1 // CalDAV.cpp - CalDAV Connection Object.
3 // (c) 2016 Xestia Software Development.
5 // This file is part of Xestia Calendar.
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.
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.
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/>
23 size_t CalDAVReceive(char *ReceivedBuffer, size_t Size, size_t NewMemoryBytes, string *StringPointer)
26 string ReceivedBufferString = "";
27 ReceivedBufferString.append(ReceivedBuffer, NewMemoryBytes);
29 StringPointer->append(ReceivedBufferString);
31 return Size * NewMemoryBytes;
35 size_t CalDAVSend(char *SendBuffer, size_t Size, size_t NewMemoryBytes, void *DataStruct){
37 struct CalDAVSendData *UploadPtr = (struct CalDAVSendData *)DataStruct;
39 if (UploadPtr->sizeleft){
41 UploadPtr->sizeleft--;
44 CharSend = (*UploadPtr->readptr)[UploadPtr->seek];
46 *SendBuffer = CharSend;
60 // Setup the objects within the CalDAV connection
63 ConnectionHandle = curl_easy_init();
69 // Destory the objects within the CalDAV connection
72 curl_easy_cleanup(ConnectionHandle);
73 ConnectionHandle = nullptr;
77 void CalDAV::SetupConnectionData(CalDAVConnectionData *ConnData){
79 // Check if ConnData is a nullptr, return if it is.
81 if (ConnData == nullptr){
85 // Set the connection settings to the values from ConnData.
87 ConnectionData = (*ConnData);
91 CalDAVStatus CalDAV::GetConnectionData(){
93 // Get the current connection settings for the CalDAV
94 // connection object and return a CalDAVStatus object.
96 CalDAVStatus ConnectionStatus;
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;
105 return ConnectionStatus;
109 CalDAVServerResult CalDAV::Connect(){
111 CalDAVServerResult ServerResult;
113 string ServerAddress = "";
114 string ServerUserPass = "";
116 // Setup the server address.
118 ServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
120 // Setup the server password.
122 ServerUserPass += ConnectionData.Username;
123 ServerUserPass += ":";
124 ServerUserPass += ConnectionData.Password;
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);
135 // Connect to the CalDAV server.
137 ServerResult.Code = curl_easy_perform(ConnectionHandle);
139 // Process the result received from the server.
141 if (ServerResult.Code != CURLE_OK){
143 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
147 ServerResult.Result = CALDAVQUERYRESULT_OK;
151 // Get the HTTP code.
153 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
159 CalDAVServerResult CalDAV::GetServerResult(){
161 return ConnectionServerResult;
165 CalDAVServerSupport CalDAV::GetServerSupport(){
167 CalDAVServerSupport ServerStatus;
169 // Setup the server connection.
171 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "OPTIONS");
173 CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
177 if (ServerResult == CURLE_OK){
178 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
180 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
182 ConnectionServerResult.Code = ServerResult;
183 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
185 if (ServerResult != CURLE_OK){
189 // Check that the server header has data in,
190 // otherwise return an "empty" CalDAVServerSupport.
192 if (ServerHeader.size() == 0){
196 // Process each line looking for the first DAV header
199 bool NewlineMode = true;
203 for (int CharSeek = 0; CharSeek < ServerHeader.size(); CharSeek++){
205 if (NewlineMode == true){
207 // Check if we have reached the end of the string.
209 if (CharSeek >= ServerHeader.size()){
215 // Check the first four letters to make sure
218 string DAVHeaderCheck = "";
221 DAVHeaderCheck = ServerHeader.substr(CharSeek, 4);
224 catch (out_of_range &oor){
228 if (DAVHeaderCheck == "DAV:"){
232 for (; CharSeek < ServerHeader.size(); CharSeek++){
234 if (ServerHeader[CharSeek] == '\n'){
240 DAVLine.push_back(ServerHeader[CharSeek]);
252 if (ServerHeader[CharSeek] == '\n'){
260 // Process the DAV line.
262 vector<string> DAVLineData;
263 string DAVSegmentString;
265 for (int CharSeek = 0; CharSeek < DAVLine.size(); CharSeek++){
267 if (DAVLine[CharSeek] == ' '){
271 if (DAVLine[CharSeek] == ','){
273 DAVLineData.push_back(DAVSegmentString);
274 DAVSegmentString.clear();
279 DAVSegmentString += DAVLine[CharSeek];
283 // Process the DAV values and set each value
284 // to true as required.
286 for (int DAVItemSeek = 0;
287 DAVItemSeek < DAVLineData.size();
290 if (DAVLineData.at(DAVItemSeek) == "calendar-access"){
292 ServerStatus.BasicSupport = true;
298 // Reset the connection status.
300 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
306 string CalDAV::GetUserPrincipal(){
308 string CurrentUserPrincipal = "";
309 string UserPrincipalRequest = "";
310 CalDAVSendData UserPrincipalSendData;
312 UserPrincipalRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
313 "<d:propfind xmlns:d=\"DAV:\">\n"
315 " <d:current-user-principal />\n"
319 UserPrincipalSendData.readptr = &UserPrincipalRequest;
320 UserPrincipalSendData.sizeleft = UserPrincipalRequest.size();
324 struct curl_slist *UserPrincipalRequestHeader = NULL;
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");
330 curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, UserPrincipalRequestHeader);
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);
340 ServerHeader.clear();
342 CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
346 if (ServerResult == CURLE_OK){
347 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
349 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
351 ConnectionServerResult.Code = ServerResult;
352 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
354 if (ServerResult != CURLE_OK){
356 return CurrentUserPrincipal;
360 // Process the User Principal from the ServerData.
362 CurrentUserPrincipal = ProcessXMLUserPrincipal();
364 // Reset the changed settings.
366 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
367 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
368 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
370 return CurrentUserPrincipal;
374 string CalDAV::GetCalendarHome(string UserPrincipalURI){
376 string CalendarHomeURI = "";
378 // Build the Calendar Home URL address.
380 string CalendarHomeURL = BuildServerAddress(&ConnectionData, UserPrincipalURI);
382 // Setup the header request.
384 CalDAVSendData CalendarHomeSendData;
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"
389 " <c:calendar-home-set />\n"
393 CalendarHomeSendData.readptr = &CalendarHomeRequest;
394 CalendarHomeSendData.sizeleft = CalendarHomeRequest.size();
398 struct curl_slist *CalendarRequestHeader = NULL;
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");
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);
414 ServerHeader.clear();
416 CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
420 if (ServerResult == CURLE_OK){
421 ConnectionServerResult.Result = CALDAVQUERYRESULT_OK;
423 ConnectionServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
425 ConnectionServerResult.Code = ServerResult;
426 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ConnectionServerResult.HTTPCode);
428 if (ServerResult != CURLE_OK){
430 return CalendarHomeURI;
434 // Process the User Principal from the ServerData.
436 CalendarHomeURI = ProcessXMLCalendarHome();
438 // Reset the changed settings.
440 string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
441 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
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);
448 return CalendarHomeURI;
452 CalDAVCalendarList CalDAV::GetCalendars(){
454 CalDAVCalendarList ServerList;
455 CalDAVSendData CalendarListSendData;
457 // Build the server address.
459 string UserPrincipalURI = "";
460 UserPrincipalURI = GetUserPrincipal();
462 if (UserPrincipalURI.size() == 0){
468 string CalendarHomeURI = "";
469 CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
471 string CalendarListURLAddress = BuildServerAddress(&ConnectionData, CalendarHomeURI);
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"
477 " <d:resourcetype />\n"
478 " <d:displayname />\n"
479 " <x0:calendar-color />\n"
480 " <x0:calendar-order />\n"
482 " <c:supported-calendar-component-set />\n"
483 " <c:calendar-description />\n"
487 CalendarListSendData.readptr = &CalendarListRequest;
488 CalendarListSendData.sizeleft = CalendarListRequest.size();
492 struct curl_slist *CalendarListRequestHeader = NULL;
494 CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Depth: 1");
495 CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Prefer: return-minimal");
496 CalendarListRequestHeader = curl_slist_append(CalendarListRequestHeader, "Content-Type: application/xml; charset=utf-8");
498 curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarListRequestHeader);
499 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarListURLAddress.c_str());
500 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPFIND");
501 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
502 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarListSendData);
503 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
508 ServerHeader.clear();
510 CURLcode ServerResult = curl_easy_perform(ConnectionHandle);
512 //ServerList = ProcessXMLCalendarList();
514 // Restore the original settings.
516 string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals");
517 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
518 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
519 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
520 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
521 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
523 // Process the received XML data into a list of calendars
526 if (ServerResult != CURLE_OK){
532 ServerList = ProcessXMLCalendarList();
538 CalDAVServerResult CalDAV::AddCalendar(string CalendarName){
540 CalDAVServerResult ServerResult;
541 CalDAVSendData CalendarAddSendData;
543 // Build the server address.
545 string UserPrincipalURI = "";
546 UserPrincipalURI = GetUserPrincipal();
548 if (UserPrincipalURI.size() == 0){
554 string CalendarHomeURI = "";
555 CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
557 // Generate the UUID.
559 string UUIDValue = GenerateUUID();
560 UUIDValue.erase(UUIDValue.end()-1);
562 string CalendarHomeURL = CalendarHomeURI;
563 CalendarHomeURL.append(UUIDValue);
564 CalendarHomeURL.append("/");
566 // Build the calendar list address.
568 string CalendarListURLAddress = BuildServerAddress(&ConnectionData, CalendarHomeURL);
570 string CalendarAddRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
571 "<c:mkcalendar xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">\n"
575 CalendarAddRequest += CalendarName;
576 CalendarAddRequest += "</d:displayname>\n"
577 " <c:supported-calendar-component-set>\n"
578 " <c:comp name=\"VTODO\"/>\n"
579 " <c:comp name=\"VEVENT\"/>\n"
580 " </c:supported-calendar-component-set>\n"
585 CalendarAddSendData.readptr = &CalendarAddRequest;
586 CalendarAddSendData.sizeleft = CalendarAddRequest.size();
590 struct curl_slist *CalendarRequestHeader = NULL;
592 //curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
593 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarListURLAddress.c_str());
594 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "MKCALENDAR");
595 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
596 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarAddSendData);
597 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
602 ServerHeader.clear();
604 CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
606 if (ServerConnectionResult == CURLE_OK){
607 ServerResult.Result = CALDAVQUERYRESULT_OK;
609 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
611 ServerResult.Code = ServerConnectionResult;
612 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
614 // Restore the original settings.
616 string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
617 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
618 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
619 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
620 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
621 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
627 CalDAVServerResult CalDAV::EditCalendarProcess(string *CalendarHREF,
628 string *CalendarName,
629 Colour *CalendarColour,
630 string *CalendarDescription,
633 CalDAVServerResult ServerResult;
634 CalDAVSendData CalendarEditSendData;
636 // Build the server address.
638 string UserPrincipalURI = "";
639 UserPrincipalURI = GetUserPrincipal();
641 if (UserPrincipalURI.size() == 0){
647 string CalendarHomeURI = "";
648 CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
650 // Generate the UUID.
652 string UUIDValue = GenerateUUID();
653 UUIDValue.erase(UUIDValue.end()-1);
655 string CalendarHomeURL = CalendarHomeURI;
656 CalendarHomeURL.append(UUIDValue);
657 CalendarHomeURL.append("/");
659 // Build the calendar list address.
661 string CalendarEditURLAddress = BuildServerAddress(&ConnectionData, (*CalendarHREF));
663 string CalendarEditRequest = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
664 "<d:propertyupdate xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\"\n"
665 " xmlns:x0=\"http://apple.com/ns/ical/\">\n"
669 // Update the calendar name.
671 if (CalendarName != nullptr){
673 CalendarEditRequest += "<d:displayname>";
674 CalendarEditRequest += (*CalendarName);
675 CalendarEditRequest += "</d:displayname>\n";
679 // Update the calendar colour.
681 if (CalendarColour != nullptr){
683 CalendarEditRequest += "<x0:calendar-color>";
684 CalendarEditRequest += (*CalendarColour);
685 CalendarEditRequest += "</x0:calendar-color>\n";
689 // Update the calendar description.
691 if (CalendarDescription != nullptr){
693 CalendarEditRequest += "<c:calendar-description>";
694 CalendarEditRequest += (*CalendarDescription);
695 CalendarEditRequest += "</c:calendar-description>\n";
699 // Update the calendar order.
701 if (CalendarOrder != nullptr){
703 CalendarEditRequest += "<x0:calendar-order>";
704 CalendarEditRequest += to_string((*CalendarOrder));
705 CalendarEditRequest += "</x0:calendar-order>\n";
709 CalendarEditRequest += " </d:prop>\n"
711 "</d:propertyupdate>";
713 CalendarEditSendData.readptr = &CalendarEditRequest;
714 CalendarEditSendData.sizeleft = CalendarEditRequest.size();
718 struct curl_slist *CalendarRequestHeader = NULL;
720 //curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, CalendarRequestHeader);
721 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarEditURLAddress.c_str());
722 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "PROPPATCH");
723 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 1L);
724 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, &CalendarEditSendData);
725 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, CalDAVSend);
730 ServerHeader.clear();
732 CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
734 if (ServerConnectionResult == CURLE_OK){
735 ServerResult.Result = CALDAVQUERYRESULT_OK;
737 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
739 ServerResult.Code = ServerConnectionResult;
740 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
742 // Restore the original settings.
744 string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
745 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
746 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
747 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
748 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
749 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
755 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
756 string *CalendarName,
757 Colour *CalendarColour,
758 string *CalendarDescription,
761 CalDAVServerResult ServerResult;
763 ServerResult = EditCalendarProcess(CalendarHREF,
773 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
774 Colour *CalendarColour){
777 CalDAVServerResult ServerResult;
779 ServerResult = EditCalendarProcess(CalendarHREF,
789 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
790 string *CalendarName){
792 CalDAVServerResult ServerResult;
794 ServerResult = EditCalendarProcess(CalendarHREF,
804 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
807 CalDAVServerResult ServerResult;
809 ServerResult = EditCalendarProcess(CalendarHREF,
819 CalDAVServerResult CalDAV::EditCalendarDescription(string *CalendarHREF,
820 string *CalendarDescription){
822 CalDAVServerResult ServerResult;
824 ServerResult = EditCalendarProcess(CalendarHREF,
834 CalDAVServerResult CalDAV::DeleteCalendar(string *CalendarHREF){
836 CalDAVServerResult ServerResult;
838 // Build the server address.
840 string UserPrincipalURI = "";
841 UserPrincipalURI = GetUserPrincipal();
843 if (UserPrincipalURI.size() == 0){
849 string CalendarHomeURI = "";
850 CalendarHomeURI = GetCalendarHome(UserPrincipalURI);
852 // Generate the UUID.
854 string UUIDValue = GenerateUUID();
855 UUIDValue.erase(UUIDValue.end()-1);
857 string CalendarHomeURL = CalendarHomeURI;
858 CalendarHomeURL.append(UUIDValue);
859 CalendarHomeURL.append("/");
861 // Build the calendar list address.
863 struct curl_slist *DeleteRequestHeader = NULL;
865 DeleteRequestHeader = curl_slist_append(DeleteRequestHeader, "Depth: infinity");
867 string CalendarDeleteURLAddress = BuildServerAddress(&ConnectionData, (*CalendarHREF));
869 curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, DeleteRequestHeader);
870 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, CalendarDeleteURLAddress.c_str());
871 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, "DELETE");
873 // Delete the calendar.
876 ServerHeader.clear();
878 CURLcode ServerConnectionResult = curl_easy_perform(ConnectionHandle);
880 if (ServerConnectionResult == CURLE_OK){
881 ServerResult.Result = CALDAVQUERYRESULT_OK;
883 ServerResult.Result = CALDAVQUERYRESULT_SERVERERROR;
885 ServerResult.Code = ServerConnectionResult;
886 curl_easy_getinfo(ConnectionHandle, CURLINFO_RESPONSE_CODE, &ServerResult.HTTPCode);
888 // Restore the original settings.
890 string OriginalServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
891 curl_easy_setopt(ConnectionHandle, CURLOPT_URL, OriginalServerAddress.c_str());
892 curl_easy_setopt(ConnectionHandle, CURLOPT_CUSTOMREQUEST, NULL);
893 curl_easy_setopt(ConnectionHandle, CURLOPT_UPLOAD, 0L);
894 curl_easy_setopt(ConnectionHandle, CURLOPT_READDATA, NULL);
895 curl_easy_setopt(ConnectionHandle, CURLOPT_READFUNCTION, NULL);
896 curl_easy_setopt(ConnectionHandle, CURLOPT_HTTPHEADER, NULL);
902 bool CalDAVObjectValidSettings(CalDAVConnectionData *ConnData){
904 // Check if the passed CalDAV Connection Data is has
905 // an address set. Return false if nullptr is used.
907 if (ConnData == nullptr){
913 // Check the server hostname. Return false
914 // if no value has been set.
916 if (ConnData->Hostname.size() == 0){
922 // Check the server port. Return false if
923 // no value has been set or the port number
924 // is less than 1 or higher than 65535.
926 if (ConnData->Port < 1 || ConnData->Port > 65535){
932 // Check the server username. Return false
933 // if no value has been set.
935 if (ConnData->Username.size() == 0){
941 // Check the server password. Return false
942 // if no value has been set.
944 if (ConnData->Password.size() == 0){
950 // Cannot check UseSSL: It is either true
953 // Cannot check Prefix: The prefix may need
954 // to be worked out first.
956 // No errors were found whilst checking so
963 string BuildServerAddress(CalDAVConnectionData *ConnData, string URIAddress){
965 string ServerAddress;
967 // Setup the server address.
969 if (ConnData->UseSSL == true){
970 ServerAddress += "https://";
972 ServerAddress += "http://";
975 ServerAddress += ConnData->Hostname;
977 // Check if server port is 80, otherwise
978 // specifiy the port number in the address.
980 if (ConnData->Port != 80){
981 ServerAddress += ":";
982 ServerAddress += to_string(ConnData->Port);
985 ServerAddress += URIAddress;
987 return ServerAddress;