source/objects/CalDAV/CalDAV.cpp

   1 // CalDAV.cpp - CalDAV Connection Object.
   2 //
   3 // (c) 2016 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   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 Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "CalDAV.h"
  20
  21 using namespace std;
  22
  23 size_t CalDAVReceive(char *ReceivedBuffer, size_t Size, size_t NewMemoryBytes, string *StringPointer)
  24 {
  25
  26         string ReceivedBufferString = "";
  27         ReceivedBufferString.append(ReceivedBuffer, NewMemoryBytes);
  28
  29         StringPointer->append(ReceivedBufferString);
  30
  31         return Size * NewMemoryBytes;
  32
  33 }
  34
  35 size_t CalDAVSend(char *SendBuffer, size_t Size, size_t NewMemoryBytes, void *DataStruct){
  36
  37         struct CalDAVSendData *UploadPtr = (struct CalDAVSendData *)DataStruct;
  38
  39         if (UploadPtr->sizeleft){
  40
  41                 UploadPtr->sizeleft--;
  42                 char CharSend;
  43
  44                 CharSend = (*UploadPtr->readptr)[UploadPtr->seek];
  45
  46                 *SendBuffer = CharSend;
  47
  48                 UploadPtr->seek++;
  49
  50                 return 1;
  51
  52         }
  53
  54         return 0;
  55
  56 }
  57
  58 CalDAV::CalDAV(){
  59
  60         // Setup the objects within the CalDAV connection
  61         // object.
  62
  63         ConnectionHandle = curl_easy_init();
  64
  65 }
  66
  67 CalDAV::~CalDAV(){
  68
  69         // Destory the objects within the CalDAV connection
  70         // object.
  71
  72         curl_easy_cleanup(ConnectionHandle);
  73         ConnectionHandle = nullptr;
  74
  75 }
  76
  77 void CalDAV::SetupConnectionData(CalDAVConnectionData *ConnData){
  78
  79         // Check if ConnData is a nullptr, return if it is.
  80
  81         if (ConnData == nullptr){
  82                 return;
  83         }
  84
  85         // Set the connection settings to the values from ConnData.
  86
  87         ConnectionData = (*ConnData);
  88
  89 }
  90
  91 CalDAVStatus CalDAV::GetConnectionData(){
  92
  93         // Get the current connection settings for the CalDAV
  94         // connection object and return a CalDAVStatus object.
  95
  96         CalDAVStatus ConnectionStatus;
  97
  98         ConnectionStatus.Hostname = ConnectionData.Hostname;
  99         ConnectionStatus.Port = ConnectionData.Port;
 100         ConnectionStatus.Username = ConnectionData.Username;
 101         ConnectionStatus.Prefix = ConnectionData.Prefix;
 102         ConnectionStatus.UseSSL = ConnectionData.UseSSL;
 103         ConnectionStatus.Timeout = ConnectionData.Timeout;
 104
 105         return ConnectionStatus;
 106
 107 }
 108
 109 CalDAVServerResult CalDAV::Connect(){
 110
 111         CalDAVServerResult ServerResult;
 112
 113         string ServerAddress = "";
 114         string ServerUserPass = "";
 115
 116         // Setup the server address.
 117
 118         ServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 119
 120         // Setup the server password.
 121
 122         ServerUserPass += ConnectionData.Username;
 123         ServerUserPass += ":";
 124         ServerUserPass += ConnectionData.Password;
 125
 126         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, ServerAddress.c_str());
 127         curl_easy_setopt(ConnectionHandle, CURLOPT_USERPWD, ServerUserPass.c_str());
 128         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
 129         curl_easy_setopt(ConnectionHandle, CURLOPT_FAILONERROR, 1L);
 130         curl_easy_setopt(ConnectionHandle, CURLOPT_TIMEOUT, ConnectionData.Timeout);
 131         curl_easy_setopt(ConnectionHandle, CURLOPT_WRITEFUNCTION, CalDAVReceive);
 132         curl_easy_setopt(ConnectionHandle, CURLOPT_WRITEDATA, &ServerData);
 133         curl_easy_setopt(ConnectionHandle, CURLOPT_WRITEHEADER, &ServerHeader);
 134
 135         // Connect to the CalDAV server.
 136
 137         ServerResult.Code = curl_easy_perform(ConnectionHandle);
 138
 139         // Process the result received from the server.
 140
 141         if (ServerResult.Code != CURLE_OK){
 142
 143                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 144
 145         } else {
 146
 147                 ServerResult.Result = CALDAVQUERYRESULT_OK;
 148
 149         }
 150
 151         // Get the HTTP code.
 152
 153         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
 154
 155         return ServerResult;
 156
 157 }
 158
 159 CalDAVServerResult CalDAV::GetServerResult(){
 160
 161         return ConnectionServerResult;
 162
 163 }
 164
 165 CalDAVServerSupport CalDAV::GetServerSupport(){
 166
 167         CalDAVServerSupport ServerStatus;
 168
 169         // Setup the server connection.
 170
 171         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "OPTIONS");
 172
 173         CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
 174
 175         // Set the results.
 176
 177         if (ServerResult == CURLE_OK){
 178                 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
 179         } else {
 180                 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 181         }
 182         ConnectionServerResult.Code = ServerResult;
 183         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
 184
 185         if (ServerResult != CURLE_OK){
 186                 return ServerStatus;
 187         }
 188
 189         // Check that the server header has data in,
 190         // otherwise return an "empty" CalDAVServerSupport.
 191
 192         if (ServerHeader.size() == 0){
 193                 return ServerStatus;
 194         }
 195
 196         // Process each line looking for the first DAV header
 197         // line.
 198
 199         bool NewlineMode = true;
 200
 201         string DAVLine;
 202
 203         for (int CharSeek = 0; CharSeek < ServerHeader.size(); CharSeek++){
 204
 205                 if (NewlineMode == true){
 206
 207                         // Check if we have reached the end of the string.
 208
 209                         if (CharSeek >= ServerHeader.size()){
 210
 211                                 break;
 212
 213                         }
 214
 215                         // Check the first four letters to make sure
 216                         // they are 'DAV:'.
 217
 218                         string DAVHeaderCheck = "";
 219
 220                         try {
 221                                 DAVHeaderCheck = ServerHeader.substr(CharSeek, 4);
 222                         }
 223
 224                         catch (out_of_range &oor){
 225                                 break;
 226                         }
 227
 228                         if (DAVHeaderCheck == "DAV:"){
 229
 230                                 CharSeek += 5;
 231
 232                                 for (; CharSeek < ServerHeader.size(); CharSeek++){
 233
 234                                         if (ServerHeader[CharSeek] == '\n'){
 235
 236                                                 break;
 237
 238                                         }
 239
 240                                         DAVLine.push_back(ServerHeader[CharSeek]);
 241
 242                                 }
 243
 244                                 break;
 245
 246                         }
 247
 248                         NewlineMode = false;
 249
 250                 }
 251
 252                 if (ServerHeader[CharSeek] == '\n'){
 253
 254                         NewlineMode = true;
 255
 256                 }
 257
 258         }
 259
 260         // Process the DAV line.
 261
 262         vector<string> DAVLineData;
 263         string DAVSegmentString;
 264
 265         for (int CharSeek = 0; CharSeek < DAVLine.size(); CharSeek++){
 266
 267                 if (DAVLine[CharSeek] == ' '){
 268                         continue;
 269                 }
 270
 271                 if (DAVLine[CharSeek] == ','){
 272
 273                         DAVLineData.push_back(DAVSegmentString);
 274                         DAVSegmentString.clear();
 275                         continue;
 276
 277                 }
 278
 279                 DAVSegmentString += DAVLine[CharSeek];
 280
 281         }
 282
 283         // Process the DAV values and set each value
 284         // to true as required.
 285
 286         for (int DAVItemSeek = 0;
 287                 DAVItemSeek < DAVLineData.size();
 288                 DAVItemSeek++){
 289
 290                 if (DAVLineData.at(DAVItemSeek) == "calendar-access"){
 291
 292                         ServerStatus.BasicSupport = true;
 293
 294                 }
 295
 296         }
 297
 298         // Reset the connection status.
 299
 300         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 301
 302         return ServerStatus;
 303
 304 }
 305
 306 string CalDAV::GetUserPrincipal(){
 307
 308         string CurrentUserPrincipal = "";
 309         string UserPrincipalRequest = "";
 310         CalDAVSendData UserPrincipalSendData;
 311
 312         UserPrincipalRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 313         "<d:propfind xmlns:d=\"DAV:\">\n"
 314         " <d:prop>\n"
 315         "  <d:current-user-principal />\n"
 316         " </d:prop>\n"
 317         "</d:propfind>";
 318
 319         UserPrincipalSendData.readptr = &UserPrincipalRequest;
 320         UserPrincipalSendData.sizeleft = UserPrincipalRequest.size();
 321
 322         // Setup the header.
 323
 324         struct curl_slist *UserPrincipalRequestHeader = NULL;
 325
 326         UserPrincipalRequestHeader = curl_slist_append(UserPrincipalRequestHeader, "Depth: 0");
 327         UserPrincipalRequestHeader = curl_slist_append(UserPrincipalRequestHeader, "Prefer: return-minimal");
 328         UserPrincipalRequestHeader = curl_slist_append(UserPrincipalRequestHeader, "Content-Type: application/xml; charset=utf-8");
 329
 330         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, UserPrincipalRequestHeader);
 331
 332         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPFIND");
 333         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 334         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &UserPrincipalSendData);
 335         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 336
 337         // Process the data.
 338
 339         ServerData.clear();
 340         ServerHeader.clear();
 341
 342         CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
 343
 344         // Set the results.
 345
 346         if (ServerResult == CURLE_OK){
 347                 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
 348         } else {
 349                 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 350         }
 351         ConnectionServerResult.Code = ServerResult;
 352         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
 353
 354         if (ServerResult != CURLE_OK){
 355
 356                 return CurrentUserPrincipal;
 357
 358         }
 359
 360         // Process the User Principal from the ServerData.
 361
 362         CurrentUserPrincipal = ProcessXMLUserPrincipal();
 363
 364         // Reset the changed settings.
 365
 366         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 367         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 368         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 369
 370         return CurrentUserPrincipal;
 371
 372 }
 373
 374 string CalDAV::GetCalendarHome(string UserPrincipalURI){
 375
 376         string CalendarHomeURI = "";
 377
 378         // Build the Calendar Home URL address.
 379
 380         string CalendarHomeURL = BuildServerAddress(&ConnectionData, UserPrincipalURI);
 381
 382         // Setup the header request.
 383
 384         CalDAVSendData CalendarHomeSendData;
 385
 386         string CalendarHomeRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 387         "<d:propfind xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">\n"
 388         " <d:prop>\n"
 389         "  <c:calendar-home-set />\n"
 390         " </d:prop>\n"
 391         "</d:propfind>";
 392
 393         CalendarHomeSendData.readptr = &CalendarHomeRequest;
 394         CalendarHomeSendData.sizeleft = CalendarHomeRequest.size();
 395
 396         // Setup the header.
 397
 398         struct curl_slist *CalendarRequestHeader = NULL;
 399
 400         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, "Depth: 0");
 401         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, "Prefer: return-minimal");
 402         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, "Content-Type: application/xml; charset=utf-8");
 403
 404         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
 405         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarHomeURL.c_str());
 406         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPFIND");
 407         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 408         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarHomeSendData);
 409         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 410
 411         // Process the data.
 412
 413         ServerData.clear();
 414         ServerHeader.clear();
 415
 416         CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
 417
 418         // Set the results.
 419
 420         if (ServerResult == CURLE_OK){
 421                 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
 422         } else {
 423                 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 424         }
 425         ConnectionServerResult.Code = ServerResult;
 426         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
 427
 428         if (ServerResult != CURLE_OK){
 429
 430                 return CalendarHomeURI;
 431
 432         }
 433
 434         // Process the User Principal from the ServerData.
 435
 436         CalendarHomeURI = ProcessXMLCalendarHome();
 437
 438         // Reset the changed settings.
 439
 440         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 441         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 442
 443         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 444         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 445         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 446         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
 447
 448         return CalendarHomeURI;
 449
 450 }
 451
 452 CalDAVCalendarList CalDAV::GetCalendars(){
 453
 454         CalDAVCalendarList ServerList;
 455         CalDAVSendData CalendarListSendData;
 456
 457         // Build the server address.
 458
 459         string UserPrincipalURI = "";
 460         UserPrincipalURI = GetUserPrincipal();
 461
 462         if (UserPrincipalURI.size() == 0){
 463
 464                 return ServerList;
 465
 466         }
 467
 468         string CalendarHomeURI = "";
 469         CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
 470
 471         string CalendarListURLAddress = BuildServerAddress(&ConnectionData, CalendarHomeURI);
 472
 473         string CalendarListRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 474         "<d:propfind xmlns:d=\"DAV:\" xmlns:cs=\"http://calendarserver.org/ns/\""
 475         " xmlns:c=\"urn:ietf:params:xml:ns:caldav\" xmlns:x0=\"http://apple.com/ns/ical/\">\n"
 476         " <d:prop>\n"
 477         "  <d:resourcetype />\n"
 478         "  <d:displayname />\n"
 479         "  <d:sync-token />\n"
 480         "  <x0:calendar-color />\n"
 481         "  <x0:calendar-order />\n"
 482         "  <cs:getctag />\n"
 483         "  <c:supported-calendar-component-set />\n"
 484         "  <c:calendar-description />\n"
 485         " </d:prop>\n"
 486         "</d:propfind>";
 487
 488         CalendarListSendData.readptr = &CalendarListRequest;
 489         CalendarListSendData.sizeleft = CalendarListRequest.size();
 490
 491         // Setup the header.
 492
 493         struct curl_slist *CalendarListRequestHeader = NULL;
 494
 495         CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Depth: 1");
 496         CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Prefer: return-minimal");
 497         CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Content-Type: application/xml; charset=utf-8");
 498
 499         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarListRequestHeader);
 500         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarListURLAddress.c_str());
 501         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPFIND");
 502         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 503         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarListSendData);
 504         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 505
 506         // Process the data.
 507
 508         ServerData.clear();
 509         ServerHeader.clear();
 510
 511         CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
 512
 513         //ServerList = ProcessXMLCalendarList();
 514
 515         if (ServerResult == CURLE_OK){
 516                 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
 517         } else {
 518                 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 519         }
 520         ConnectionServerResult.Code = ServerResult;
 521         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
 522
 523         if (ServerResult != CURLE_OK){
 524
 525                 return ServerList;
 526
 527         }
 528
 529         // Process the received XML data into a list of calendars
 530         // and locations.
 531
 532         ServerList = ProcessXMLCalendarList();
 533
 534         // Restore the original settings.
 535
 536         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 537
 538         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 539         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 540         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 541         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 542         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 543
 544         return ServerList;
 545
 546 }
 547
 548 CalDAVServerResult CalDAV::AddCalendar(string CalendarName){
 549
 550         CalDAVServerResult ServerResult;
 551         CalDAVSendData CalendarAddSendData;
 552
 553         // Build the server address.
 554
 555         string UserPrincipalURI = "";
 556         UserPrincipalURI = GetUserPrincipal();
 557
 558         if (UserPrincipalURI.size() == 0){
 559
 560                 return ServerResult;
 561
 562         }
 563
 564         string CalendarHomeURI = "";
 565         CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
 566
 567         // Generate the UUID.
 568
 569         string UUIDValue = GenerateUUID();
 570         UUIDValue.erase(UUIDValue.end()-1);
 571
 572         string CalendarHomeURL = CalendarHomeURI;
 573         CalendarHomeURL.append(UUIDValue);
 574         CalendarHomeURL.append("/");
 575
 576         // Build the calendar list address.
 577
 578         string CalendarListURLAddress = BuildServerAddress(&ConnectionData, CalendarHomeURL);
 579
 580         string CalendarAddRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 581         "<c:mkcalendar xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">\n"
 582         " <d:set>\n"
 583         "  <d:prop>\n"
 584         "   <d:displayname>";
 585         CalendarAddRequest += CalendarName;
 586         CalendarAddRequest += "</d:displayname>\n"
 587         "   <c:supported-calendar-component-set>\n"
 588         "    <c:comp name=\"VTODO\"/>\n"
 589         "    <c:comp name=\"VEVENT\"/>\n"
 590         "   </c:supported-calendar-component-set>\n"
 591         "  </d:prop>\n"
 592         " </d:set>\n"
 593         "</c:mkcalendar>";
 594
 595         CalendarAddSendData.readptr = &CalendarAddRequest;
 596         CalendarAddSendData.sizeleft = CalendarAddRequest.size();
 597
 598         // Setup the header.
 599
 600         struct curl_slist *CalendarRequestHeader = NULL;
 601
 602         //curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
 603         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarListURLAddress.c_str());
 604         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "MKCALENDAR");
 605         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 606         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarAddSendData);
 607         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 608
 609         // Process the data.
 610
 611         ServerData.clear();
 612         ServerHeader.clear();
 613
 614         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
 615
 616         if (ServerConnectionResult == CURLE_OK){
 617                 ServerResult.Result = CALDAVQUERYRESULT_OK;
 618         } else {
 619                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 620         }
 621         ServerResult.Code = ServerConnectionResult;
 622         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
 623
 624         // Restore the original settings.
 625
 626         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 627         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 628         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 629         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 630         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 631         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 632
 633         return ServerResult;
 634
 635 }
 636
 637 CalDAVServerResult CalDAV::EditCalendarProcess(string *CalendarHREF,
 638                         string *CalendarName,
 639                         Colour *CalendarColour,
 640                         string *CalendarDescription,
 641                         int *CalendarOrder){
 642
 643         CalDAVServerResult ServerResult;
 644         CalDAVSendData CalendarEditSendData;
 645
 646         // Build the server address.
 647
 648         string UserPrincipalURI = "";
 649         UserPrincipalURI = GetUserPrincipal();
 650
 651         if (UserPrincipalURI.size() == 0){
 652
 653                 return ServerResult;
 654
 655         }
 656
 657         string CalendarHomeURI = "";
 658         CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
 659
 660         // Generate the UUID.
 661
 662         string UUIDValue = GenerateUUID();
 663         UUIDValue.erase(UUIDValue.end()-1);
 664
 665         string CalendarHomeURL = CalendarHomeURI;
 666         CalendarHomeURL.append(UUIDValue);
 667         CalendarHomeURL.append("/");
 668
 669         // Build the calendar list address.
 670
 671         string CalendarEditURLAddress = BuildServerAddress(&ConnectionData, (*CalendarHREF));
 672
 673         string CalendarEditRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 674         "<d:propertyupdate xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\"\n"
 675         "       xmlns:x0=\"http://apple.com/ns/ical/\">\n"
 676         " <d:set>\n"
 677         "  <d:prop>\n";
 678
 679         // Update the calendar name.
 680
 681         if (CalendarName != nullptr){
 682
 683                 CalendarEditRequest += "<d:displayname>";
 684                 CalendarEditRequest += (*CalendarName);
 685                 CalendarEditRequest += "</d:displayname>\n";
 686
 687         }
 688
 689         // Update the calendar colour.
 690
 691         if (CalendarColour != nullptr){
 692
 693                 CalendarEditRequest += "<x0:calendar-color>";
 694                 CalendarEditRequest += (*CalendarColour);
 695                 CalendarEditRequest += "</x0:calendar-color>\n";
 696
 697         }
 698
 699         // Update the calendar description.
 700
 701         if (CalendarDescription != nullptr){
 702
 703                 CalendarEditRequest += "<c:calendar-description>";
 704                 CalendarEditRequest += (*CalendarDescription);
 705                 CalendarEditRequest += "</c:calendar-description>\n";
 706
 707         }
 708
 709         // Update the calendar order.
 710
 711         if (CalendarOrder != nullptr){
 712
 713                 CalendarEditRequest += "<x0:calendar-order>";
 714                 CalendarEditRequest += to_string((*CalendarOrder));
 715                 CalendarEditRequest += "</x0:calendar-order>\n";
 716
 717         }
 718
 719         CalendarEditRequest += "  </d:prop>\n"
 720         " </d:set>\n"
 721         "</d:propertyupdate>";
 722
 723         CalendarEditSendData.readptr = &CalendarEditRequest;
 724         CalendarEditSendData.sizeleft = CalendarEditRequest.size();
 725
 726         // Setup the header.
 727
 728         struct curl_slist *CalendarRequestHeader = NULL;
 729
 730         //curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
 731         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarEditURLAddress.c_str());
 732         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPPATCH");
 733         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 734         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarEditSendData);
 735         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 736
 737         // Process the data.
 738
 739         ServerData.clear();
 740         ServerHeader.clear();
 741
 742         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
 743
 744         if (ServerConnectionResult == CURLE_OK){
 745                 ServerResult.Result = CALDAVQUERYRESULT_OK;
 746         } else {
 747                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 748         }
 749         ServerResult.Code = ServerConnectionResult;
 750         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
 751
 752         // Restore the original settings.
 753
 754         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 755         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 756         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 757         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 758         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 759         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 760
 761         return ServerResult;
 762
 763 }
 764
 765 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
 766                         string *CalendarName,
 767                         Colour *CalendarColour,
 768                         string *CalendarDescription,
 769                         int *CalendarOrder){
 770
 771         CalDAVServerResult ServerResult;
 772
 773         ServerResult = EditCalendarProcess(CalendarHREF,
 774                 CalendarName,
 775                 CalendarColour,
 776                 CalendarDescription,
 777                 CalendarOrder);
 778
 779         return ServerResult;
 780
 781 }
 782
 783 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
 784                         Colour *CalendarColour){
 785
 786
 787         CalDAVServerResult ServerResult;
 788
 789         ServerResult = EditCalendarProcess(CalendarHREF,
 790                 nullptr,
 791                 CalendarColour,
 792                 nullptr,
 793                 nullptr);
 794
 795         return ServerResult;
 796
 797 }
 798
 799 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
 800                         string *CalendarName){
 801
 802         CalDAVServerResult ServerResult;
 803
 804         ServerResult = EditCalendarProcess(CalendarHREF,
 805                 CalendarName,
 806                 nullptr,
 807                 nullptr,
 808                 nullptr);
 809
 810         return ServerResult;
 811
 812 }
 813
 814 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
 815                         int *CalendarOrder){
 816
 817         CalDAVServerResult ServerResult;
 818
 819         ServerResult = EditCalendarProcess(CalendarHREF,
 820                 nullptr,
 821                 nullptr,
 822                 nullptr,
 823                 CalendarOrder);
 824
 825         return ServerResult;
 826
 827 }
 828
 829 CalDAVServerResult CalDAV::EditCalendarDescription(string *CalendarHREF,
 830                         string *CalendarDescription){
 831
 832         CalDAVServerResult ServerResult;
 833
 834         ServerResult = EditCalendarProcess(CalendarHREF,
 835                 nullptr,
 836                 nullptr,
 837                 CalendarDescription,
 838                 nullptr);
 839
 840         return ServerResult;
 841
 842 }
 843
 844 CalDAVServerResult CalDAV::DeleteCalendar(string *CalendarHREF){
 845
 846         CalDAVServerResult ServerResult;
 847
 848         // Build the server address.
 849
 850         string UserPrincipalURI = "";
 851         UserPrincipalURI = GetUserPrincipal();
 852
 853         if (UserPrincipalURI.size() == 0){
 854
 855                 return ServerResult;
 856
 857         }
 858
 859         string CalendarHomeURI = "";
 860         CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
 861
 862         // Generate the UUID.
 863
 864         string UUIDValue = GenerateUUID();
 865         UUIDValue.erase(UUIDValue.end()-1);
 866
 867         string CalendarHomeURL = CalendarHomeURI;
 868         CalendarHomeURL.append(UUIDValue);
 869         CalendarHomeURL.append("/");
 870
 871         // Build the calendar list address.
 872
 873         struct curl_slist *DeleteRequestHeader = NULL;
 874
 875         DeleteRequestHeader = curl_slist_append(DeleteRequestHeader, "Depth: infinity");
 876
 877         string CalendarDeleteURLAddress = BuildServerAddress(&ConnectionData, (*CalendarHREF));
 878
 879         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, DeleteRequestHeader);
 880         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarDeleteURLAddress.c_str());
 881         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "DELETE");
 882
 883         // Delete the calendar.
 884
 885         ServerData.clear();
 886         ServerHeader.clear();
 887
 888         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
 889
 890         if (ServerConnectionResult == CURLE_OK){
 891                 ServerResult.Result = CALDAVQUERYRESULT_OK;
 892         } else {
 893                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 894         }
 895         ServerResult.Code = ServerConnectionResult;
 896         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
 897
 898         // Restore the original settings.
 899
 900         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 901         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 902         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 903         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 904         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
 905         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
 906         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
 907
 908         return ServerResult;
 909
 910 }
 911
 912 CalDAVServerResult CalDAV::GetEntryETag(string *CalendarEntryHREF, string *ETagValue){
 913
 914         CalDAVServerResult ServerResult;
 915         CalDAVSendData EntryETagGetData;
 916
 917         // Build the server address.
 918
 919         string UserPrincipalURI = "";
 920         UserPrincipalURI = GetUserPrincipal();
 921
 922         if (UserPrincipalURI.size() == 0){
 923
 924                 return ServerResult;
 925
 926         }
 927
 928         string CalendarHomeURI = "";
 929         CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
 930
 931         // Split the path and filename.
 932
 933         string EntryURIPath;
 934         string EntryFilename;
 935
 936         SplitPathFilename(CalendarEntryHREF, &EntryURIPath, &EntryFilename);
 937
 938         // Build the request for the server.
 939
 940         string EntryETagRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 941         "<c:calendar-multiget xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">\n"
 942         " <d:prop>\n"
 943         "  <d:getetag />\n"
 944         " </d:prop>\n"
 945         " <d:href>";
 946         EntryETagRequest += (*CalendarEntryHREF);
 947         EntryETagRequest += "</d:href>\n"
 948         "</c:calendar-multiget>";
 949
 950         EntryETagGetData.readptr = &EntryETagRequest;
 951         EntryETagGetData.sizeleft = EntryETagRequest.size();
 952
 953         // Build the calendar list address.
 954
 955         struct curl_slist *GetETagRequestHeader = NULL;
 956
 957         GetETagRequestHeader = curl_slist_append(GetETagRequestHeader, "Depth: 1");
 958         GetETagRequestHeader = curl_slist_append(GetETagRequestHeader, "Prefer: return-minimal");
 959         GetETagRequestHeader = curl_slist_append(GetETagRequestHeader, "Content-Type: application/xml; charset=utf-8");
 960
 961         string GetETagURLAddress = BuildServerAddress(&ConnectionData, EntryURIPath);
 962
 963         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, GetETagRequestHeader);
 964         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, GetETagURLAddress.c_str());
 965         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "REPORT");
 966         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
 967         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &EntryETagGetData);
 968         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
 969
 970         // Attempt to get the entity tag.
 971
 972         ServerData.clear();
 973         ServerHeader.clear();
 974
 975         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
 976
 977         if (ServerConnectionResult == CURLE_OK){
 978                 ServerResult.Result = CALDAVQUERYRESULT_OK;
 979         } else {
 980                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
 981         }
 982         ServerResult.Code = ServerConnectionResult;
 983         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
 984
 985         if (ServerConnectionResult != CURLE_OK){
 986                 return ServerResult;
 987         }
 988
 989         // Get the entity tag from the result.
 990
 991         *ETagValue = ProcessXMLEntryETag();
 992
 993         // Restore the original settings.
 994
 995         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
 996         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
 997         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
 998         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
 999         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
1000         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
1001         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
1002
1003         return ServerResult;
1004
1005 }
1006
1007 CalDAVServerResult CalDAV::AddEntry(string *CalendarEntryHREF, string *EntryData){
1008
1009         // Add an entry to the calendar collection.
1010
1011         CalDAVServerResult ServerResult;
1012         CalDAVSendData EntryAddSendData;
1013
1014         // Build the calendar list address.
1015
1016         string EntryAddURLAddress = BuildServerAddress(&ConnectionData, (*CalendarEntryHREF));
1017
1018         EntryAddSendData.readptr = EntryData;
1019         EntryAddSendData.sizeleft = EntryData->size();
1020
1021         struct curl_slist *CalendarRequestHeader = NULL;
1022
1023         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, "Content-Type: text/calendar; charset=utf-8");
1024
1025         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
1026         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, EntryAddURLAddress.c_str());
1027         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PUT");
1028         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
1029         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &EntryAddSendData);
1030         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
1031
1032         // Process the data.
1033
1034         ServerData.clear();
1035         ServerHeader.clear();
1036
1037         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
1038
1039         if (ServerConnectionResult == CURLE_OK){
1040                 ServerResult.Result = CALDAVQUERYRESULT_OK;
1041         } else {
1042                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
1043         }
1044         ServerResult.Code = ServerConnectionResult;
1045         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
1046
1047         // Restore the original settings.
1048
1049         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
1050         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
1051         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
1052         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
1053         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
1054         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
1055         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
1056
1057         return ServerResult;
1058
1059 }
1060
1061 CalDAVServerResult CalDAV::EditEntry(string *CalendarEntryHREF, string *EntryData, string *EntryETag){
1062
1063         // Edit an entry in the calendar collection.
1064
1065         // Add an entry to the calendar collection.
1066
1067         CalDAVServerResult ServerResult;
1068         CalDAVSendData EntryAddSendData;
1069
1070         // Build the calendar list address.
1071
1072         string EntryAddURLAddress = BuildServerAddress(&ConnectionData, (*CalendarEntryHREF));
1073
1074         EntryAddSendData.readptr = EntryData;
1075         EntryAddSendData.sizeleft = EntryData->size();
1076
1077         string IfMatchHeader = "If-Match: \"";
1078         IfMatchHeader.append(*EntryETag);
1079         IfMatchHeader.append("\"");
1080
1081         struct curl_slist *CalendarRequestHeader = NULL;
1082
1083         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, "Content-Type: text/calendar; charset=utf-8");
1084         CalendarRequestHeader = curl_slist_append(CalendarRequestHeader, IfMatchHeader.c_str());
1085
1086         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
1087         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, EntryAddURLAddress.c_str());
1088         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PUT");
1089         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
1090         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &EntryAddSendData);
1091         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
1092
1093         // Process the data.
1094
1095         ServerData.clear();
1096         ServerHeader.clear();
1097
1098         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
1099
1100         if (ServerConnectionResult == CURLE_OK){
1101                 ServerResult.Result = CALDAVQUERYRESULT_OK;
1102         } else {
1103                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
1104         }
1105         ServerResult.Code = ServerConnectionResult;
1106         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
1107
1108         // Restore the original settings.
1109
1110         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
1111         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
1112         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
1113         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
1114         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
1115         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
1116         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
1117
1118         return ServerResult;
1119
1120 }
1121
1122 CalDAVServerResult CalDAV::DeleteEntry(string *CalendarEntryHREF){
1123
1124         // Delete an entry in the calendar collection.
1125
1126         CalDAVServerResult ServerResult;
1127
1128         // Build the calendar list address.
1129
1130         string EntryDeleteURLAddress = BuildServerAddress(&ConnectionData, (*CalendarEntryHREF));
1131
1132         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
1133         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, EntryDeleteURLAddress.c_str());
1134         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "DELETE");
1135
1136         // Delete the calendar.
1137
1138         ServerData.clear();
1139         ServerHeader.clear();
1140
1141         CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
1142
1143         if (ServerConnectionResult == CURLE_OK){
1144                 ServerResult.Result = CALDAVQUERYRESULT_OK;
1145         } else {
1146                 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
1147         }
1148         ServerResult.Code = ServerConnectionResult;
1149         curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
1150
1151         // Restore the original settings.
1152
1153         string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
1154         curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
1155         curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
1156         curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
1157         curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
1158         curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
1159         curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
1160
1161         return ServerResult;
1162
1163 }
1164
1165 bool CalDAVObjectValidSettings(CalDAVConnectionData *ConnData){
1166
1167         // Check if the passed CalDAV Connection Data is has
1168         // an address set. Return false if nullptr is used.
1169
1170         if (ConnData == nullptr){
1171
1172                 return false;
1173
1174         }
1175
1176         // Check the server hostname. Return false
1177         // if no value has been set.
1178
1179         if (ConnData->Hostname.size() == 0){
1180
1181                 return false;
1182
1183         }
1184
1185         // Check the server port. Return false if
1186         // no value has been set or the port number
1187         // is less than 1 or higher than 65535.
1188
1189         if (ConnData->Port < 1 || ConnData->Port > 65535){
1190
1191                 return false;
1192
1193         }
1194
1195         // Check the server username. Return false
1196         // if no value has been set.
1197
1198         if (ConnData->Username.size() == 0){
1199
1200                 return false;
1201
1202         }
1203
1204         // Check the server password. Return false
1205         // if no value has been set.
1206
1207         if (ConnData->Password.size() == 0){
1208
1209                 return false;
1210
1211         }
1212
1213         // Cannot check UseSSL: It is either true
1214         // or false.
1215
1216         // Cannot check Prefix: The prefix may need
1217         // to be worked out first.
1218
1219         // No errors were found whilst checking so
1220         // return true.
1221
1222         return true;
1223
1224 }
1225
1226 string BuildServerAddress(CalDAVConnectionData *ConnData, string URIAddress){
1227
1228         string ServerAddress;
1229
1230         // Setup the server address.
1231
1232         if (ConnData->UseSSL == true){
1233                 ServerAddress += "https://";
1234         } else {
1235                 ServerAddress += "http://";
1236         }
1237
1238         ServerAddress += ConnData->Hostname;
1239
1240         // Check if server port is 80, otherwise
1241         // specifiy the port number in the address.
1242
1243         if (ConnData->Port != 80){
1244                 ServerAddress += ":";
1245                 ServerAddress += to_string(ConnData->Port);
1246         }
1247
1248         ServerAddress += URIAddress;
1249
1250         return ServerAddress;
1251
1252 }