*** empty log message ***

1 files changed, 40 insertions, 8 deletions

diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 4e8a603..6c1a9c0 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -2800,196 +2800,199 @@ PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* s
   int changedRemote = 0;
 
   PwMSyncItem* syncItemLocal;
   PwMSyncItem* syncItemRemote;
 
   QString mCurrentSyncName = manager->getCurrentSyncName();
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
   bool fullDateRange = false;
   int take;
   //    local->resetTempSyncStat();
   QDateTime mLastSync = QDateTime::currentDateTime();
   QDateTime modifiedSync = mLastSync;
 
   unsigned int index;
   //Step 1. Find syncinfo in Local file and create if not existent.
   bool found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
   if (found == false)
     {
       PwMSyncItem newSyncItemLocal;
       newSyncItemLocal.syncName = mCurrentSyncDevice;
       newSyncItemLocal.lastSyncDate = mLastSync;
       syncLocal->addSyncDataEntry(&newSyncItemLocal, true);
       found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
       if (found == false) {
         qDebug("PwMDoc::syncronize : newly created local sync data could not be found");
         return e_syncError;
       }
             }
 
   syncItemLocal = syncLocal->getSyncDataEntry(index); 
   qDebug("Last Sync %s ", syncItemLocal->lastSyncDate.toString().latin1());
 
   //Step 2. Find syncinfo in remote file and create if not existent.
   found = syncRemote->findSyncData(mCurrentSyncName, &index);
   if (found == false)
     {
       qDebug("FULLDATE 1");
       fullDateRange = true;
       PwMSyncItem newSyncItemRemote;
       newSyncItemRemote.syncName = mCurrentSyncName;
       newSyncItemRemote.lastSyncDate = mLastSync;
       syncRemote->addSyncDataEntry(&newSyncItemRemote, true);
       found = syncRemote->findSyncData(mCurrentSyncName, &index);
       if (found == false) {
         qDebug("PwMDoc::syncronize : newly created remote sync data could not be found");
         return e_syncError;
       }
     }
   
   syncItemRemote = syncRemote->getSyncDataEntry(index); 
   //and remove the found entry here. We will reenter it later again.
   syncRemote->delSyncDataEntry(index, true);
 
 
   if ( syncItemLocal->lastSyncDate == mLastSync ) {
     qDebug("FULLDATE 2");
     fullDateRange = true;
   }
   
   if ( ! fullDateRange  ) {
         if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
             
             // qDebug("set fulldate to true %s %s" ,addresseeLSync->dtStart().toString().latin1(), addresseeRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", addresseeLSync->dtStart().time().second(), addresseeLSync->dtStart().time().msec() , addresseeRSync->dtStart().time().second(), addresseeRSync->dtStart().time().msec());
             fullDateRange = true;
             qDebug("FULLDATE 3 %s %s", syncItemLocal->lastSyncDate.toString().latin1() , syncItemRemote->lastSyncDate.toString().latin1() );
         } 
     }
     // fullDateRange = true; // debug only!
     if ( fullDateRange )
         mLastSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastSync = syncItemLocal->lastSyncDate;
 
 
     qDebug("*************************** ");
     // qDebug("mLastAddressbookSync %s ",mLastAddressbookSync.toString().latin1() );
     QStringList er = syncRemote->getIDEntryList(); 
     PwMDataItem* inRemote ;//= er.first();
     PwMDataItem* inLocal;
     unsigned int catLocal, indexLocal;
     unsigned int catRemote, indexRemote;
 
     QString uid;
     manager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
 
     int modulo = (er.count()/10)+1;
     unsigned int incCounter = 0;
     while ( incCounter < er.count()) {
         if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
           manager->showProgressBar(incCounter);
 
         uid = er[ incCounter ]; 
+        qDebug("sync uid %s from remote file", uid.latin1());
+
         qApp->processEvents();
 
             inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
             inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
+            PWM_ASSERT(inRemote);
             if ( inLocal != 0 ) { // maybe conflict - same uid in both files
                 if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
                     //qDebug("take %d %s ", take, inL.summary().latin1());
                     if ( take == 3 )
                         return e_syncError;
                     if ( take == 1  ) {// take local
                         //US                        syncRemote->removeAddressee( inRemote );
                         (*inRemote) = (*inLocal);
                         //US                        syncRemote->insertAddressee(  inRemote , false);
                         ++changedRemote;
                     } else { // take == 2  take remote
                       //US                        syncLocal->removeAddressee( inLocal );
                         (*inLocal) = (*inRemote);
                         //US                        syncLocal->insertAddressee(  inLocal , false );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                     if ( inRemote->meta.update > mLastSync || mode == 5 ) {
                         inRemote->meta.update = modifiedSync;
                         //US                        syncRemote->insertAddressee( inRemote, false );
                         //US                        syncLocal->insertAddressee( inRemote, false );
                         syncLocal->addEntry("newcategory", inRemote, true, false);
 
                         ++addedPasswordsLocal;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
                         syncRemote->delEntry(catRemote, indexRemote, true);
                         //USsyncRemote->removeAddressee( inRemote );
                         ++deletedPasswordsRemote; 
                     }
             }
 
         ++incCounter;
     }
 
 
     er.clear();
     QStringList el = syncLocal->getIDEntryList(); 
     modulo = (el.count()/10)+1;
 
     manager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
         if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
           manager->showProgressBar(incCounter);
         uid = el[ incCounter ]; 
 
         inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
         inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
         if ( inRemote == 0 ) { 
                 if ( inLocal->meta.update < mLastSync && mode != 4 ) {
                     // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                     syncLocal->delEntry(catLocal, indexLocal, true);
                         //USsyncLocal->removeAddressee( inLocal );
                     ++deletedPasswordsLocal; 
                 } else {
                     if ( ! PWMPrefs::instance()->mWriteBackExistingOnly ) {
                         ++addedPasswordsRemote; 
                         inLocal->meta.update = modifiedSync;
                         //USsyncLocal->insertAddressee( inLocal, false );
                         (*inRemote) = (*inLocal);
                         //USsyncRemote->insertAddressee( inRemote, false );
                         syncRemote->addEntry("newcategory", inRemote, true, false);
 
                     }
                 }
 
         }
         ++incCounter;
     }
     el.clear();
     manager->hideProgressBar();
 
     // Now write the info back into the sync data space of the files
 
     mLastSync = QDateTime::currentDateTime().addSecs( 1 );
     // get rid of micro seconds
     QTime t =  mLastSync.time();
     mLastSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
 
    
     syncItemLocal->lastSyncDate = mLastSync;
     syncItemRemote->lastSyncDate = mLastSync;
 
     //    addresseeRSync.setRole( i18n("!Remote from: ")+mCurrentSyncName ) ;
     //    addresseeLSync.setRole(i18n("!Local from: ") + mCurrentSyncName  );
 
     syncRemote->addSyncDataEntry( syncItemRemote, false );
     syncLocal->addSyncDataEntry( syncItemLocal, false );
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedPasswordsLocal, addedPasswordsRemote, changedLocal, changedRemote, deletedPasswordsLocal, deletedPasswordsRemote ); 
     if ( PWMPrefs::instance()->mShowSyncSummary ) {
@@ -3001,212 +3004,241 @@ PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* s
 
 
 int PwMDoc::takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full )
 {
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime localMod = local->meta.update;
     QDateTime remoteMod = remote->meta.update;
 
     //US    QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
 
      if ( localMod == remoteMod )
        return 0;
         
     qDebug(" %d %d conflict on %s %s ", mode, full, local->desc.c_str(), remote->desc.c_str() );
 
     //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);  
     //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
     //full = true; //debug only
     if ( full ) {
       bool equ = true;//US ( (*local) == (*remote) );
         if ( equ ) {
             //qDebug("equal ");
             if ( mode < SYNC_PREF_FORCE_LOCAL )
                 return 0;
               
         }//else //debug only
         //qDebug("not equal %s %s ", local->summary().latin1(), remote->summary().latin1());
     }
     
     int result;
     bool localIsNew;
     //qDebug("%s -- %s mLastCalendarSync %s lastsync %s --- local %s remote %s ",local->summary().latin1(), remote->summary().latin1(),mLastCalendarSync.toString().latin1() ,lastSync.toString().latin1()  ,  local->lastModified().toString().latin1() , remote->lastModified().toString().latin1()  );
 
     if ( full && mode < SYNC_PREF_NEWEST )
         mode = SYNC_PREF_ASK;
 
     switch( mode ) {
     case SYNC_PREF_LOCAL:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 1;
         break;
     case SYNC_PREF_REMOTE:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 2;
         break;
     case SYNC_PREF_NEWEST:
         if ( localMod > remoteMod )
             return 1;
         else
             return 2;
         break;
     case SYNC_PREF_ASK: 
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         localIsNew = localMod >= remoteMod;
         //qDebug("conflict! ************************************** ");
         {
           PwMDataItemChooser acd ( *local,*remote, localIsNew , 0/*this*/ );
             result = acd.executeD(localIsNew);
             return result;
         }
         break;
     case SYNC_PREF_FORCE_LOCAL:
         return 1;
         break;
     case SYNC_PREF_FORCE_REMOTE:
         return 2;
         break;
        
     default:
         // SYNC_PREF_TAKE_BOTH not implemented
         break;
     }
     return 0;
 }
 
 
 
 
 //this are the overwritten callbackmethods from the syncinterface
 bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
 {
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
-  // construct on the stack = automatic cleanup.
+  //1) unlock local file first if necessary (ask for password)
+  if (this->isDeepLocked()) {
+    PwMerror ret = this->deepLock(false);
+    if (ret != e_success)
+      return false;
+  }
+
+  //2)  construct and open a new doc on the stack(automatic cleanup) for remote file.
   PwMDoc syncTarget(this, "synctarget");
+  PwMDoc* pSyncTarget = &syncTarget;
+
 
-  PwMerror err = syncTarget.openDoc(&filename, 2 /*== deeplocked*/);
+  PwMerror err = pSyncTarget->openDoc(&filename, 1 /*== open with all entries locked*/);
 
-  if (err != e_success)
+  if (err == e_alreadyOpen) {
+    PwMDocList::listItem li;
+    if (getOpenDocList()->find(filename.latin1(), &li))
+      pSyncTarget = li.doc;
+    else {
+      qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
+      return false;
+    }
+  }
+  else if (err != e_success) {
+    qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
     return false;
-  
+  }
+
   qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode );
 
