source/carddav/carddav-serveretag.cpp

   1 #include "carddav.h"
   2 #include "../version.h"
   3 #include <wx/wx.h>
   4 #include <wx/tokenzr.h>
   5 #include <wx/ffile.h>
   6 #include <libxml/parser.h>
   7 #include <libxml/tree.h>
   8 #include <map>
   9 #include <thread>
  10 #include "../vcard/vcard.h"
  11 #include "../common/dirs.h"
  12
  13 void CardDAV::GetServerETagValueThread()
  14 {
  15
  16         PageData.Clear();
  17         PageHeader.Clear();
  18
  19         SSLStatus = TRUE;
  20         AuthPassed = TRUE;
  21         AbortConnection = FALSE;
  22
  23         bool FilenameIsDirectory = FALSE;
  24         CURL *conn;
  25         CURLcode conncode;
  26         wxString ServerAddressURL;
  27         wxString ServerAuth;
  28         wxString ServerAddressSSL;
  29         wxString ServerAddressNormal;
  30
  31         conn = curl_easy_init();
  32
  33         struct CardDAVCURLPasser {
  34
  35                 CardDAV *Data;
  36                 bool HeaderMode = TRUE;
  37
  38         } CardDAVHeader, CardDAVFooter;
  39
  40         CardDAVHeader.Data = this;
  41         CardDAVHeader.HeaderMode = TRUE;
  42
  43         CardDAVFooter.Data = this;
  44         CardDAVFooter.HeaderMode = FALSE;
  45
  46         wxString Data1;
  47         wxString Data2;
  48
  49         ServerAddressURL = ServerAddress + wxT(":") + wxString::Format(wxT("%i"), ServerPort) + wxT("/") + ServerPrefix + ServerFilenameLocation;
  50         ServerAddressSSL = wxT("https://") + ServerAddressURL;
  51         ServerAddressNormal = wxT("http://") + ServerAddressURL;
  52
  53         ServerAuth = ServerUser + wxT(":") + ServerPass;
  54
  55         // Workout if path is directory or filename.
  56
  57         /*if (ServerAddress){
  58                 FilenameIsDirectory = TRUE;
  59         } else {
  60                 FilenameIsDirectory = FALSE;
  61         }*/
  62
  63         // Try SSL first.
  64
  65
  66         /*
  67         char *ServerAdrSSLChar = new char[(ServerAddressSSL.Length() - 1)];
  68         //memset(ServerAdrSSLChar, 0, ServerAddressSSL.Length());
  69         strncpy(ServerAdrSSLChar, (const char*)ServerAddressSSL.mb_str(wxConvUTF8), (ServerAddressSSL.Length() - 1));
  70
  71         char *ServerAdrNorChar = new char[(ServerAddressNormal.Length() - 1)];
  72         //memset(ServerAdrNorChar, 0, ServerAddressSSL.Length());
  73         strncpy(ServerAdrNorChar, (const char*)ServerAddressNormal.mb_str(wxConvUTF8), (ServerAddressNormal.Length() - 1));
  74
  75         char *ServerAuthChar = new char[(ServerAuth.Length() - 1)];
  76         //memset(ServerAuthChar, 0, ServerAddressSSL.Length());
  77         strncpy(ServerAuthChar, (const char*)ServerAuth.mb_str(wxConvUTF8), (ServerAuth.Length() - 1));
  78
  79         */
  80
  81         //std::string WriteDataString = std::string(ServerUploadData.mb_str());
  82
  83         std::map<int,int>::iterator ActIter;
  84         struct UploadDataStruc UploadData;
  85
  86
  87         ActIter = ActivityListPtr->find((int)ItemIndex);
  88
  89         static const char* query =
  90         "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
  91         "<C:addressbook-query xmlns:D=\"DAV:\""
  92         "       xmlns:C=\"urn:ietf:params:xml:ns:carddav\">"
  93         "<D:prop><D:getetag/>"
  94         //"<C:address-data>"
  95         //"     <C:allprop/>"
  96         //"</C:address-data></D:prop>"
  97         "</D:prop>"
  98         "<C:filter/>"
  99         "</C:addressbook-query>";
 100
 101         if (ServerSSL){
 102
 103                 wxString ServerCertFilename;
 104                 bool MatchingCert = FALSE;
 105
 106                 curl_easy_setopt(conn, CURLOPT_URL, (const char*)ServerAddressSSL.mb_str(wxConvUTF8));
 107                 curl_easy_setopt(conn, CURLOPT_NOPROGRESS, 0);
 108                 curl_easy_setopt(conn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 109                 curl_easy_setopt(conn, CURLOPT_TIMEOUT, 60);
 110                 curl_easy_setopt(conn, CURLOPT_FAILONERROR, TRUE);
 111                 curl_easy_setopt(conn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 112                 curl_easy_setopt(conn, CURLOPT_USERPWD, (const char*)ServerAuth.mb_str(wxConvUTF8));
 113                 curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 114                 curl_easy_setopt(conn, CURLOPT_WRITEDATA, &PageData);
 115                 curl_easy_setopt(conn, CURLOPT_WRITEHEADER, &PageHeader);
 116                 curl_easy_setopt(conn, CURLOPT_PROGRESSDATA, this);
 117                 curl_easy_setopt(conn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 118                 curl_easy_setopt(conn, CURLOPT_CUSTOMREQUEST, "REPORT");
 119                 curl_easy_setopt(conn, CURLOPT_NOSIGNAL, 1);
 120
 121                 //UploadData.readptr = &CardDAVDataQuery;
 122                 //UploadData.sizeleft = CardDAVDataQuery.Len();
 123                 //curl_easy_setopt(conn, CURLOPT_UPLOAD, 1);
 124                 //curl_easy_setopt(conn, CURLOPT_READDATA, &UploadData);
 125                 //curl_easy_setopt(conn, CURLOPT_READFUNCTION, UploadReadFunc);
 126
 127                 //curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, writefunc);
 128                 curl_easy_setopt(conn, CURLOPT_POSTFIELDS, query);
 129                 curl_easy_setopt(conn, CURLOPT_POSTFIELDSIZE, strlen(query));
 130
 131                 ServerCertFilename = GetAccountDir(ServerAccount, TRUE);
 132
 133                 if (wxFile::Exists(ServerCertFilename) == TRUE){
 134
 135                         curl_easy_setopt(conn, CURLOPT_SSL_VERIFYPEER, 1);
 136                         curl_easy_setopt(conn, CURLOPT_SSL_VERIFYHOST, 2);
 137                         curl_easy_setopt(conn, CURLOPT_CAINFO, (const char*)ServerCertFilename.mb_str(wxConvUTF8));
 138
 139                 }
 140
 141                 claconncode = (curl_easy_perform(conn));
 142
 143                 // If CURLE_PEER_FAILED_VERIFICATION is returned, retry without
 144                 // the local certificate in use.
 145
 146                 if (claconncode == CURLE_PEER_FAILED_VERIFICATION){
 147
 148                         curl_easy_cleanup(conn);
 149                         conn = curl_easy_init();
 150
 151                         curl_easy_setopt(conn, CURLOPT_URL, (const char*)ServerAddressSSL.mb_str(wxConvUTF8));
 152                         curl_easy_setopt(conn, CURLOPT_NOPROGRESS, 0);
 153                         curl_easy_setopt(conn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 154                         curl_easy_setopt(conn, CURLOPT_TIMEOUT, 60);
 155                         curl_easy_setopt(conn, CURLOPT_FAILONERROR, TRUE);
 156                         curl_easy_setopt(conn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 157                         curl_easy_setopt(conn, CURLOPT_USERPWD, (const char*)ServerAuth.mb_str(wxConvUTF8));
 158                         curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 159                         curl_easy_setopt(conn, CURLOPT_WRITEDATA, &PageData);
 160                         curl_easy_setopt(conn, CURLOPT_WRITEHEADER, &PageHeader);
 161                         curl_easy_setopt(conn, CURLOPT_PROGRESSDATA, this);
 162                         curl_easy_setopt(conn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 163                         curl_easy_setopt(conn, CURLOPT_CUSTOMREQUEST, "REPORT");
 164                         curl_easy_setopt(conn, CURLOPT_NOSIGNAL, 1);
 165                         curl_easy_setopt(conn, CURLOPT_POSTFIELDS, query);
 166                         curl_easy_setopt(conn, CURLOPT_POSTFIELDSIZE, strlen(query));
 167
 168                         claconncode = (curl_easy_perform(conn));
 169
 170                         // If claconncode is CURLE_OK then delete the certificate file as that
 171                         // is no longer needed.
 172
 173                         if (claconncode == CURLE_OK){
 174
 175                                 // Delete the certificate file.
 176
 177                                 wxRemoveFile(ServerCertFilename);
 178
 179                         }
 180
 181                 }
 182
 183                 // Check if it fails with a CURLE_SSL_CACERT then compare
 184                 // the certificates as PEM files.
 185
 186                 if (claconncode == CURLE_SSL_CACERT && wxFile::Exists(ServerCertFilename) == TRUE){
 187
 188                         //curl_easy_cleanup(conn);
 189                         //conn = curl_easy_init();
 190
 191                         CURL *sslerrconn;
 192                         sslerrconn = curl_easy_init();
 193                         CURLcode sslerrconncode;
 194
 195                         //claconncode = (curl_easy_perform(conn));
 196
 197                         wxString ServerAddressOnly = wxT("https://") + ServerAddress + wxT(":") + wxString::Format(wxT("%i"), ServerPort) + wxT("/");
 198
 199                         PageData.clear();
 200                         PageHeader.clear();
 201
 202                         curl_easy_setopt(sslerrconn, CURLOPT_URL, (const char*)ServerAddressOnly.mb_str(wxConvUTF8));
 203                         curl_easy_setopt(sslerrconn, CURLOPT_NOPROGRESS, 0);
 204                         curl_easy_setopt(sslerrconn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 205                         curl_easy_setopt(sslerrconn, CURLOPT_TIMEOUT, 60);
 206                         curl_easy_setopt(sslerrconn, CURLOPT_FAILONERROR, TRUE);
 207                         curl_easy_setopt(sslerrconn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 208                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 209                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEDATA, &PageData);
 210                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEHEADER, &PageHeader);
 211                         curl_easy_setopt(sslerrconn, CURLOPT_PROGRESSDATA, this);
 212                         curl_easy_setopt(sslerrconn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 213                         curl_easy_setopt(sslerrconn, CURLOPT_NOSIGNAL, 1);
 214                         curl_easy_setopt(sslerrconn, CURLOPT_SSL_VERIFYPEER, 0);
 215                         curl_easy_setopt(sslerrconn, CURLOPT_CERTINFO, 1);
 216                         curl_easy_setopt(sslerrconn, CURLOPT_SSL_VERIFYPEER, 1);
 217                         curl_easy_setopt(sslerrconn, CURLOPT_SSL_VERIFYHOST, 2);
 218                         curl_easy_setopt(sslerrconn, CURLOPT_CAINFO, (const char*)ServerCertFilename.mb_str(wxConvUTF8));
 219
 220                         wxString SSLLocalData;
 221                         wxString SSLServerData;
 222
 223                         sslerrconncode = (curl_easy_perform(sslerrconn));
 224
 225                         SSLCertCol = BuildSSLCollection(sslerrconn);
 226                         std::map<int, SSLCertData>::iterator SSLCDIter = SSLCertCol.SSLCollection.find(0);
 227                         std::multimap<wxString,wxString>::iterator SSLDataIter = SSLCDIter->second.CertData.find(wxT("Cert"));
 228
 229                         wxFFile SSLLocalFile;
 230
 231 #if wxABI_VERSION < 20900
 232                         SSLLocalFile.Open(ServerCertFilename.c_str(), wxT("r"));
 233 #else
 234                         SSLLocalFile.Open(ServerCertFilename, wxT("r"));
 235 #endif
 236
 237                         // Load the recovery database for tasks not done.
 238
 239                         if (SSLLocalFile.IsOpened() == TRUE){
 240
 241                         // Check if we are using wxWidgets version 2.8 or less and
 242                         // execute the required command accordingly.
 243
 244                                 SSLLocalFile.ReadAll(&SSLLocalData, wxConvAuto());
 245
 246
 247                         }
 248
 249                         SSLServerData = SSLDataIter->second;
 250
 251                         if (SSLLocalData == SSLServerData){
 252
 253                                 // Server key matches with local key so retry with CURLOPT_SSL_VERIFYPEER
 254                                 // and CURLOPT_SSL_VERIFYHOST off.
 255
 256                                 curl_easy_cleanup(conn);
 257                                 conn = curl_easy_init();
 258
 259                                 PageData.clear();
 260                                 PageHeader.clear();
 261
 262                                 curl_easy_setopt(conn, CURLOPT_URL, (const char*)ServerAddressSSL.mb_str(wxConvUTF8));
 263                                 curl_easy_setopt(conn, CURLOPT_NOPROGRESS, 0);
 264                                 curl_easy_setopt(conn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 265                                 curl_easy_setopt(conn, CURLOPT_TIMEOUT, 60);
 266                                 curl_easy_setopt(conn, CURLOPT_FAILONERROR, TRUE);
 267                                 curl_easy_setopt(conn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 268                                 curl_easy_setopt(conn, CURLOPT_USERPWD, (const char*)ServerAuth.mb_str(wxConvUTF8));
 269                                 curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 270                                 curl_easy_setopt(conn, CURLOPT_WRITEDATA, &PageData);
 271                                 curl_easy_setopt(conn, CURLOPT_WRITEHEADER, &PageHeader);
 272                                 curl_easy_setopt(conn, CURLOPT_PROGRESSDATA, this);
 273                                 curl_easy_setopt(conn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 274                                 curl_easy_setopt(conn, CURLOPT_CUSTOMREQUEST, "REPORT");
 275                                 curl_easy_setopt(conn, CURLOPT_NOSIGNAL, 1);
 276                                 curl_easy_setopt(conn, CURLOPT_POSTFIELDS, query);
 277                                 curl_easy_setopt(conn, CURLOPT_POSTFIELDSIZE, strlen(query));
 278                                 curl_easy_setopt(conn, CURLOPT_SSL_VERIFYPEER, 0);
 279                                 curl_easy_setopt(conn, CURLOPT_SSL_VERIFYHOST, 0);
 280
 281                                 claconncode = (curl_easy_perform(conn));
 282
 283                                 MatchingCert = TRUE;
 284
 285                         }
 286
 287                         if (MatchingCert == FALSE){
 288
 289                                 claconncode = CURLE_SSL_CACERT;
 290                                 return;
 291
 292                         }
 293
 294                         curl_easy_cleanup(sslerrconn);
 295
 296                 }
 297
 298                 // Sort out SSL error.
 299
 300                 // When SSL cert error occurs, connect again and fetch certificates.
 301                 // Display a message to the user explaining that an invalid
 302                 // certificate has been given and let the user decide what
 303                 // to do next.
 304
 305                 if (claconncode == CURLE_OK){
 306
 307                 } else if (claconncode == CURLE_SSL_CACERT || claconncode == CURLE_PEER_FAILED_VERIFICATION){
 308
 309                         CURL *sslerrconn;
 310                         sslerrconn = curl_easy_init();
 311                         CURLcode sslerrconncode;
 312
 313                         wxString ServerAddressOnly = wxT("https://") + ServerAddress + wxT(":") + wxString::Format(wxT("%i"), ServerPort) + wxT("/");
 314
 315                         // Replace conn with sslerrconn!
 316
 317                         curl_easy_setopt(sslerrconn, CURLOPT_URL, (const char*)ServerAddressOnly.mb_str(wxConvUTF8));
 318                         curl_easy_setopt(sslerrconn, CURLOPT_NOPROGRESS, 0);
 319                         curl_easy_setopt(sslerrconn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 320                         curl_easy_setopt(sslerrconn, CURLOPT_TIMEOUT, 60);
 321                         curl_easy_setopt(sslerrconn, CURLOPT_FAILONERROR, TRUE);
 322                         curl_easy_setopt(sslerrconn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 323                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 324                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEDATA, &PageData);
 325                         curl_easy_setopt(sslerrconn, CURLOPT_WRITEHEADER, &PageHeader);
 326                         curl_easy_setopt(sslerrconn, CURLOPT_PROGRESSDATA, this);
 327                         curl_easy_setopt(sslerrconn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 328                         curl_easy_setopt(sslerrconn, CURLOPT_NOSIGNAL, 1);
 329                         curl_easy_setopt(sslerrconn, CURLOPT_SSL_VERIFYPEER, 0);
 330                         curl_easy_setopt(sslerrconn, CURLOPT_CERTINFO, 1);
 331
 332                         sslerrconncode = (curl_easy_perform(sslerrconn));
 333
 334                         SSLCertCol = BuildSSLCollection(sslerrconn);
 335                         SSLCertCol.SuccessCode = 1;
 336
 337                         curl_easy_cleanup(conn);
 338                         curl_easy_cleanup(sslerrconn);
 339
 340                         return;
 341
 342                 } else if (claconncode == CURLE_HTTP_RETURNED_ERROR){
 343
 344                         fprintf(stderr, "curl_easy_perform() failed: %s\n",
 345                                         curl_easy_strerror(claconncode));
 346                         int http_code = 0;
 347                         curl_easy_getinfo(conn, CURLINFO_RESPONSE_CODE, &http_code);
 348                         fprintf(stderr, "Error code was: %d\n", http_code);
 349
 350                         curl_easy_cleanup(conn);
 351
 352                         return;
 353
 354                 } else {
 355
 356                         fprintf(stderr, "curl_easy_perform() failed: %s\n",
 357                                         curl_easy_strerror(claconncode));
 358                         int http_code = 0;
 359                         curl_easy_getinfo(conn, CURLINFO_RESPONSE_CODE, &http_code);
 360                         fprintf(stderr, "Error code was: %d\n", http_code);
 361
 362                         curl_easy_cleanup(conn);
 363
 364                         return;
 365
 366                 }
 367
 368         } else {
 369
 370                 // No SSL.
 371
 372                 wxString EmptyString;
 373
 374                 curl_easy_setopt(conn, CURLOPT_URL, (const char*)ServerAddressNormal.mb_str(wxConvUTF8));
 375                 curl_easy_setopt(conn, CURLOPT_NOPROGRESS, 0);
 376                 curl_easy_setopt(conn, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 377                 curl_easy_setopt(conn, CURLOPT_TIMEOUT, 60);
 378                 curl_easy_setopt(conn, CURLOPT_FAILONERROR, TRUE);
 379                 curl_easy_setopt(conn, CURLOPT_USERAGENT, XSDAB_USERAGENT);
 380                 curl_easy_setopt(conn, CURLOPT_USERPWD, (const char*)ServerAuth.mb_str(wxConvUTF8));
 381                 curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, WritebackFunc);
 382                 curl_easy_setopt(conn, CURLOPT_WRITEDATA, &PageData);
 383                 curl_easy_setopt(conn, CURLOPT_WRITEHEADER, &PageHeader);
 384                 curl_easy_setopt(conn, CURLOPT_PROGRESSDATA, this);
 385                 curl_easy_setopt(conn, CURLOPT_PROGRESSFUNCTION, ProgressFunc);
 386                 curl_easy_setopt(conn, CURLOPT_CUSTOMREQUEST, "REPORT");
 387                 curl_easy_setopt(conn, CURLOPT_NOSIGNAL, 1);
 388
 389                 //UploadData.readptr = &CardDAVDataQuery;
 390                 //UploadData.sizeleft = CardDAVDataQuery.Len();
 391                 //curl_easy_setopt(conn, CURLOPT_UPLOAD, 1);
 392                 //curl_easy_setopt(conn, CURLOPT_READDATA, &UploadData);
 393                 //curl_easy_setopt(conn, CURLOPT_READFUNCTION, UploadReadFunc);
 394
 395                 //curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, writefunc);
 396                 curl_easy_setopt(conn, CURLOPT_POSTFIELDS, query);
 397                 curl_easy_setopt(conn, CURLOPT_POSTFIELDSIZE, strlen(query));
 398
 399                 PageData.Clear();
 400                 PageHeader.Clear();
 401
 402                 conncode = (curl_easy_perform(conn));
 403
 404                 if (conncode == CURLE_OK){
 405
 406                 } else if (conncode == CURLE_HTTP_RETURNED_ERROR){
 407
 408                         fprintf(stderr, "curl_easy_perform() failed: %s\n",
 409                                         curl_easy_strerror(conncode));
 410
 411                         return;
 412
 413                 } else {
 414
 415                         fprintf(stderr, "curl_easy_perform() failed: %s\n",
 416                                         curl_easy_strerror(conncode));
 417
 418                         return;
 419
 420                 }
 421
 422         }
 423
 424         xmlDocPtr xmlCardDAVDoc;
 425
 426         xmlCardDAVDoc = xmlReadMemory(PageData.mb_str(wxConvUTF8), (int)PageData.Len(), "noname.xml", NULL, 0);
 427
 428         xmlNodePtr nodeLevel1;
 429         xmlNodePtr nodeLevel2;
 430         xmlNodePtr nodeLevel3;
 431         xmlNodePtr nodeLevel4;
 432         xmlNodePtr nodeLevel5;
 433         xmlNodePtr nodeLevel6;
 434
 435         std::map<wxString,wxString> xmlDataMap;
 436
 437         wxString DataFilename;
 438         wxString ETagData;
 439
 440         std::string xmlStringSafe;
 441
 442         // Tranverse through the catacombs of the response to get our ETag for the file.
 443
 444         for (nodeLevel1 = xmlCardDAVDoc->children;
 445                 nodeLevel1 != NULL;
 446                 nodeLevel1 = nodeLevel1->next)
 447         {
 448
 449                 bool HREFFound = FALSE;
 450                 bool ETagFound = FALSE;
 451
 452                 for (nodeLevel2 = nodeLevel1->children;
 453                         nodeLevel2 != NULL;
 454                         nodeLevel2 = nodeLevel2->next)
 455                 {
 456
 457                         for (nodeLevel3 = nodeLevel2->children;
 458                         nodeLevel3 != NULL;
 459                         nodeLevel3 = nodeLevel3->next)
 460                         {
 461
 462                                 if (!xmlStrcmp(nodeLevel3->name, (const xmlChar *)"href") ||
 463                                 !xmlStrcmp(nodeLevel3->name, (const xmlChar *)"d:href") ||
 464                                 !xmlStrcmp(nodeLevel3->name, (const xmlChar *)"D:href")
 465                                 ){
 466
 467                                         // Get the filename.
 468
 469                                         for (nodeLevel4 = nodeLevel3->children;
 470                                         nodeLevel4 != NULL;
 471                                         nodeLevel4 = nodeLevel4->next)
 472                                         {
 473
 474                                                 if (!xmlStrcmp(nodeLevel4->name, (const xmlChar *)"text") ||
 475                                                 !xmlStrcmp(nodeLevel4->name, (const xmlChar *)"d:text") ||
 476                                                 !xmlStrcmp(nodeLevel4->name, (const xmlChar *)"D:text")
 477                                                 ){
 478
 479                                                         DataFilename = wxString::FromUTF8((const char*)nodeLevel4->content);
 480                                                         wxStringTokenizer wSTDFilename(DataFilename, wxT("/"));
 481
 482                                                         while (wSTDFilename.HasMoreTokens()){
 483
 484                                                                 DataFilename = wSTDFilename.GetNextToken();
 485
 486                                                         }
 487
 488                                                         HREFFound = TRUE;
 489
 490                                                 }
 491
 492
 493
 494                                         }
 495
 496                                 } else {
 497
 498                                         for (nodeLevel4 = nodeLevel3->children;
 499                                         nodeLevel4 != NULL;
 500                                         nodeLevel4 = nodeLevel4->next)
 501                                         {
 502
 503                                                         for (nodeLevel5 = nodeLevel4->children;
 504                                                         nodeLevel5 != NULL;
 505                                                         nodeLevel5 = nodeLevel5->next)
 506                                                         {
 507
 508                                                                 if (!xmlStrcmp(nodeLevel5->name, (const xmlChar *)"getetag") ||
 509                                                                 !xmlStrcmp(nodeLevel5->name, (const xmlChar *)"d:getetag") ||
 510                                                                 !xmlStrcmp(nodeLevel5->name, (const xmlChar *)"D:getetag")
 511                                                                 ){
 512
 513                                                                         for (nodeLevel6 = nodeLevel5->children;
 514                                                                         nodeLevel6 != NULL;
 515                                                                         nodeLevel6 = nodeLevel6->next)
 516                                                                         {
 517
 518                                                                                 // Strip the quotes from the ETag.
 519
 520                                                                                 ETagData = wxString::FromUTF8((const char*)nodeLevel6->content);
 521                                                                                 if (ETagData.Mid(0, 1) == wxT("\"") && ETagData.Mid((ETagData.Len() - 1), 1) == wxT("\"")){
 522
 523                                                                                         ETagData.Remove(0, 1);
 524                                                                                         ETagData.RemoveLast();
 525
 526                                                                                 }
 527
 528                                                                                 ETagFound = TRUE;
 529
 530                                                                         }
 531
 532                                                                 }
 533
 534                                                         }
 535
 536                                         }
 537
 538                                 }
 539
 540                         }
 541
 542                 }
 543
 544                 if (HREFFound == TRUE && ETagFound == TRUE){
 545
 546                         // Add to the map data.
 547
 548                         xmlDataMap.insert(std::make_pair(DataFilename, ETagData));
 549
 550                         HREFFound = FALSE;
 551                         ETagFound = FALSE;
 552
 553                 }
 554
 555
 556         }
 557
 558         xmlFreeDoc(xmlCardDAVDoc);
 559
 560         // Get the first result.
 561
 562         for (std::map<wxString,wxString>::iterator iter = xmlDataMap.begin();
 563                 iter != xmlDataMap.end(); ++iter){
 564
 565                 ETagResult = iter->second;
 566                 break;
 567
 568         }
 569
 570         if (ETagResult.IsEmpty()){
 571
 572                 return;
 573
 574         }
 575
 576         return;
 577
 578 }
 579
 580 void CardDAV::GetServerETagValue(){
 581
 582         std::thread ConnectThread(&CardDAV::GetServerETagValueThread, this);
 583         ConnectThread.detach();
 584
 585 }