Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Get the sync-token value for the calendars.
[xestiacalendar/.git] / 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/>
19 #include "CalDAV.h"
21 using namespace std;
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 }
35 size_t CalDAVSend(char *SendBuffer, size_t Size, size_t NewMemoryBytes, void *DataStruct){
37         struct CalDAVSendData *UploadPtr = (struct CalDAVSendData *)DataStruct;
38         
39         if (UploadPtr->sizeleft){
41                 UploadPtr->sizeleft--;
42                 char CharSend;
44                 CharSend = (*UploadPtr->readptr)[UploadPtr->seek];
45                 
46                 *SendBuffer = CharSend;
47                 
48                 UploadPtr->seek++;
50                 return 1;
52         }
54         return 0;
56 }
58 CalDAV::CalDAV(){
60         // Setup the objects within the CalDAV connection 
61         // object.
62         
63         ConnectionHandle = curl_easy_init();
64         
65 }
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 }
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.
87         ConnectionData = (*ConnData);
88         
89 }
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         
109 CalDAVServerResult CalDAV::Connect(){
111         CalDAVServerResult ServerResult;
113         string ServerAddress = "";
114         string ServerUserPass = "";
116         // Setup the server address.
117         
118         ServerAddress = BuildServerAddress(&ConnectionData, "/principals/");
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);
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         
159 CalDAVServerResult CalDAV::GetServerResult(){
160         
161         return ConnectionServerResult;
162         
165 CalDAVServerSupport CalDAV::GetServerSupport(){
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         
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);
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.
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);
370         return CurrentUserPrincipal;
374 string CalDAV::GetCalendarHome(string UserPrincipalURI){
375         
376         string CalendarHomeURI = "";
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.
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         
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         
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         
637 CalDAVServerResult CalDAV::EditCalendarProcess(string *CalendarHREF,
638                         string *CalendarName,
639                         Colour *CalendarColour,
640                         string *CalendarDescription,
641                         int *CalendarOrder){
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;
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         
783 CalDAVServerResult CalDAV::EditCalendar(string *CalendarHREF,
784                         Colour *CalendarColour){
785         
787         CalDAVServerResult ServerResult;
789         ServerResult = EditCalendarProcess(CalendarHREF,
790                 nullptr,
791                 CalendarColour,
792                 nullptr,
793                 nullptr);
794                                 
795         return ServerResult;    
796         
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         
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         
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         
844 CalDAVServerResult CalDAV::DeleteCalendar(string *CalendarHREF){
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         
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);
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.
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;
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         
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         
1061 CalDAVServerResult CalDAV::EditEntry(string *CalendarEntryHREF, string *EntryData, string *EntryETag){
1062         
1063         // Edit an entry in the calendar collection.
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         
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         
1165 bool CalDAVObjectValidSettings(CalDAVConnectionData *ConnData){
1167         // Check if the passed CalDAV Connection Data is has
1168         // an address set. Return false if nullptr is used.
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         }
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.
1219         // No errors were found whilst checking so
1220         // return true.
1221         
1222         return true;
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         
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy