source/actmgr/frmActivityMgr.cpp

   1 // frmActivityMgr.cpp - Activity Manager form.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "frmActivityMgr.h"
  20 #include <wx/mstream.h>
  21 #include <wx/file.h>
  22 #include <wx/ffile.h>
  23 #include <wx/tokenzr.h>
  24 #include <wx/dir.h>
  25 #include <wx/filefn.h>
  26 #include <thread>
  27 #include <list>
  28 #include <curl/curl.h>
  29
  30 #include "../bitmaps.h"
  31 #include "../enums.h"
  32 #include "../common/preferences.h"
  33 #include "../frmConflictResolution.h"
  34 #include "../frmInvalidSSLCertificate.h"
  35 #include "../frmMain.h"
  36 #include "../common/events.h"
  37 #include "../common/filename.h"
  38 #include "../vcard/vcard34conv.h"
  39 #include "../vcard/vcard.h"
  40
  41 DEFINE_EVENT_TYPE(ACTMGR_RESUMEPROC);
  42 DEFINE_EVENT_TYPE(ACTMGR_TOGGLECONN);
  43 DEFINE_EVENT_TYPE(ACTMGR_STARTTIMER);
  44 DEFINE_EVENT_TYPE(ACTMGR_STOPTIMER);
  45 DEFINE_EVENT_TYPE(ACTMGR_STARTPROCESSTIMER);
  46 DEFINE_EVENT_TYPE(ACTMGR_STOPPROCESSTIMER);
  47 DEFINE_EVENT_TYPE(ACTMGR_UPDATESTATUSLABEL);
  48
  49 BEGIN_EVENT_TABLE(frmActivityMgr, wxWindow)
  50   EVT_COMMAND(wxID_ANY, ACTMGR_RESUMEPROC, frmActivityMgr::ResumeProcessing)
  51   EVT_COMMAND(wxID_ANY, ACTMGR_TOGGLECONN, frmActivityMgr::ToggleConnectionStatus)
  52   EVT_COMMAND(wxID_ANY, ACTMGR_STARTTIMER, frmActivityMgr::StartTimer)
  53   EVT_COMMAND(wxID_ANY, ACTMGR_STOPTIMER, frmActivityMgr::StopTimer)
  54   EVT_COMMAND(wxID_ANY, ACTMGR_STARTPROCESSTIMER, frmActivityMgr::StartProcessTimer)
  55   EVT_COMMAND(wxID_ANY, ACTMGR_STOPPROCESSTIMER, frmActivityMgr::StopProcessTimer)
  56   EVT_COMMAND(wxID_ANY, ACTMGR_UPDATESTATUSLABEL, frmActivityMgr::UpdateStatusLabel)
  57 END_EVENT_TABLE()
  58
  59 frmActivityMgr::frmActivityMgr( wxWindow* parent )
  60 :
  61 frmActivityMgrADT( parent )
  62 {
  63
  64         wxMemoryInputStream istream(icons_activitywindow_png, sizeof(icons_activitywindow_png));
  65         wxImage icons_activitywindow_pngi(istream, wxBITMAP_TYPE_PNG);
  66         wxBitmap activityiconbmp(icons_activitywindow_pngi, -1);
  67         wxIcon activityicon;
  68         activityicon.CopyFromBitmap(activityiconbmp);
  69         this->SetIcon(activityicon);
  70
  71         wxMemoryInputStream istream2(misc_activitysleep_png, sizeof(misc_activitysleep_png));
  72         wxImage misc_activitysleep_pngi(istream2, wxBITMAP_TYPE_PNG);
  73         wxBitmap sleepiconbmp(misc_activitysleep_pngi, -1);
  74         SleepBitmap = sleepiconbmp;
  75         bmpActivity->SetBitmap(SleepBitmap);
  76         ActProcessTimer.SetupPointers(this);
  77         lblDetails->SetLabel(_("No activity."));
  78
  79         ActListProcTimer.SetupPointers(&ActivityList, &ActivityListIndex, &ActivityListTaskDetail,
  80                                         &TasksActive, lstActivity, lblDetails, GauProgress, this, &AnimationTimer,
  81                                         &ActProcessTimer, &ActivityListFinDate, &ActivityListConn);
  82
  83         AnimationTimer.SetBitmap(bmpActivity);
  84         AnimationTimer.SetSleepBitmap(&SleepBitmap);
  85         AnimationTimer.SetupPointer(this->GetParent());
  86
  87         wxListItem ColumnData;
  88         ColumnData.SetId(0);
  89         ColumnData.SetText(_("Activity"));
  90         ColumnData.SetWidth(175);
  91         lstActivity->InsertColumn(0, ColumnData);
  92
  93         wxListItem ColumnData2;
  94         ColumnData2.SetId(1);
  95         ColumnData2.SetText(_("Account"));
  96         ColumnData2.SetWidth(100);
  97         lstActivity->InsertColumn(1, ColumnData2);
  98
  99         wxListItem ColumnData3;
 100         ColumnData3.SetId(2);
 101         ColumnData3.SetText(_("Status"));
 102         ColumnData3.SetWidth(100);
 103         lstActivity->InsertColumn(2, ColumnData3);
 104
 105         //AnimationTimer.StartAnimation();
 106
 107         // Create recovery database if it doesn't exist.
 108
 109         wxString RecoveryFilename = GetRecoveryDB();
 110
 111         wxFile RecoveryDB;
 112
 113         if (wxFile::Exists(RecoveryFilename) == FALSE){
 114
 115                 // Create the recovery database.
 116
 117                 RecoveryDB.Open(RecoveryFilename.c_str(), wxFile::write);
 118
 119                 RecoveryDB.Write(wxT("BEGIN:XAB-RECOVERYDB\r\n"), wxConvUTF8);
 120                 RecoveryDB.Write(wxT("VERSION:1.0\r\n"), wxConvUTF8);
 121                 RecoveryDB.Write(wxT("COMMENT:Please do not alter or delete this file. DATA LOSS IS POSSIBLE!\r\n"), wxConvUTF8);
 122                 RecoveryDB.Write(wxT("END:XAB-RECOVERYDB\r\n"), wxConvUTF8);
 123                 RecoveryDB.Close();
 124
 125         }
 126
 127         wxFFile RecoveryDBF;
 128
 129 #if wxABI_VERSION < 20900
 130         RecoveryDBF.Open(RecoveryFilename.c_str(), wxT("r"));
 131 #else
 132         RecoveryDBF.Open(RecoveryFilename, wxT("r"));
 133 #endif
 134
 135         // Load the recovery database for tasks not done.
 136
 137         if (RecoveryDBF.IsOpened() == TRUE){
 138
 139                 wxString wxSRecoveryDB;
 140                 wxString RecoveryLine;
 141
 142                 // Check if we are using wxWidgets version 2.8 or less and
 143                 // execute the required command accordingly.
 144
 145                 RecoveryDBF.ReadAll(&wxSRecoveryDB, wxConvAuto());
 146
 147                 // Split the lines.
 148
 149                 std::map<int, wxString> RecoveryFileLines;
 150                 std::map<int, wxString>::iterator striter;
 151
 152                 wxStringTokenizer wSTRecoveryDBLines(wxSRecoveryDB, wxT("\r\n"));
 153
 154                 int RecoveryLineSeek = 0;
 155
 156                 while (wSTRecoveryDBLines.HasMoreTokens() == TRUE){
 157
 158                         RecoveryLine = wSTRecoveryDBLines.GetNextToken();
 159                         RecoveryFileLines.insert(std::make_pair(RecoveryLineSeek, RecoveryLine));
 160                         RecoveryLineSeek++;
 161
 162                 }
 163
 164         }
 165
 166
 167
 168         //TestTimer.Start(50, FALSE);
 169 }
 170
 171 void frmActivityMgr::OpenWindow()
 172 {
 173         WindowOpen = TRUE;
 174 }
 175
 176 void frmActivityMgr::CloseWindow( wxCommandEvent& event )
 177 {
 178         WindowOpen = FALSE;
 179         this->Hide();
 180 }
 181
 182 void frmActivityMgr::CloseWindow( wxCloseEvent& event )
 183 {
 184         WindowOpen = FALSE;
 185         this->Hide();
 186 }
 187
 188 void frmActivityMgr::ProcessTasksThread()
 189 {
 190
 191         if (ProcessTasksData == FALSE){
 192
 193                 return;
 194
 195         }
 196
 197         std::map<int,int>::iterator TypeIter;
 198         std::map<int,wxString>::iterator StringIter;
 199         std::map<int,wxString>::iterator StringDataIter;
 200         std::map<int,wxString>::iterator StringURLIter;
 201         std::map<int,wxString>::iterator StringDetailIter;
 202         std::map<int,wxString>::iterator StringAccountIter;
 203         std::map<int,wxString>::iterator StringFilenameIter;
 204         std::map<int,wxString>::iterator StringFullFilenameIter;
 205         std::map<int,wxString>::iterator StringTaskDetailIter;
 206         std::map<int,wxString>::iterator StringETagIter;
 207         std::map<int,wxString>::iterator StringETagOrigIter;
 208         std::map<int,CardDAV*>::iterator CardDAVIter;
 209         std::map<int,ActivityMgrAccountSettings>::iterator AccountSettingsIter;
 210         std::map<int,long>::iterator LongIter;
 211         bool TasksFoundProc = FALSE;
 212         wxString TaskDetail;
 213
 214         for (std::map<int,int>::iterator iter = ActivityList.begin();
 215          iter != ActivityList.end(); ++iter){
 216
 217                 // Check for any queued tasks and start one.
 218
 219                 if (iter->second > 4){
 220                         continue;
 221                 }
 222
 223                 CardDAVIter = ActivityListConn.find(iter->first);
 224                 TypeIter = ActivityListType.find(iter->first);
 225                 StringETagIter = ActivityListETag.find(iter->first);
 226                 StringETagOrigIter = ActivityListETagOriginal.find(iter->first);
 227                 StringAccountIter = ActivityListAccount.find(iter->first);
 228                 StringFilenameIter = ActivityListFilename.find(iter->first);
 229                 StringFullFilenameIter = ActivityListFullFilename.find(iter->first);
 230                 AccountSettingsIter = ActivityListAccSettings.find(iter->first);
 231
 232                 // Setup the CardDAV object.
 233
 234                 CardDAV ConnHandle;
 235
 236                 ConnHandle.SetupConnection(AccountSettingsIter->second.Address,
 237                                          AccountSettingsIter->second.Port,
 238                                          AccountSettingsIter->second.Username,
 239                                          AccountSettingsIter->second.Password,
 240                                          AccountSettingsIter->second.SSL,
 241                                          AccountSettingsIter->second.Prefix,
 242                                          AccountSettingsIter->second.Dir);
 243                 ConnHandle.SetupVariables(&ActivityList, iter->first);
 244                 ConnHandle.SetupResultBools(&BlankBool, &BlankBool);
 245
 246                 // 0 = Queued.
 247                 // 1 = Processing.
 248                 // 2 = Failed.
 249                 // 3 = Stopped.
 250                 // 4 = Completed.
 251                 // 5 = Failed (UI Updated).
 252                 // 6 = Stopped (UI Updated).
 253                 // 7 = (Reserved) (UI Updated).
 254                 // 8 = Completed. (UI Updated).
 255
 256                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 257                 XABPreferences PrefData(GetUserPrefDir());
 258
 259                 if (iter->second == 0){
 260
 261                         //CardDAVIter->second.
 262
 263                         // Wait for process to finish.
 264
 265                         TasksActive = TRUE;
 266                         TasksFoundProc = TRUE;
 267                         wxString ETag;
 268                         wxString ETagOriginal;
 269                         wxString ETagServer;
 270                         wxString AccountDir;
 271                         wxString ContactFilename;
 272                         wxString FullFilename;
 273                         wxString ETagResult;
 274                         bool EditMode = FALSE;
 275
 276                         iter->second = 1;
 277
 278                         // Compare the ETags and work out if a conflict has occured.
 279
 280                         if (TypeIter->second == 0){
 281
 282                                 // Add a contact.
 283
 284                                 StringDataIter = ActivityListData.find(iter->first);
 285                                 StringURLIter = ActivityListURL.find(iter->first);
 286
 287                                 AccountDir = StringAccountIter->second;
 288                                 ContactFilename = StringFilenameIter->second;
 289                                 wxString AccountNameFriendly;
 290
 291                                 int AccountID = 0;
 292
 293                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
 294
 295                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
 296
 297                                         AccountDirCheck.Trim();
 298                                         AccountDirCheck.Append(wxT(".carddav"));
 299
 300                                         if (AccountDirCheck == StringAccountIter->second){
 301
 302                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
 303                                                 AccountID = i;
 304
 305                                         }
 306
 307                                 }
 308
 309                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 310
 311                                 ETag = StringETagIter->second;
 312                                 ETagOriginal = StringETagOrigIter->second;
 313                                 AccountDir = StringAccountIter->second;
 314                                 ContactFilename = StringFilenameIter->second;
 315                                 FullFilename = StringFullFilenameIter->second;
 316                                 EditMode = ActivityListEditMode.find(iter->first)->second;
 317
 318                                 bool KeepUpdating = TRUE;
 319
 320                                 while(KeepUpdating == TRUE){
 321
 322                                         bool ExitLoop = FALSE;
 323
 324                                         while (ExitLoop == FALSE){
 325
 326                                                 // Verify that we have a trusted SSL connection first.
 327
 328                                                 int ErrorCode = ConnHandle.SSLVerifyTest();
 329
 330                                                 if (ErrorCode != CURLE_OK){
 331
 332                                                         if (ErrorCode == CURLE_SSL_CACERT ||
 333                                                                 ErrorCode == CURLE_PEER_FAILED_VERIFICATION ||
 334                                                                 ErrorCode == CURLE_SSL_CONNECT_ERROR){
 335
 336                                                                 // Invalid SSL certificate so bring up a dialog to the user
 337                                                                 // explaining what has happened and the options available.
 338
 339                                                                 // Stop all the timers.
 340
 341                                                                 frmMainPtrGet->PauseAllTimers();
 342
 343                                                                 int SSLResult;
 344
 345 #if defined(__APPLE__)
 346
 347                                                                 // Bring up the trust panel and display the SSL certificate dialog.
 348
 349                                                                 SSLResult = DisplayTrustPanel(ConnHandle.GetTrustObject(), AccountNameFriendly);
 350
 351                                                                 // Update the SSL account with the trust object.
 352
 353                                                                 if (SSLResult != NSOKButton){
 354
 355                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetTrustObject());
 356                                                                         iter->second = 2;
 357                                                                         break;
 358
 359                                                                 } else {
 360
 361                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 362
 363
 364                                                                 }
 365
 366 #elif defined(__WIN32__)
 367
 368                                                                 BOOL ModifiedCertificateData;
 369                                                                 CRYPTUI_VIEWCERTIFICATE_STRUCTW CertificateData = BuildCertificateData(&ConnHandle, (HWND)frmMainPtrGet->GetHandle());
 370
 371                                                                 if (!CryptUIDlgViewCertificate(&CertificateData, &ModifiedCertificateData)){
 372                                                                         wxMessageBox(_("An error occured while trying to open the certificate dialog."), _("Error opening Certificate Information dialog"));
 373                                                                 }
 374
 375                                                                 if (ModifiedCertificateData == FALSE){
 376
 377                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetCertificateContextPointer());
 378                                                                         iter->second = 2;
 379                                                                         break;
 380
 381                                                                 } else {
 382
 383                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
 384
 385                                                                 }
 386
 387 #else
 388
 389                                                                 // Setup the data to be sent in the wxPostEvent command.
 390
 391                                                                 SSLInvalidCertNotifObj SSLICNProcData;
 392
 393                                                                 SSLCertCollection certcol = ConnHandle.GetSSLVerifyResults();
 394
 395                                                                 bool *PauseMode = new bool;
 396                                                                 QRNotif qrn;
 397
 398                                                                 *PauseMode = TRUE;
 399                                                                 qrn.QResponse = &SSLResult;
 400                                                                 qrn.PausePtr = PauseMode;
 401
 402                                                                 SSLICNProcData.CertCollection = certcol;
 403                                                                 SSLICNProcData.QRNotifData = &qrn;
 404                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
 405
 406                                                                 wxCommandEvent event(INVALIDSSLCERT);
 407                                                                 event.SetClientData(&SSLICNProcData);
 408                                                                 wxPostEvent(frmMainPtrGet, event);
 409
 410                                                                 /*timespec n1, n2;
 411
 412                                                                         // Fall asleep until we get an response.
 413
 414                                                                         n1.tv_sec = 0;
 415                                                                         n1.tv_nsec = 250000000L;*/
 416
 417                                                                 while (*PauseMode == TRUE){
 418                                                                         //nanosleep(&n1, &n2);
 419                                                                         SleepFor(250000000);
 420                                                                 }
 421
 422                                                                 // Process the response from the user.
 423
 424                                                                 if (SSLResult == 1){
 425
 426                                                                         // Accept the certificate. Write the certificate into the account
 427                                                                         // directory (as server.crt) - will overwrite old certificate.
 428
 429                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateData());
 430                                                                         WriteServerCertificate(AccountDir, ConnHandle.GetCertificateData());
 431
 432                                                                 } else if (SSLResult == 2){
 433
 434                                                                         // Reject the certificate, abort the task and mark as failed.
 435
 436                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetCertificateData());
 437                                                                         iter->second = 2;
 438                                                                         break;
 439
 440                                                                 }
 441
 442 #endif
 443
 444                                                                 // Resume all the timers.
 445
 446                                                                 frmMainPtrGet->ResumeAllTimers();
 447                                                                 ExitLoop = TRUE;
 448
 449                                                         } else {
 450
 451                                                                 iter->second = 2;
 452                                                                 break;
 453
 454                                                         }
 455
 456                                                 } else {
 457
 458                                                         ExitLoop = TRUE;
 459
 460                                                 }
 461
 462                                         }
 463
 464                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
 465                                                 break;
 466                                         }
 467
 468 #if defined(__APPLE__)
 469
 470                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 471
 472 #elif defined(__WIN32__)
 473
 474                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
 475
 476 #else
 477
 478                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateData());
 479
 480 #endif
 481
 482                                         ConnHandle.SetUploadMode(TRUE);
 483                                         ConnHandle.SetupData(wxT("PUT"), StringURLIter->second, StringDataIter->second);
 484                                         ConnHandle.SetEditMode(EditMode);
 485                                         ConnHandle.ProcessData();
 486
 487                                         int ErrorCode = ConnHandle.GetResultCode();
 488
 489                                         if (ErrorCode != CURLE_OK){
 490
 491                                                 iter->second = 4;
 492                                                 break;
 493
 494                                         }
 495
 496                                         // Add contact to the ETag DB.
 497
 498                                         ConnHandle.GetServerETagValueThread();
 499                                         ETagServer = ConnHandle.ETagValueResult();
 500                                         ETagDBPtr->AddETag(ContactFilename, ETagServer, ETagServer);
 501
 502                                         iter->second = 4;
 503                                         break;
 504
 505                                 }
 506
 507                         } else if (TypeIter->second == 1){
 508
 509                                 // Update a contact.
 510
 511                                 StringDataIter = ActivityListData.find(iter->first);
 512                                 StringURLIter = ActivityListURL.find(iter->first);
 513
 514                                 AccountDir = StringAccountIter->second;
 515                                 ContactFilename = StringFilenameIter->second;
 516                                 wxString AccountNameFriendly;
 517
 518                                 int AccountID = 0;
 519
 520                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
 521
 522                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
 523
 524                                         AccountDirCheck.Trim();
 525                                         AccountDirCheck.Append(wxT(".carddav"));
 526
 527                                         if (AccountDirCheck == StringAccountIter->second){
 528
 529                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
 530                                                 AccountID = i;
 531
 532                                         }
 533
 534                                 }
 535
 536                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 537
 538                                 ETag = StringETagIter->second;
 539                                 ETagOriginal = StringETagOrigIter->second;
 540                                 AccountDir = StringAccountIter->second;
 541                                 ContactFilename = StringFilenameIter->second;
 542                                 FullFilename = StringFullFilenameIter->second;
 543                                 EditMode = ActivityListEditMode.find(iter->first)->second;
 544
 545                                 bool KeepUpdating = TRUE;
 546
 547                                 while(KeepUpdating == TRUE){
 548
 549                                         bool ExitLoop = FALSE;
 550
 551                                         while (ExitLoop == FALSE){
 552
 553                                                 int ErrorCode = ConnHandle.SSLVerifyTest();
 554
 555                                                 if (ErrorCode != CURLE_OK){
 556
 557                                                         if (ErrorCode == CURLE_SSL_CACERT ||
 558                                                                 ErrorCode == CURLE_PEER_FAILED_VERIFICATION ||
 559                                                                 ErrorCode == CURLE_SSL_CONNECT_ERROR){
 560
 561                                                                 // Invalid SSL certificate so bring up a dialog to the user
 562                                                                 // explaining what has happened and the options available.
 563
 564                                                                 // Stop all the timers.
 565
 566                                                                 frmMainPtrGet->PauseAllTimers();
 567
 568                                                                 int SSLResult;
 569
 570 #if defined(__APPLE__)
 571
 572                                                                 // Bring up the trust panel and display the SSL certificate dialog.
 573
 574                                                                 SSLResult = DisplayTrustPanel(ConnHandle.GetTrustObject(), AccountNameFriendly);
 575
 576                                                                 // Update the SSL account with the trust object.
 577
 578                                                                 if (SSLResult != NSOKButton){
 579
 580                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetTrustObject());
 581                                                                         iter->second = 2;
 582                                                                         break;
 583
 584                                                                 } else {
 585
 586                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 587
 588                                                                 }
 589
 590 #elif defined(__WIN32__)
 591
 592                                                                 BOOL ModifiedCertificateData;
 593                                                                 CRYPTUI_VIEWCERTIFICATE_STRUCTW CertificateData = BuildCertificateData(&ConnHandle, (HWND)frmMainPtrGet->GetHandle());
 594
 595                                                                 if (!CryptUIDlgViewCertificate(&CertificateData, &ModifiedCertificateData)){
 596                                                                         wxMessageBox(_("An error occured while trying to open the certificate dialog."), _("Error opening Certificate Information dialog"));
 597                                                                 }
 598
 599                                                                 if (ModifiedCertificateData == FALSE){
 600
 601                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetCertificateContextPointer());
 602                                                                         iter->second = 2;
 603                                                                         break;
 604
 605                                                                 } else {
 606
 607                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
 608
 609                                                                 }
 610
 611 #else
 612
 613                                                                 // Setup the data to be sent in the wxPostEvent command.
 614
 615                                                                 SSLInvalidCertNotifObj SSLICNProcData;
 616
 617                                                                 SSLCertCollection certcol = ConnHandle.GetSSLVerifyResults();
 618
 619                                                                 bool *PauseMode = new bool;
 620                                                                 QRNotif qrn;
 621
 622                                                                 *PauseMode = TRUE;
 623                                                                 qrn.QResponse = &SSLResult;
 624                                                                 qrn.PausePtr = PauseMode;
 625
 626                                                                 SSLICNProcData.CertCollection = certcol;
 627                                                                 SSLICNProcData.QRNotifData = &qrn;
 628                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
 629
 630                                                                 wxCommandEvent event(INVALIDSSLCERT);
 631                                                                 event.SetClientData(&SSLICNProcData);
 632                                                                 wxPostEvent(frmMainPtrGet, event);
 633
 634                                                                 while (*PauseMode == TRUE){
 635                                                                         //nanosleep(&n1, &n2);
 636                                                                         SleepFor(250000000);
 637                                                                 }
 638
 639                                                                 // Process the response from the user.
 640
 641                                                                 if (SSLResult == 1){
 642
 643                                                                         // Accept the certificate. Write the certificate into the account
 644                                                                         // directory (as server.crt) - will overwrite old certificate.
 645
 646                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
 647                                                                         WriteServerCertificate(AccountDir, ConnHandle.GetSSLVerifyResults());
 648
 649                                                                 } else if (SSLResult == 2){
 650
 651                                                                         // Reject the certificate, abort the task and mark as failed.
 652
 653                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetSSLVerifyResults());
 654                                                                         iter->second = 2;
 655                                                                         break;
 656
 657                                                                 }
 658
 659 #endif
 660
 661                                                                 // Resume all the timers.
 662
 663                                                                 frmMainPtrGet->ResumeAllTimers();
 664                                                                 ExitLoop = TRUE;
 665
 666                                                         } else {
 667
 668                                                                 iter->second = 2;
 669                                                                 break;
 670
 671                                                         }
 672
 673                                                 } else {
 674
 675                                                         ExitLoop = TRUE;
 676
 677                                                 }
 678
 679                                         }
 680
 681                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
 682                                                 break;
 683                                         }
 684
 685 #if defined(__APPLE__)
 686
 687                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 688
 689 #elif defined(__WIN32__)
 690
 691                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
 692
 693 #else
 694
 695                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
 696
 697 #endif
 698
 699                                         ConnHandle.SetUploadMode(TRUE);
 700                                         ConnHandle.SetupData(wxT("PUT"), StringURLIter->second, StringDataIter->second);
 701                                         ConnHandle.SetEditMode(EditMode);
 702                                         ConnHandle.GetServerETagValueThread();
 703                                         ETagServer = ConnHandle.ETagValueResult();
 704
 705                                         int ErrorCode = ConnHandle.GetResultCode();
 706
 707                                         if (ErrorCode != CURLE_OK){
 708                                                 iter->second = 2;
 709                                                 break;
 710                                         }
 711
 712                                         // Compare the ETag with the Server ETag.
 713
 714                                         if (ETagOriginal != ETagServer){
 715
 716                                                 // Server ETag is different from original ETag.
 717                                                 // This is a conflict which the user will now
 718                                                 // need to resolve.
 719
 720                                                 vCard Moo1;
 721                                                 vCard Moo2;
 722
 723                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 724
 725                                                 vCard34Conv vCard34Obj;
 726
 727                                                 wxString ServerContactData;
 728                                                 vCard ClientData;
 729                                                 vCard ConvertedV4Data;
 730
 731                                                 // Load the client data from the filename given.
 732
 733                                                 ConnHandle.GetServerContactData();
 734                                                 ServerContactData = ConnHandle.GetPageData();
 735
 736                                                 // Process v3 version into v4 version.
 737
 738                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
 739
 740                                                 vCardConflictObj vCardProcData;
 741
 742                                                 vCardProcData.vCardLocalData = &ClientData;
 743                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
 744                                                 ClientData.LoadFile(FullFilename);
 745
 746                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
 747                                                 //event.SetData(ContactFilename, Moo1, Moo2);
 748
 749                                                 //wxPostEvent(frmMainPtrGet, event);
 750
 751                                                 // Setup Conflict Resolution Dialog.
 752
 753                                                 // Fetch Data from Server and convert.
 754
 755                                                 bool *PauseMode = new bool;
 756                                                 int ConflictResult;
 757                                                 QRNotif qrn;
 758
 759                                                 *PauseMode = TRUE;
 760                                                 qrn.QResponse = &ConflictResult;
 761                                                 qrn.PausePtr = PauseMode;
 762
 763                                                 vCardProcData.QRNotifData = &qrn;
 764
 765                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
 766                                                 event.SetClientData(&vCardProcData);
 767                                                 wxPostEvent(frmMainPtrGet, event);
 768
 769                                                 while (*PauseMode == TRUE){
 770                                                         //nanosleep(&n1, &n2);
 771                                                         SleepFor(250000000);
 772                                                 }
 773
 774                                                 delete PauseMode;
 775                                                 PauseMode = NULL;
 776
 777                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
 778
 779                                                 if (ConflictResult == 0){
 780
 781                                                         // Decide Later.
 782
 783                                                         iter->second = 4;
 784                                                         break;
 785
 786                                                 } else if (ConflictResult == 1){
 787
 788                                                         // Decided to use client version.
 789
 790                                                         ConnHandle.ProcessData();
 791
 792                                                 } else if (ConflictResult == 2){
 793
 794                                                         // Decided to use server version.
 795
 796                                                         // Download server version.
 797
 798                                                         ConvertedV4Data.WriteFile(FullFilename);
 799
 800                                                 }
 801
 802                                         } else {
 803
 804                                                 // Update the data to the server.
 805
 806                                                 ConnHandle.ProcessData();
 807
 808                                         }
 809
 810                                         // Update the ETag DB.
 811
 812                                         ConnHandle.GetServerETagValueThread();
 813                                         ETagServer = ConnHandle.ETagValueResult();
 814                                         ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
 815
 816                                         iter->second = 4;
 817                                         break;
 818
 819                                 }
 820
 821                         } else if (TypeIter->second == 2) {
 822
 823                                 // Delete the contact from the server and update the ETag DB.
 824
 825                                 AccountDir = StringAccountIter->second;
 826                                 ContactFilename = StringFilenameIter->second;
 827                                 wxString AccountNameFriendly;
 828
 829                                 int AccountID = 0;
 830
 831                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
 832
 833                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
 834
 835                                         AccountDirCheck.Trim();
 836                                         AccountDirCheck.Append(wxT(".carddav"));
 837
 838                                         if (AccountDirCheck == StringAccountIter->second){
 839
 840                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
 841                                                 AccountID = i;
 842
 843                                         }
 844
 845                                 }
 846
 847                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 848
 849                                 bool KeepUpdating = TRUE;
 850
 851                                 while(KeepUpdating == TRUE){
 852
 853                                         bool ExitLoop = FALSE;
 854
 855                                         while (ExitLoop == FALSE){
 856
 857                                                 int ErrorCode = ConnHandle.SSLVerifyTest();
 858
 859                                                 if (ErrorCode != CURLE_OK){
 860
 861                                                         if (ErrorCode == CURLE_SSL_CACERT ||
 862                                                                 ErrorCode == CURLE_PEER_FAILED_VERIFICATION ||
 863                                                                 ErrorCode == CURLE_SSL_CONNECT_ERROR){
 864
 865                                                                 // Invalid SSL certificate so bring up a dialog to the user
 866                                                                 // explaining what has happened and the options available.
 867
 868                                                                 // Stop all the timers.
 869
 870                                                                 frmMainPtrGet->PauseAllTimers();
 871
 872                                                                 int SSLResult;
 873
 874 #if defined(__APPLE__)
 875
 876                                                                 // Bring up the trust panel and display the SSL certificate dialog.
 877
 878                                                                 SSLResult = DisplayTrustPanel(ConnHandle.GetTrustObject(), AccountNameFriendly);
 879
 880                                                                 // Update the SSL account with the trust object.
 881
 882                                                                 if (SSLResult != NSOKButton){
 883
 884                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetTrustObject());
 885                                                                         iter->second = 2;
 886                                                                         break;
 887
 888                                                                 } else {
 889
 890                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 891
 892                                                                 }
 893
 894 #elif defined(__WIN32__)
 895
 896                                                                 BOOL ModifiedCertificateData;
 897                                                                 CRYPTUI_VIEWCERTIFICATE_STRUCTW CertificateData = BuildCertificateData(&ConnHandle, (HWND)frmMainPtrGet->GetHandle());
 898
 899                                                                 if (!CryptUIDlgViewCertificate(&CertificateData, &ModifiedCertificateData)){
 900                                                                         wxMessageBox(_("An error occured while trying to open the certificate dialog."), _("Error opening Certificate Information dialog"));
 901                                                                 }
 902
 903                                                                 if (ModifiedCertificateData == FALSE){
 904
 905                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetCertificateContextPointer());
 906                                                                         iter->second = 2;
 907                                                                         break;
 908
 909                                                                 } else {
 910
 911                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
 912
 913                                                                 }
 914
 915 #else
 916
 917                                                                 // Setup the data to be sent in the wxPostEvent command.
 918
 919                                                                 SSLInvalidCertNotifObj SSLICNProcData;
 920
 921                                                                 SSLCertCollection certcol = ConnHandle.GetSSLVerifyResults();
 922
 923                                                                 bool *PauseMode = new bool;
 924                                                                 QRNotif qrn;
 925
 926                                                                 *PauseMode = TRUE;
 927                                                                 qrn.QResponse = &SSLResult;
 928                                                                 qrn.PausePtr = PauseMode;
 929
 930                                                                 SSLICNProcData.CertCollection = certcol;
 931                                                                 SSLICNProcData.QRNotifData = &qrn;
 932                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
 933
 934                                                                 wxCommandEvent event(INVALIDSSLCERT);
 935                                                                 event.SetClientData(&SSLICNProcData);
 936                                                                 wxPostEvent(frmMainPtrGet, event);
 937
 938                                                                 /*timespec n1, n2;
 939
 940                                                                         // Fall asleep until we get an response.
 941
 942                                                                         n1.tv_sec = 0;
 943                                                                         n1.tv_nsec = 250000000L;*/
 944
 945                                                                 while (*PauseMode == TRUE){
 946                                                                         //nanosleep(&n1, &n2);
 947                                                                         SleepFor(250000000);
 948                                                                 }
 949
 950                                                                 // Process the response from the user.
 951
 952                                                                 if (SSLResult == 1){
 953
 954                                                                         // Accept the certificate. Write the certificate into the account
 955                                                                         // directory (as server.crt) - will overwrite old certificate.
 956
 957                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
 958                                                                         WriteServerCertificate(AccountDir, ConnHandle.GetSSLVerifyResults());
 959
 960                                                                 } else if (SSLResult == 2){
 961
 962                                                                 // Reject the certificate, abort the task and mark as failed.
 963
 964                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetSSLVerifyResults());
 965                                                                         iter->second = 2;
 966                                                                         break;
 967
 968                                                                 }
 969
 970 #endif
 971
 972                                                                 // Resume all the timers.
 973
 974                                                                 frmMainPtrGet->ResumeAllTimers();
 975                                                                 ExitLoop = TRUE;
 976
 977                                                         } else {
 978
 979                                                                 iter->second = 4;
 980                                                                 break;
 981
 982                                                         }
 983
 984                                                 } else {
 985
 986                                                         ExitLoop = TRUE;
 987
 988                                                 }
 989
 990                                         }
 991
 992                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
 993                                                 break;
 994                                         }
 995
 996 #if defined(__APPLE__)
 997
 998                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
 999
1000 #elif defined(__WIN32__)
1001
1002                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
1003
1004 #else
1005
1006                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
1007
1008 #endif
1009
1010                                         ConnHandle.SetUploadMode(FALSE);
1011                                         ConnHandle.SetupData(wxT("DELETE"), ContactFilename, wxT(""));
1012                                         ConnHandle.ProcessData();
1013
1014                                         SSLCertCollection certcol = ConnHandle.GetCertificateData();
1015
1016                                         // Check if any errors have occured whilst getting the data.
1017
1018                                         int ErrorCode = ConnHandle.GetResultCode();
1019
1020                                         if (ErrorCode != CURLE_OK){
1021                                                 iter->second = 2;
1022                                                 break;
1023                                         }
1024
1025                                         ETagDBPtr->RemoveETag(ContactFilename);
1026
1027                                         iter->second = 4;
1028                                         CardDAVIter->second = NULL;
1029                                         break;
1030
1031                                 }
1032
1033                         } else if (TypeIter->second == 3) {
1034
1035                                 wxString AccountNameFriendly;
1036
1037                                 int AccountID = 0;
1038
1039                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
1040
1041                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
1042
1043                                         AccountDirCheck.Trim();
1044                                         AccountDirCheck.Append(wxT(".carddav"));
1045
1046                                         if (AccountDirCheck == StringAccountIter->second){
1047
1048                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
1049                                                 AccountID = i;
1050
1051                                         }
1052
1053                                 }
1054
1055                                 bool KeepUpdating = TRUE;
1056
1057                                 while (KeepUpdating == TRUE){
1058
1059                                         StringTaskDetailIter = ActivityListTaskDetail.find(iter->first);
1060
1061                                         AccountDir = StringAccountIter->second;
1062
1063                                         ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1064
1065                                         wxArrayString vCardAdd;
1066                                         wxArrayString vCardDelete;
1067                                         wxArrayString vCardList;
1068                                         wxArrayString vCardUpdateLocal;
1069                                         wxArrayString vCardUpdateRemote;
1070                                         wxArrayString vCardUpdateLog;
1071                                         std::map<wxString,wxString> vCardETag;
1072                                         ContactListData ServerContactList;
1073
1074                                         std::map<wxString,vCardDownloadDataFileClass> vCardDownloadData;
1075                                         //wxArrayString vCardDownload;
1076                                         //std::map<wxString,wxString> vCardDownloadData;
1077
1078                                         // Get the list of vCard files locally.
1079
1080                                         wxString AccountDirFinal;
1081                                         wxString AccountSyncTokenFilename;
1082                                         wxString SyncTokenLoad;
1083
1084 #if defined(__HAIKU__)
1085
1086                                             //preffilename = wxT("noo");
1087
1088 #elif defined(__WIN32__)
1089
1090                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
1091                                         AccountSyncTokenFilename = AccountDirFinal;
1092                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
1093
1094 #else
1095
1096                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
1097                                         AccountSyncTokenFilename = AccountDirFinal;
1098                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
1099
1100 #endif
1101
1102                                         // Suppress Error Messages.
1103
1104                                         wxLogNull PleaseDoNotDisturb;
1105
1106                                         wxFFile SyncLoad;
1107                                         SyncLoad.Open(AccountSyncTokenFilename, wxT("r"));
1108
1109                                         if (SyncLoad.IsOpened()){
1110
1111                                                 SyncLoad.ReadAll(&SyncTokenLoad, wxMBConvUTF8());
1112                                                 SyncLoad.Close();
1113
1114                                         }
1115
1116                                         // Get a list of vCard files from the server.
1117
1118                                         // Get the list of vCard files from the ETagDB.
1119
1120                                         std::map<wxString,ETagData> ETagDBData = ETagDBPtr->GetETagData();
1121
1122                                         bool ExitLoop = FALSE;
1123
1124                                         std::map<wxString,FileSyncData> *SCListData = NULL;
1125
1126                                         while (ExitLoop == FALSE){
1127
1128                                                 // Check if any errors have occured whilst getting the data.
1129
1130                                                 int ErrorCode = ConnHandle.SSLVerifyTest();
1131
1132                                                 if (ErrorCode != CURLE_OK){
1133
1134                                                         if (ErrorCode == CURLE_SSL_CACERT ||
1135                                                                 ErrorCode == CURLE_PEER_FAILED_VERIFICATION ||
1136                                                                 ErrorCode == CURLE_SSL_CONNECT_ERROR){
1137
1138                                                                 // Invalid SSL certificate so bring up a dialog to the user
1139                                                                 // explaining what has happened and the options available.
1140
1141                                                                 // Stop all the timers.
1142
1143                                                                 frmMainPtrGet->PauseAllTimers();
1144
1145                                                                 int SSLResult;
1146
1147 #if defined(__APPLE__)
1148
1149                                                                 // Bring up the trust panel and display the SSL certificate dialog.
1150
1151                                                                 SSLResult = DisplayTrustPanel(ConnHandle.GetTrustObject(), AccountNameFriendly);
1152
1153                                                                 // Update the SSL account with the trust object.
1154
1155                                                                 if (SSLResult != NSOKButton){
1156
1157                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetTrustObject());
1158                                                                         iter->second = 2;
1159                                                                         break;
1160
1161                                                                 } else {
1162
1163                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
1164
1165                                                                 }
1166
1167 #elif defined(__WIN32__)
1168
1169                                                                 BOOL ModifiedCertificateData;
1170                                                                 CRYPTUI_VIEWCERTIFICATE_STRUCTW CertificateData = BuildCertificateData(&ConnHandle, (HWND)frmMainPtrGet->GetHandle());
1171
1172                                                                 if (!CryptUIDlgViewCertificate(&CertificateData, &ModifiedCertificateData)){
1173                                                                         wxMessageBox(_("An error occured while trying to open the certificate dialog."), _("Error opening Certificate Information dialog"));
1174                                                                 }
1175
1176                                                                 if (ModifiedCertificateData == FALSE){
1177
1178                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetCertificateContextPointer());
1179                                                                         iter->second = 2;
1180                                                                         break;
1181
1182                                                                 } else {
1183
1184                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
1185
1186                                                                 }
1187 #else
1188
1189                                                                 // Setup the data to be sent in the wxPostEvent command.
1190
1191                                                                 SSLInvalidCertNotifObj SSLICNProcData;
1192
1193                                                                 SSLCertCollection certcol = ConnHandle.GetSSLVerifyResults();
1194
1195                                                                 bool *PauseMode = new bool;
1196                                                                 QRNotif qrn;
1197
1198                                                                 *PauseMode = TRUE;
1199                                                                 qrn.QResponse = &SSLResult;
1200                                                                 qrn.PausePtr = PauseMode;
1201
1202                                                                 SSLICNProcData.CertCollection = certcol;
1203                                                                 SSLICNProcData.QRNotifData = &qrn;
1204                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
1205
1206                                                                 wxCommandEvent event(INVALIDSSLCERT);
1207                                                                 event.SetClientData(&SSLICNProcData);
1208                                                                 wxPostEvent(frmMainPtrGet, event);
1209
1210                                                                 /*timespec n1, n2;
1211
1212                                                                 // Fall asleep until we get an response.
1213
1214                                                                 n1.tv_sec = 0;
1215                                                                 n1.tv_nsec = 250000000L;*/
1216
1217                                                                 while (*PauseMode == TRUE){
1218                                                                         //nanosleep(&n1, &n2);
1219                                                                         SleepFor(250000000);
1220                                                                 }
1221
1222                                                                 // Process the response from the user.
1223
1224                                                                 if (SSLResult == 1){
1225
1226                                                                         // Accept the certificate. Write the certificate into the account
1227                                                                         // directory (as server.crt) - will overwrite old certificate.
1228
1229                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
1230                                                                         WriteServerCertificate(AccountDir, ConnHandle.GetSSLVerifyResults());
1231
1232                                                                 } else if (SSLResult == 2){
1233
1234                                                                         // Reject the certificate, abort the task and mark as failed.
1235
1236                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, ConnHandle.GetSSLVerifyResults());
1237                                                                         iter->second = 2;
1238                                                                         break;
1239
1240                                                                 }
1241
1242 #endif
1243
1244                                                                 // Resume all the timers.
1245
1246                                                                 frmMainPtrGet->ResumeAllTimers();
1247                                                                 ExitLoop = TRUE;
1248
1249                                                         } else {
1250
1251                                                                 iter->second = 4;
1252                                                                 break;
1253
1254                                                         }
1255
1256                                                 } else {
1257
1258                                                         ExitLoop = TRUE;
1259
1260                                                 }
1261
1262                                         }
1263
1264                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
1265                                                 break;
1266                                         }
1267
1268 #if defined(__APPLE__)
1269
1270                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetTrustObject());
1271
1272 #elif defined(__WIN32__)
1273
1274                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetCertificateContextPointer());
1275
1276 #else
1277
1278                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, ConnHandle.GetSSLVerifyResults());
1279
1280 #endif
1281
1282                                         // Look in directory and see which vCards to add and delete
1283
1284                                         // In short:
1285                                         // vCard exists but not in ETagDB - Add (and upload).
1286                                         // vCard missing but in ETagDB - Delete (from server).
1287
1288                                         // Start by looking for vCards that are not in the ETagDB.
1289
1290                                         wxDir AccDir(AccountDirFinal);
1291                                         wxString AccDirFilename;
1292
1293                                         bool ContinueProcess = AccDir.GetFirst(&AccDirFilename, wxEmptyString, wxDIR_DEFAULT);
1294
1295                                         ServerContactList = ConnHandle.GetContactList(SyncTokenLoad.ToUTF8());
1296
1297                                         int ErrorCode = ConnHandle.GetResultCode();
1298
1299                                         if (ErrorCode != CURLE_OK){
1300
1301                                                 iter->second = 4;
1302                                                 break;
1303
1304                                         }
1305
1306                                         SSLCertCollection certcol = ConnHandle.GetCertificateData();
1307
1308                                         // Create a pointer for the std::map<wxString,FileSyncData>.
1309
1310                                         SCListData = &ServerContactList.ListData;
1311
1312                                         // Process the server data.
1313
1314                                         if (SCListData != NULL){
1315
1316                                                 for (std::map<wxString, FileSyncData>::iterator fsiter = SCListData->begin();
1317                                                         fsiter != SCListData->end(); fsiter++){
1318
1319                                                         // Check the mode of the file before adding.
1320
1321                                                         // Get the HTTP status of the file from the list.
1322
1323                                                         FileSyncData fsd = fsiter->second;
1324
1325                                                         if (fsd.DataFlag == 1){
1326
1327                                                                 // Added or modified contact.
1328
1329                                                                 //vCardAdd.Add(fsiter->first, 1);
1330
1331                                                                 vCardDownloadDataFileClass vCardNewData;
1332                                                                 vCardNewData.DataType = 0;
1333                                                                 vCardDownloadData.insert(std::make_pair(fsiter->first, vCardNewData));
1334
1335                                                                 //} else if (fsd.DataFlag == 1){
1336
1337                                                                 // Contact has been modified on the server.
1338
1339                                                                 //      vCardUpdateLocal.Add(fsiter->first, 1);
1340
1341                                                         }
1342                                                         else if (fsd.DataFlag == 2){
1343
1344                                                                 // Contact has been deleted.
1345
1346                                                                 vCardDelete.Add(fsiter->first, 1);
1347
1348                                                         }
1349
1350                                                 }
1351
1352                                         }
1353
1354                                         // Look for vCards that are missing but in the ETagDB.
1355
1356                                         for (std::map<wxString,ETagData>::iterator etagiter = ETagDBData.begin();
1357                                                 etagiter != ETagDBData.end(); etagiter++){
1358
1359                                                 // Check if the vCard exists.
1360
1361                                                 if (!wxFileExists(AccountDirFinal + etagiter->first)){
1362
1363                                                         // vCard doesn't exist so mark for deleting.
1364
1365                                                         vCardDelete.Add(etagiter->first, 1);
1366
1367                                                 }
1368
1369                                         }
1370
1371                                         // Compare Server with the ETag DB. Work out which
1372                                         // needs to updated remotely and which needs to be
1373                                         // updated locally.
1374
1375                                         for (std::map<wxString,FileSyncData>::iterator srviter = SCListData->begin();
1376                                                 srviter != SCListData->end(); srviter++){
1377
1378                                                 if (ETagDBData.find(srviter->first) == ETagDBData.end()){
1379                                                         continue;
1380                                                 }
1381
1382                                                 std::map<wxString,ETagData>::iterator lociter = ETagDBData.find(srviter->first);
1383
1384                                                 ETagData etd = lociter->second;
1385                                                 FileSyncData fsd = srviter->second;
1386
1387                                                 wxString ETagSrv = fsd.ETagData;
1388
1389                                                 // Check if the local ETag value has 'DELETED' set and skip
1390                                                 // checking this file if it does.
1391
1392                                                 if (etd.ETagValue == "DELETED"){
1393
1394                                                         continue;
1395
1396                                                 }
1397
1398                                                 // Compare local ETag with original local ETag.
1399                                                 // If different, update to server is required.
1400
1401                                                 if (etd.ETagValue != etd.ETagOrigValue){
1402
1403                                                         // Check if local original ETag is different from server ETag.
1404                                                         // If it is then throw up a conflict resolution dialog.
1405
1406                                                         if (etd.ETagOrigValue != ETagSrv){
1407
1408                                                                 vCard34Conv vCard34Obj;
1409
1410                                                                 wxString ServerContactData;
1411                                                                 wxString FullFilename;
1412                                                                 vCard ClientData;
1413                                                                 vCard ConvertedV4Data;
1414
1415                                                                 // Conflict. Bring up conflict resolution dialog.
1416
1417                                                                 // Get the server contact data for comparison.
1418
1419                                                                 ConnHandle.SetServerFilename(srviter->first);
1420                                                                 ConnHandle.GetServerContactData();
1421                                                                 ServerContactData = ConnHandle.GetPageData();
1422
1423                                                                 FullFilename = CreateFilenamePath(AccountDirFinal, srviter->first);
1424
1425                                                                 // Convert it to v4.
1426
1427                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1428
1429                                                                 vCardConflictObj vCardProcData;
1430
1431                                                                 vCardProcData.vCardLocalData = &ClientData;
1432                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1433
1434                                                                 // Load the client data from the filename given.
1435
1436                                                                 ClientData.LoadFile(FullFilename);
1437
1438                                                                 // Show dialog.
1439
1440                                                                 bool *PauseMode = new bool;
1441                                                                 int ConflictResult;
1442                                                                 QRNotif qrn;
1443                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
1444
1445                                                                 *PauseMode = TRUE;
1446                                                                 qrn.QResponse = &ConflictResult;
1447                                                                 qrn.PausePtr = PauseMode;
1448
1449                                                                 vCardProcData.QRNotifData = &qrn;
1450
1451                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1452                                                                 event.SetClientData(&vCardProcData);
1453                                                                 wxPostEvent(frmMainPtrGet, event);
1454
1455                                                                 /*timespec n1, n2;
1456
1457                                                                 n1.tv_sec = 0;
1458                                                                 n1.tv_nsec = 250000000L;*/
1459
1460                                                                 while (*PauseMode == TRUE){
1461                                                                         //nanosleep(&n1, &n2);
1462                                                                         SleepFor(250000000);
1463                                                                 }
1464
1465                                                                 delete PauseMode;
1466                                                                 PauseMode = NULL;
1467
1468                                                                 // If replacing local version, store copy for now.
1469                                                                 // Otherwise upload to server.
1470
1471                                                                 if (ConflictResult == 0){
1472
1473                                                                         // Decide Later.
1474
1475                                                                         continue;
1476
1477                                                                 } else if (ConflictResult == 1){
1478
1479                                                                         // Decided to use client version.
1480
1481                                                                         vCardUpdateLocal.Remove(srviter->first);
1482                                                                         vCardUpdateRemote.Add(srviter->first, 1);
1483
1484                                                                 } else if (ConflictResult == 2){
1485
1486                                                                         // Decided to use server version.
1487                                                                         // Store the converted downloaded copy for
1488                                                                         // processing later.
1489
1490                                                                         //vCardUpdateLocal.Add(srviter->first, 1);
1491
1492                                                                         vCardDownloadDataFileClass vCardNewData;
1493                                                                         vCardNewData.DataType = 1;
1494                                                                         vCardNewData.FileData = ConvertedV4Data.WriteString();
1495
1496                                                                         ConvertedV4Data.WriteFile(FullFilename);
1497
1498                                                                         vCardDownloadData.insert(std::make_pair(srviter->first, vCardNewData));
1499
1500
1501
1502                                                                 }
1503
1504                                                         } else {
1505
1506                                                                 // Send vCard to the server.
1507
1508                                                                 vCardUpdateRemote.Add(srviter->first, 1);
1509
1510                                                         }
1511
1512                                                 } else {
1513
1514                                                         // Check if local ETag is different from server ETag.
1515                                                         // If different, obtain the vCard from the server.
1516
1517                                                         if (etd.ETagOrigValue != ETagSrv){
1518
1519                                                                 vCardUpdateLocal.Add(srviter->first, 1);
1520
1521                                                         }
1522
1523                                                 }
1524
1525                                         }
1526
1527                                         // Process the vCards that need to be downloaded and added/overwritten.
1528
1529                                         wxString vCardFilenameFinal;
1530                                         wxString vCardOutputData;
1531                                         wxString vCardInputData;
1532                                         wxString ETagFileData;
1533                                         wxFFile vCardFile;
1534
1535                                         for (std::map<wxString,vCardDownloadDataFileClass>::iterator additer = vCardDownloadData.begin();
1536                                                 additer != vCardDownloadData.end(); additer++){
1537
1538                                                 vCardFilenameFinal.Clear();
1539                                                 vCardInputData.Clear();
1540                                                 vCardOutputData.Clear();
1541                                                 ETagFileData.Clear();
1542
1543                                                 vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
1544
1545                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1546
1547                                                 if (additer->second.DataType == 0){
1548
1549                                                         vCard ConvertedV4Data;
1550
1551                                                         // Grab the file from the server and write the contact out.
1552
1553                                                         vCard34Conv vCard34Obj;
1554
1555                                                         ConnHandle.SetServerFilename(additer->first);
1556                                                         ConnHandle.GetServerContactData();
1557                                                         vCardInputData = ConnHandle.GetPageData();
1558
1559                                                         vCard34Obj.ConvertToV4(&vCardInputData, &ConvertedV4Data);
1560
1561                                                         ConvertedV4Data.WriteFile(vCardFilenameFinal);
1562
1563                                                         // Update the ETagDB.
1564
1565                                                         //vCardFile.Open(vCardFilenameFinal, wxT("w"));
1566
1567                                                         //if (vCardFile.IsOpened()){
1568
1569                                                         //      vCardFile.Write(vCardOutputData, wxConvAuto());
1570                                                         //      vCardFile.Close();
1571
1572                                                         //}
1573
1574                                                         // Get the server ETag.
1575
1576                                                         wxString ServerETag;
1577                                                         ConnHandle.GetServerETagValueThread();
1578                                                         ServerETag = ConnHandle.ETagValueResult();
1579
1580                                                         // Add to the ETag Database.
1581
1582                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
1583
1584                                                 } else if (additer->second.DataType == 1){
1585
1586                                                         // Write out the contact to the account directory.
1587
1588                                                         vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
1589                                                         vCardOutputData = additer->second.FileData;
1590
1591                                                         vCardFile.Open(vCardFilenameFinal, wxT("w"));
1592
1593                                                         if (vCardFile.IsOpened()){
1594
1595                                                                 vCardFile.Write(vCardOutputData, wxConvAuto());
1596                                                                 vCardFile.Close();
1597
1598                                                         }
1599
1600                                                         // Update the ETagDB.
1601
1602                                                         wxString ServerETag;
1603                                                         ConnHandle.GetServerETagValueThread();
1604                                                         ServerETag = ConnHandle.ETagValueResult();
1605
1606                                                         // Add to the ETag Database.
1607
1608                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
1609
1610                                                 }
1611                                         }
1612
1613                                         // Look for vCard files which aren't in the ETagDB.
1614
1615                                         while(ContinueProcess){
1616
1617                                                 // Check and make sure that the filename ends in .vcf/.vcard
1618                                                 // Skip any file that beings with a dot.
1619
1620                                                 if (AccDirFilename.Left(1) == wxT(".")){
1621
1622                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1623                                                         continue;
1624
1625                                                 }
1626
1627                                                 if (AccDirFilename.Right(4) != wxT(".vcf") &&
1628                                                 AccDirFilename.Right(6) != wxT(".vcard")){
1629
1630                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1631                                                         continue;
1632
1633                                                 }
1634
1635                                                 // Look in the ETagDB for the file.
1636
1637                                                 bool ETagExists = ETagDBPtr->CheckETagExists(AccDirFilename);
1638
1639                                                 if (ETagExists == FALSE){
1640
1641                                                         // Add the vCard to the list to be added.
1642
1643                                                         vCardAdd.Add(AccDirFilename, 1);
1644
1645                                                 }
1646
1647                                                 ContinueProcess = AccDir.GetNext(&AccDirFilename);
1648
1649                                         }
1650
1651                                         // Process the vCards to add/update to the server.
1652
1653                                         for (int vi = 0; vi < vCardAdd.GetCount(); vi++){
1654
1655                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1656                                                 ETag = ETagDBPtr->GetETag(vCardAdd[vi]);
1657                                                 ETagOriginal = ETagDBPtr->GetETagOriginal(vCardAdd[vi]);
1658
1659                                                 ContactFilename = vCardAdd[vi];
1660                                                 FullFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1661
1662                                                 ContactFilename.Trim();
1663
1664                                                 if (ETag == ETagOriginal && ETagDBPtr->ETagExists(vCardAdd[vi])){
1665
1666                                                         // Compare the ETag with the Server ETag.
1667
1668                                                         ConnHandle.SetServerFilename(vCardAdd[vi]);
1669                                                         ConnHandle.GetServerETagValueThread();
1670                                                         ETagServer = ConnHandle.ETagValueResult();
1671
1672                                                         if (ETagOriginal != ETagServer){
1673
1674                                                                 // Server ETag is different from original ETag.
1675                                                                 // This is a conflict which the user will now
1676                                                                 // need to resolve.
1677
1678                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
1679
1680                                                                 vCard34Conv vCard34Obj;
1681
1682                                                                 wxString ServerContactData;
1683                                                                 vCard ClientData;
1684                                                                 vCard ConvertedV4Data;
1685
1686                                                                 // Load the client data from the filename given.
1687
1688                                                                 ConnHandle.GetServerContactData();
1689                                                                 ServerContactData = ConnHandle.GetPageData();
1690
1691                                                                 // Process v3 version into v4 version.
1692
1693                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1694
1695                                                                 vCardConflictObj vCardProcData;
1696
1697                                                                 vCardProcData.vCardLocalData = &ClientData;
1698                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1699                                                                 ClientData.LoadFile(FullFilename);
1700
1701                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1702                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1703
1704                                                                 //wxPostEvent(frmMainPtrGet, event);
1705
1706                                                                 // Setup Conflict Resolution Dialog.
1707
1708                                                                 // Fetch Data from Server and convert.
1709
1710                                                                 bool *PauseMode = new bool;
1711                                                                 int ConflictResult;
1712                                                                 QRNotif qrn;
1713
1714                                                                 *PauseMode = TRUE;
1715                                                                 qrn.QResponse = &ConflictResult;
1716                                                                 qrn.PausePtr = PauseMode;
1717
1718                                                                 vCardProcData.QRNotifData = &qrn;
1719
1720                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1721                                                                 event.SetClientData(&vCardProcData);
1722                                                                 wxPostEvent(frmMainPtrGet, event);
1723
1724                                                                 /*timespec n1, n2;
1725
1726                                                                 n1.tv_sec = 0;
1727                                                                 n1.tv_nsec = 250000000L;*/
1728
1729                                                                 while (*PauseMode == TRUE){
1730                                                                         //nanosleep(&n1, &n2);
1731                                                                         SleepFor(250000000);
1732                                                                 }
1733
1734                                                                 delete PauseMode;
1735                                                                 PauseMode = NULL;
1736
1737                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1738
1739                                                                 if (ConflictResult == 0){
1740
1741                                                                         // Decide Later.
1742
1743                                                                         iter->second = 4;
1744                                                                         continue;
1745
1746                                                                 } else if (ConflictResult == 1){
1747
1748                                                                         // Decided to use client version.
1749
1750                                                                         ConnHandle.ProcessData();
1751
1752                                                                         iter->second = 4;
1753
1754                                                                 } else if (ConflictResult == 2){
1755
1756                                                                         // Decided to use server version.
1757
1758                                                                         // Download server version.
1759
1760                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1761
1762                                                                         iter->second = 4;
1763
1764                                                                 }
1765
1766                                                         } else {
1767
1768                                                                 // Setup the filename for the contact being added.
1769
1770                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1771                                                                 wxString wxSCardData;
1772                                                                 wxString TaskData;
1773                                                                 //wxString TaskURL;
1774
1775                                                                 // Load the data from the file.
1776
1777                                                                 wxFFile wxFCard;
1778                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1779
1780                                                                 if (wxFCard.IsOpened()){
1781
1782                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1783                                                                         wxFCard.Close();
1784
1785                                                                 }
1786
1787                                                                 // Convert the data to v3.
1788
1789                                                                 vCard34Conv vCard34Obj;
1790
1791                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1792
1793                                                                 // Setup the URL address.
1794
1795                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1796
1797                                                                 // Upload the data to the server.
1798
1799                                                                 ConnHandle.SetUploadMode(TRUE);
1800                                                                 ConnHandle.SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1801                                                                 ConnHandle.ProcessData();
1802
1803                                                                 // Get the Server ETag and put it in the ETag database.
1804
1805                                                                 ConnHandle.SetServerFilename(vCardAdd[vi]);
1806                                                                 ConnHandle.GetServerETagValueThread();
1807                                                                 ETagServer = ConnHandle.ETagValueResult();
1808
1809                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1810
1811                                                         }
1812
1813                                                 } else {
1814
1815                                                         if (ETagOriginal != ETagServer){
1816
1817                                                                 // Server ETag is different from original ETag.
1818                                                                 // This is a conflict which the user will now
1819                                                                 // need to resolve.
1820
1821                                                                 frmMain *frmMainPtrGet = (frmMain *)frmMainPtr;
1822
1823                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1824                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1825
1826                                                                 vCard34Conv vCard34Obj;
1827
1828                                                                 wxString ServerContactData;
1829                                                                 vCard ClientData;
1830                                                                 vCard ConvertedV4Data;
1831
1832                                                                 // Load the client data from the filename given.
1833
1834                                                                 ConnHandle.GetServerContactData();
1835                                                                 ServerContactData = ConnHandle.GetPageData();
1836                                                                 ClientData.LoadFile(FullFilename);
1837
1838                                                                 // Process v3 version into v4 version.
1839
1840                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1841
1842                                                                 vCardConflictObj vCardProcData;
1843
1844                                                                 vCardProcData.vCardLocalData = &ClientData;
1845                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1846
1847                                                                 bool *PauseMode = new bool;
1848                                                                 int ConflictResult;
1849                                                                 QRNotif qrn;
1850
1851                                                                 *PauseMode = TRUE;
1852                                                                 qrn.QResponse = &ConflictResult;
1853                                                                 qrn.PausePtr = PauseMode;
1854
1855                                                                 vCardProcData.QRNotifData = &qrn;
1856
1857                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1858                                                                 event.SetClientData(&vCardProcData);
1859                                                                 wxPostEvent(frmMainPtrGet, event);
1860
1861                                                                 /*timespec n1, n2;
1862
1863                                                                 n1.tv_sec = 0;
1864                                                                 n1.tv_nsec = 250000000L;*/
1865
1866                                                                 while (*PauseMode == TRUE){
1867                                                                         //nanosleep(&n1, &n2);
1868                                                                         SleepFor(250000000);
1869                                                                 }
1870
1871                                                                 delete PauseMode;
1872                                                                 PauseMode = NULL;
1873
1874                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1875
1876                                                                 if (ConflictResult == 0){
1877
1878                                                                         // Decide Later.
1879
1880                                                                         iter->second = 4;
1881                                                                         continue;
1882
1883                                                                 } else if (ConflictResult == 1){
1884
1885                                                                         // Decided to use client version.
1886
1887                                                                         ConnHandle.ProcessData();
1888                                                                         //ETagServer = CardDAVIter->second.GetServerETagValueThread();
1889                                                                         //ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1890
1891                                                                         iter->second = 4;
1892
1893                                                                 } else if (ConflictResult == 2){
1894
1895                                                                         // Decided to use server version.
1896
1897                                                                         // Write server version to file.
1898
1899                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1900
1901                                                                         iter->second = 4;
1902
1903                                                                 }
1904
1905                                                         } else {
1906
1907                                                                 // Setup the filename for the contact being added.
1908
1909                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1910                                                                 wxString wxSCardData;
1911                                                                 wxString TaskData;
1912                                                                 //wxString TaskURL;
1913
1914                                                                 // Load the data from the file.
1915
1916                                                                 wxFFile wxFCard;
1917                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1918
1919                                                                 if (wxFCard.IsOpened()){
1920
1921                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1922                                                                         wxFCard.Close();
1923
1924                                                                 }
1925
1926                                                                 // Convert the data to v3.
1927
1928                                                                 vCard34Conv vCard34Obj;
1929
1930                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1931
1932                                                                 // Setup the URL address.
1933
1934                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1935
1936                                                                 // Upload the data to the server.
1937
1938                                                                 ConnHandle.SetUploadMode(TRUE);
1939                                                                 ConnHandle.SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1940                                                                 ConnHandle.ProcessData();
1941
1942                                                                 // Get the Server ETag and put it in the ETag database.
1943
1944                                                                 ConnHandle.SetServerFilename(vCardAdd[vi]);
1945                                                                 ConnHandle.GetServerETagValueThread();
1946                                                                 ETagServer = ConnHandle.ETagValueResult();
1947
1948
1949                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1950
1951                                                         }
1952
1953                                                 }
1954
1955                                         }
1956
1957                                         // Process the vCards to delete locally.
1958
1959                                         for (int vi = 0; vi < vCardDelete.GetCount(); vi++){
1960
1961                                                 if (!wxRemoveFile(CreateFilenamePath(AccountDirFinal, vCardDelete[vi]))){
1962
1963                                                 } else {
1964
1965                                                         ETagDBPtr->RemoveETag(vCardDelete[vi]);
1966
1967                                                 }
1968
1969                                         }
1970
1971                                         // Process the vCards to delete from the server.
1972
1973                                         std::map<wxString,wxString> *ETagFilenameMap = ETagDBPtr->GetFilenamePointer();
1974                                         std::list<wxString> DeleteList;
1975
1976                                         for (std::map<wxString,wxString>::iterator deliter = ETagFilenameMap->begin();
1977                                                 deliter != ETagFilenameMap->end(); deliter++){
1978
1979                                                 // Look through the ETagDB and find contacts which are marked as DELETED.
1980
1981                                                 if (deliter->second == wxT("DELETED")){
1982
1983                                                         ConnHandle.SetUploadMode(FALSE);
1984                                                         ConnHandle.SetupData(wxT("DELETE"), deliter->first, wxT(""));
1985                                                         ConnHandle.ProcessDataThread();
1986
1987                                                         // Delete the ETag as the file has now been deleted.
1988
1989                                                         DeleteList.push_back(deliter->first);
1990
1991                                                 }
1992
1993                                         }
1994
1995                                         for (std::list<wxString>::iterator removeetagiter = DeleteList.begin();
1996                                              removeetagiter != DeleteList.end(); removeetagiter++){
1997
1998                                                 ETagDBPtr->RemoveETag(*removeetagiter);
1999
2000                                         }
2001
2002                                         // Write out the update server sync token.
2003
2004                                         wxString ServerSyncToken = ServerContactList.SyncToken;
2005
2006                                         ServerSyncToken.Trim();
2007
2008                                         if (!ServerSyncToken.IsEmpty()){
2009
2010                                                 wxFFile SyncWrite;
2011                                                 SyncWrite.Open(AccountSyncTokenFilename, wxT("w"));
2012
2013                                                 if (SyncWrite.IsOpened()){
2014
2015                                                         SyncWrite.Write(ServerSyncToken, wxConvAuto());
2016                                                         SyncWrite.Close();
2017
2018                                                 }
2019
2020                                         }
2021
2022                                         // Check for another sync token. If there is another
2023                                         // sync token then repeat this. If token matches then stop processing.
2024
2025                                         if (SyncTokenLoad == ServerSyncToken){
2026
2027                                                 KeepUpdating = FALSE;
2028
2029                                         }
2030
2031                                 }
2032
2033                                 // Mark as completed.
2034
2035                                 wxString AccountNameFinal;
2036                                 AccountNameFinal = PrefData.accounts.GetAccountDirectory(AccountID);
2037                                 AccountNameFinal.Append(wxT(".carddav"));
2038
2039                                 wxCommandEvent reloadevent(RELOADCONTACTLIST);
2040                                 reloadevent.SetString(AccountNameFinal);
2041                                 wxPostEvent(this->GetParent(), reloadevent);
2042
2043                                 iter->second = 4;
2044                                 continue;
2045
2046                         } else {
2047
2048                                 // Update the data to the server.
2049
2050                                 ConnHandle.ProcessData();
2051                                 iter->second = 4;
2052                                 continue;
2053
2054                         }
2055
2056                         /*timespec n1, n2;
2057
2058                         n1.tv_sec = 0;
2059                         n1.tv_nsec = 250000000L;*/
2060
2061                         while (iter->second == 1){
2062
2063                                 SleepFor(250000000);
2064                                 //nanosleep(&n1, &n2);
2065
2066                         }
2067
2068                         if ((iter->second == 4 && TypeIter->second == 0) ||
2069                         (iter->second == 8 && TypeIter->second == 0)){
2070
2071                                 AccountDir = StringAccountIter->second;
2072                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
2073
2074                                 ConnHandle.GetServerETagValueThread();
2075                                 ETagServer = ConnHandle.ETagValueResult();
2076                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
2077
2078                         }
2079
2080                         if ((iter->second == 4 && TypeIter->second == 1) ||
2081                         (iter->second == 8 && TypeIter->second == 1)){
2082
2083                                 AccountDir = StringAccountIter->second;
2084                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
2085
2086                                 ConnHandle.GetServerETagValueThread();
2087                                 ETagServer = ConnHandle.ETagValueResult();
2088                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
2089
2090                         }
2091
2092                         break;
2093
2094                 }
2095
2096         }
2097
2098         if (TasksFoundProc == FALSE){
2099
2100                 TasksActive = FALSE;
2101                 ProcessTasksData = FALSE;
2102
2103         } else {
2104
2105                 wxCommandEvent eventp(ACTMGR_STARTTIMER);
2106                 wxPostEvent(this, eventp);
2107
2108                 //AnimationTimer.StartAnimation();
2109                 //ActListProcTimer.Start();
2110
2111         }
2112
2113         wxCommandEvent event(ACTMGR_STARTPROCESSTIMER);
2114         wxPostEvent(this, event);
2115
2116         //ActProcessTimer.Start();
2117
2118 }
2119
2120 void frmActivityMgr::ProcessTasks()
2121 {
2122
2123         std::thread ProcessThread(&frmActivityMgr::ProcessTasksThread, this);
2124         ProcessThread.detach();
2125
2126 }
2127
2128 void frmActivityMgr::SetupPointers(wxETagProcessTimer *ETagTmrPtrInc, void *frmMainPtrInc)
2129 {
2130
2131         ETagTmrPtr = ETagTmrPtrInc;
2132
2133         frmMainPtr = frmMainPtrInc;
2134
2135 }
2136
2137 void frmActivityMgr::ResumeProcessing(wxCommandEvent &event){
2138
2139         QRNotif *qrn = (QRNotif *)event.GetClientData();
2140
2141         int *QRes = qrn->QResponse;
2142
2143         *qrn->PausePtr = FALSE;
2144
2145         *QRes = event.GetInt();
2146
2147 }
2148
2149 void frmActivityMgr::ToggleConnectionStatus( wxCommandEvent &event ){
2150
2151         wxCommandEvent connevent(CONNSTAT_UPDATE);
2152
2153         if (SleepMode == FALSE){
2154
2155                 connevent.SetInt(1);
2156                 SleepMode = TRUE;
2157
2158         } else {
2159
2160                 connevent.SetInt(0);
2161                 SleepMode = FALSE;
2162
2163         }
2164
2165         wxPostEvent(GetParent(), connevent);
2166
2167 }
2168
2169 void frmActivityMgr::WriteServerCertificate(wxString AccountName, SSLCertCollection SSLCertInc){
2170
2171         wxString ServerCertFinal;
2172
2173         // Get the Cert section of the certificate and write it to the file.
2174
2175         ServerCertFinal = GetAccountDir(AccountName, TRUE);
2176
2177         wxFile CertFile;
2178
2179         std::map<int, SSLCertData>::iterator SSLCDIter = SSLCertInc.SSLCollection.find(0);
2180         std::multimap<wxString,wxString>::iterator SSLDataIter = SSLCDIter->second.CertData.find(wxT("Cert"));
2181
2182         CertFile.Open(ServerCertFinal, wxFile::write);
2183
2184         CertFile.Write(SSLDataIter->second, wxConvUTF8);
2185         CertFile.Close();
2186
2187 }
2188
2189 void frmActivityMgr::StartTimer(wxCommandEvent& event){
2190
2191         ActListProcTimer.Start(1000, FALSE);
2192
2193 }
2194
2195 void frmActivityMgr::StopTimer(wxCommandEvent& event){
2196
2197         ActListProcTimer.Stop();
2198
2199 }
2200
2201 void frmActivityMgr::StartProcessTimer(wxCommandEvent& event){
2202
2203         ActProcessTimer.Start(1000, FALSE);
2204
2205 }
2206
2207 void frmActivityMgr::StopProcessTimer(wxCommandEvent& event){
2208
2209         ActProcessTimer.Stop();
2210
2211 }
2212
2213 void frmActivityMgr::UpdateStatusLabel(wxCommandEvent& event){
2214
2215         ActivityMgrLabelUpdate *actmgrudata = (ActivityMgrLabelUpdate*)event.GetClientData();
2216
2217         if (actmgrudata != NULL){
2218
2219                 lstActivity->SetItem(actmgrudata->ItemIndex, 2, actmgrudata->ItemLabel);
2220
2221                 /*if (!actmgrudata->ItemDes.IsEmpty()){
2222                 lstActivity->SetItem(actmgrudata->ItemIndex, 0, actmgrudata->ItemDes);
2223                 }*/
2224
2225                 delete actmgrudata;
2226                 actmgrudata = NULL;
2227
2228         }
2229
2230 }