+
+  //3) unlock remote file first if necessary (ask for password)
+  if (pSyncTarget->isDeepLocked()) {
+    PwMerror ret = pSyncTarget->deepLock(false);
+    if (ret != e_success)
+      return false;
+  }
+
   
-  err = syncronize(manager, this, &syncTarget, mode );
+  err = syncronize(manager, this, pSyncTarget, mode );
 
   if (err == e_success) {
             if ( PWMPrefs::instance()->mWriteBackFile ){
       qDebug("Saving remote PWManager file");
-      err = syncTarget.saveDoc(conf()->confGlobCompression());
-      if (err != e_success)
+      err = pSyncTarget->saveDoc(conf()->confGlobCompression());
+      if (err != e_success) {
+        qDebug("PwmDoc::sync: Sync failed. Error %i while storing file %s",err, filename.latin1());
         return false;
-
+      }
     }
 
     flagDirty();
     return true;
   }
   else {
     return false;
   }
 }
 
 //called by the syncmanager to indicate that the work has to marked as dirty.
 void PwMDoc::sync_setModified()
 {
   flagDirty();
 }
 
 //called by the syncmanager to ask if the dirty flag is set.
 bool PwMDoc::sync_isModified()
 {
   return isDirty();
 }
 
 //called by the syncmanager to indicate that the work has to be saved.
 void PwMDoc::sync_save()
 {
   saveDoc(conf()->confGlobCompression());
 }
 #endif
 
 
 bool PwMDoc::findSyncData(const QString &syncname, unsigned int *index)
 {
         vector<PwMSyncItem>::iterator i = dti.syncDta.begin(), 
                                       end = dti.syncDta.end();
 
         while (i != end) {
                 if ((*i).syncName == syncname.latin1()) {
                         if (index) {
                                 *index = i - dti.syncDta.begin();
                         }
                         return true;
                 }
                 ++i;
         }
         return false;
 };
 
 /** add new syncdataentry */
 PwMerror PwMDoc::addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty)
 {
         PWM_ASSERT(d);
 
         if (isDeepLocked()) {
                 PwMerror ret;
                 ret = deepLock(false);
                 if (ret != e_success)
                         return e_lock;
         }
         unsigned int index;
 
         const QString tmp = d->syncName.c_str();
         bool exists = findSyncData(d->syncName.c_str(), &index);
 
         if (exists == true) {
                 // DOH! We found this entry.
                 return e_entryExists;
         }
 
         dti.syncDta.push_back(*d);
 
         if (!dontFlagDirty)
                 flagDirty();
         return e_success;
 }
 
 
 
 /** delete syncdata entry */
 bool PwMDoc::delSyncDataEntry(unsigned int index, bool dontFlagDirty)
 {
         if (isDeepLocked())
                 return false;
         if (index > dti.syncDta.size() - 1)
                 return false;
 
         // delete entry
         dti.syncDta.erase(dti.syncDta.begin() + index);
 
         if (!dontFlagDirty)
                 flagDirty();
         return true;
 }
 
 
 PwMDataItem* PwMDoc::findEntryByID(const QString &uid, unsigned int *category, unsigned int *index)
 {