4 * Copyright 2016 Michael Rasmussen <mir@datanom.net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program 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
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
24 #include <curl/curl.h>
25 #include <curl/easy.h>
30 const char* const CollectionType_string
[] = {"unknown", "principal","calendar","addressbook"};
32 #define etag_request_head "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
33 "<C:addressbook-query xmlns:D=\"DAV:\" " \
34 "xmlns:C=\"urn:ietf:params:xml:ns:carddav\">" \
38 "<C:filter test=\"anyof\">" \
39 "<C:prop-filter name=\"UID\">" \
40 "<C:text-match collation=\"i;unicode-casemap\" " \
41 "match-type=\"contains\">"
43 #define etag_request_back "</C:text-match>" \
46 "</C:addressbook-query>"
48 #define prop_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
49 "<d:propfind xmlns:d=\"DAV:\">" \
52 "<d:current-user-privilege-set/>" \
55 "<d:getlastmodified/>" \
56 "<d:getcontenttype/>" \
60 #define changed_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
61 "<card:addressbook-query xmlns:d=\"DAV:\" " \
62 "xmlns:card=\"urn:ietf:params:xml:ns:carddav\">" \
66 "</card:addressbook-query>"
68 #define data_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
69 "<card:addressbook-query xmlns:d=\"DAV:\" " \
70 "xmlns:card=\"urn:ietf:params:xml:ns:carddav\">" \
73 "<card:address-data />" \
75 "</card:addressbook-query>"
91 char trace_ascii
; /* 1 or 0 */
95 MemoryStruct
* headers
;
97 char error_buf
[CURL_ERROR_SIZE
];
100 static Buffers
* buffers_new() {
101 Buffers
* buffers
= g_new0(Buffers
, 1);
102 buffers
->data
= g_new0(MemoryStruct
, 1);
103 buffers
->data
->size
= 0;
104 buffers
->headers
= g_new0(MemoryStruct
, 1);
105 buffers
->headers
->size
= 0;
110 static void buffers_free(Buffers
* buffers
) {
112 if (buffers
->data
->memory
)
113 g_free(buffers
->data
->memory
);
114 g_free(buffers
->data
);
115 if (buffers
->headers
->memory
)
116 g_free(buffers
->headers
->memory
);
117 g_free(buffers
->headers
);
122 static void print_buffers(Buffers
* buffers
) {
123 if (buffers
== NULL
) return;
124 g_print("Headers: %s\nData: %s\nError: %s\n",
125 buffers
->headers
->size
> 0 ? buffers
->headers
->memory
: "",
126 buffers
->data
->size
> 0 ? buffers
->data
->memory
: "",
131 * This function is burrowed from the libcurl documentation
138 static void dump(const char* text
, FILE* stream
, char* ptr
, size_t size
, char nohex
) {
142 unsigned int width
=0x10;
145 /* without the hex output, we can fit more on screen */
147 fprintf(stream
, "%s, %zd bytes (0x%zx)\n", text
, size
, size
);
148 for(i
=0; i
<size
; i
+= width
) {
149 fprintf(stream
, "%04zx: ", i
);
151 /* hex not disabled, show it */
152 for(c
= 0; c
< width
; c
++) {
154 fprintf(stream
, "%02x ", ptr
[i
+c
]);
159 for(c
= 0; (c
< width
) && (i
+c
< size
); c
++) {
160 /* check for 0D0A; if found, skip past and start a new line of output */
161 if (nohex
&& (i
+c
+1 < size
) && ptr
[i
+c
]==0x0D && ptr
[i
+c
+1]==0x0A) {
165 fprintf(stream
, "%c",(ptr
[i
+c
]>=0x20) && (ptr
[i
+c
]<0x80)?ptr
[i
+c
]:'.');
166 /* check again for 0D0A, to avoid an extra \n if it's at width */
167 if (nohex
&& (i
+c
+2 < size
) && ptr
[i
+c
+1]==0x0D && ptr
[i
+c
+2]==0x0A) {
172 fputc('\n', stream
); /* newline */
178 * This function is burrowed from the libcurl documentation
186 static int my_trace(CURL
* handle
, curl_infotype type
, char* data
, size_t size
, void* userp
) {
187 Data
* config
= (Data
*)userp
;
189 (void)handle
; /* prevent compiler warning */
193 fprintf(stderr
, "== Info: %s", data
);
194 default: /* in case a new one is introduced to shock us */
196 case CURLINFO_HEADER_OUT
:
197 text
= "=> Send header";
199 case CURLINFO_DATA_OUT
:
200 text
= "=> Send data";
202 case CURLINFO_SSL_DATA_OUT
:
203 text
= "=> Send SSL data";
205 case CURLINFO_HEADER_IN
:
206 text
= "<= Recv header";
208 case CURLINFO_DATA_IN
:
209 text
= "<= Recv data";
211 case CURLINFO_SSL_DATA_IN
:
212 text
= "<= Recv SSL data";
215 dump(text
, stderr
, data
, size
, config
->trace_ascii
);
220 * This function is burrowed from the libcurl documentation
223 * @return void* to memory region
225 static void* myrealloc(void* ptr
, size_t size
) {
226 /* There might be a realloc() out there that doesn't like reallocing
227 * NULL pointers, so we take care of it here
230 return realloc(ptr
, size
);
236 * This function is burrowed from the libcurl documentation
241 * @return number of written bytes
243 static size_t WriteMemoryCallback(void* ptr
, size_t size
, size_t nmemb
, void* data
) {
244 size_t realsize
= size
* nmemb
;
245 MemoryStruct
* mem
= (MemoryStruct
*)data
;
246 mem
->memory
= (char *)myrealloc(mem
->memory
, mem
->size
+ realsize
+ 1);
249 memcpy(&(mem
->memory
[mem
->size
]), ptr
, realsize
);
250 mem
->size
+= realsize
;
251 mem
->memory
[mem
->size
] = 0;
256 static CURL
* get_curl(CarddavData
* data
, const gchar
* extra_url
) {
262 curl
= curl_easy_init();
265 userpwd
= g_strconcat(data
->user
, ":", data
->pwd
, NULL
);
266 curl_easy_setopt(curl
, CURLOPT_USERPWD
, userpwd
);
268 userpwd
= g_strconcat(data
->user
, NULL
);
269 curl_easy_setopt(curl
, CURLOPT_USERPWD
, userpwd
);
272 curl_easy_setopt(curl
, CURLOPT_HTTPAUTH
, CURLAUTH_ANY
);
273 curl_easy_setopt(curl
, CURLOPT_USERAGENT
, "carddavParser");
276 url
= g_strconcat(data
->url
, "/", extra_url
, NULL
);
278 url
= g_strconcat(data
->url
, NULL
);
279 curl_easy_setopt(curl
, CURLOPT_URL
, url
);
282 curl_easy_setopt(curl
, CURLOPT_WRITEFUNCTION
, WriteMemoryCallback
);
283 curl_easy_setopt(curl
, CURLOPT_HEADERFUNCTION
, WriteMemoryCallback
);
285 config
.trace_ascii
= 1;
286 curl_easy_setopt(curl
, CURLOPT_DEBUGFUNCTION
, my_trace
);
287 curl_easy_setopt(curl
, CURLOPT_DEBUGDATA
, &config
);
288 curl_easy_setopt(curl
, CURLOPT_VERBOSE
, 1);
290 curl_easy_setopt(curl
, CURLOPT_FOLLOWLOCATION
, 1);
291 curl_easy_setopt(curl
, CURLOPT_UNRESTRICTED_AUTH
, 1);
292 curl_easy_setopt(curl
, CURLOPT_POSTREDIR
, CURL_REDIR_POST_ALL
);
298 static CURL
* prepare_curl(CarddavData
* dav
, Buffers
* buffers
, Request type
, const gchar
* extra_url
) {
299 CURL
* curl
= get_curl(dav
, extra_url
);
301 curl_easy_setopt(curl
, CURLOPT_WRITEDATA
, (void *)buffers
->data
);
302 curl_easy_setopt(curl
, CURLOPT_WRITEHEADER
, (void *)buffers
->headers
);
303 curl_easy_setopt(curl
, CURLOPT_ERRORBUFFER
, (char *)buffers
->error_buf
);
306 curl_easy_setopt(curl
, CURLOPT_CUSTOMREQUEST
, "OPTIONS");
309 curl_easy_setopt(curl
, CURLOPT_CUSTOMREQUEST
, "PROPFIND");
312 curl_easy_setopt(curl
, CURLOPT_CUSTOMREQUEST
, "REPORT");
315 curl_easy_setopt(curl
, CURLOPT_CUSTOMREQUEST
, "PUT");
318 curl_easy_setopt(curl
, CURLOPT_CUSTOMREQUEST
, "DELETE");
326 static gboolean
has_support(CarddavData
* dav
, const gchar
* headers
) {
327 gboolean support
= FALSE
;
329 //g_print("%s\n", headers);
330 gchar
* start
= g_strstr_len(headers
, -1, "DAV");
332 gchar
** values
= g_strsplit(start
, ":", 0);
333 if (values
&& g_strv_length(values
) > 1) {
334 gchar
** options
= g_strsplit(values
[1], ",", 0);
335 if (options
&& g_strv_length(options
) > 0) {
336 gchar
** tmp
= options
;
339 gchar
* end
= g_strstr_len(*tmp
, -1, "\r");
341 gchar
* str
= g_strndup(*tmp
, end
- *tmp
);
342 opt
= g_ascii_strup(str
, -1);
344 option
= g_strstrip(opt
);
346 opt
= g_ascii_strup(*tmp
, -1);
347 option
= g_strstrip(opt
);
349 if (g_strcmp0(option
, "ADDRESSBOOK") == 0)
351 if (g_strcmp0(option
, "EXTENDED-MKCOL") == 0)
365 static gchar
* find_text(const gchar
* string
, const gchar
* start
, const gchar
* end
) {
369 gchar
* s_start
= g_strstr_len(string
, -1, start
);
371 gchar
* s_end
= g_strstr_len(s_start
, -1, end
);
372 if (s_start
&& s_end
) {
373 text
= g_strndup(s_start
+ strlen(start
), s_end
- (s_start
+ strlen(start
)));
381 static gchar
* remove_ns(const gchar
* s
) {
385 gchar
* s_start
= g_strstr_len(s
, -1, ":");
387 s1
= g_strndup(s_start
+ 1, strlen(s_start
+ 1));
397 static gchar
* remove_start_end(const gchar
* s
, const gchar
* begin
, const gchar
* end
) {
401 gchar
* s_start
= g_strstr_len(s
, -1, begin
);
403 gchar
* s_end
= g_strstr_len(s_start
+ 1, -1, end
);
405 s1
= g_strndup(s_start
+ strlen(begin
), s_end
- (s_start
+ strlen(begin
)));
414 static CollectionType
get_collection_type(const gchar
* s
) {
415 CollectionType type
= UNKNOWN
;
416 int len
= sizeof(CollectionType_string
)/sizeof(CollectionType_string
[0]);
419 for (int i
= 0; i
< len
; ++i
) {
420 if (g_strcmp0(CollectionType_string
[i
], s
) == 0) {
431 static gchar
* get_etag(const gchar
* string
) {
434 etag
= find_text(string
, "<getetag>", "</getetag>");
439 static gchar
* get_etag_ns(const gchar
* string
, const gchar
* ns
) {
443 gchar
* etag_begin
= g_strconcat("<", ns
, ":", "getetag>", NULL
);
444 gchar
* etag_end
= g_strconcat("</", ns
, ":", "getetag>", NULL
);
445 etag
= find_text(string
, etag_begin
, etag_end
);
449 etag
= find_text(string
, "<getetag>", "</getetag>");
455 static gchar
* get_etag_header(const gchar
* headers
) {
459 gchar
* raw
= find_text(headers
, "ETag:", "\n");
461 etag
= g_strdup(raw
);
462 for (int i
= 0; i
< strlen(raw
); i
++) {
464 if (l
!= 2 && l
!= 60 && raw
[i
] != '\r') {
478 gchar
* curl_get_etag(CarddavData
* dav
, const gchar
* uid
, GString
* buf
) {
480 Buffers
* buffers
= buffers_new();
481 CURLcode curlres
= 0;
482 struct curl_slist
*list
= NULL
;
485 CURL
* curl
= prepare_curl(dav
, buffers
, REPORT
, NULL
);
487 list
= curl_slist_append(list
, "Depth: 1");
488 list
= curl_slist_append(list
, "Content-Type: text/xml; charset=\"utf-8\"");
489 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
490 gchar
* request
= g_strconcat(etag_request_head
, uid
, etag_request_back
, NULL
);
491 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, request
);
492 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
493 curlres
= curl_easy_perform(curl
);
497 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
499 etag
= get_etag_ns(buffers
->data
->memory
, "d");
500 gchar
* clean
= remove_start_end(etag
, """, """);
507 curl_easy_cleanup(curl
);
508 curl_slist_free_all(list
);
512 buf
= g_string_assign(buf
, "Missing UID");
515 buffers_free(buffers
);
520 gboolean
curl_set_object(CarddavData
* dav
, VCard
* vcard
, GString
* buf
) {
521 gboolean res
= FALSE
;
522 CURLcode curlres
= 0;
523 Buffers
* buffers
= buffers_new();
524 struct curl_slist
*list
= NULL
;
526 GSList
* uid
= VCard_get_property(vcard
, "UID");
529 buf
= g_string_assign(buf
, "VCard missing UID");
532 VCardProperty
* prop
= (VCardProperty
*) uid
->data
;
533 gchar
* extra_url
= g_strconcat(prop
->value
, ".vcf", NULL
);
534 vcard_slist_property_free(uid
);
535 CURL
* curl
= prepare_curl(dav
, buffers
, PUT
, extra_url
);
538 list
= curl_slist_append(list
, "If-None-Match: *");
539 list
= curl_slist_append(list
, "Content-Type: text/vcard");
540 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
541 gchar
* card
= VCard_get_as_string(vcard
);
542 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, card
);
543 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
544 curlres
= curl_easy_perform(curl
);
547 buf
= g_string_assign(buf
, buffers
->error_buf
);
553 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
556 buf
= g_string_assign(buf
, buffers
->data
->memory
);
557 g_string_append_printf(buf
, "\nERROR status: ");
558 g_string_append_printf(buf
, "%ld", code
);
562 gchar
* etag
= get_etag_header(buffers
->headers
->memory
);
564 VCard_set_etag(vcard
, etag
);
568 * Server did not respond a successful 201 with
569 * a the objects ETag. rfc6352 (6.3.2.3) only say
570 * SHOULD so make a request to the server for the
573 GSList
* uid
= VCard_get_property(vcard
, "UID");
574 prop
= (VCardProperty
*) uid
->data
;
575 etag
= curl_get_etag(dav
, prop
->value
, buf
);
576 vcard_slist_property_free(uid
);
579 buf
= g_string_assign(buf
, "Session result");
580 if (buffers
->data
->size
> 0) {
581 g_string_append_printf(buf
, "\nData\n");
582 g_string_append_printf(buf
, buffers
->data
->memory
);
584 if (buffers
->headers
->size
> 0) {
585 g_string_append_printf(buf
, "\nHeaders\n");
586 g_string_append_printf(buf
, buffers
->headers
->memory
);
591 VCard_set_etag(vcard
, etag
);
597 curl_easy_cleanup(curl
);
599 curl_slist_free_all(list
);
603 buffers_free(buffers
);
609 * PUT /calendars/johndoe/home/132456762153245.ics HTTP/1.1
610 * Content-Type: text/calendar; charset=utf-8
611 * If-Match: "2134-314" (ETag)
613 * HTTP/1.1 204 No Content
617 gboolean
curl_update_object(CarddavData
* dav
, VCard
* vcard
, GString
* buf
) {
618 gboolean res
= FALSE
;
620 CURLcode curlres
= 0;
621 Buffers
* buffers
= buffers_new();
622 struct curl_slist
*list
= NULL
;
625 GSList
* uid
= VCard_get_property(vcard
, "UID");
628 buf
= g_string_assign(buf
, "VCard missing UID");
631 VCardProperty
* prop
= (VCardProperty
*) uid
->data
;
632 gchar
* extra_url
= g_strconcat(prop
->value
, ".vcf", NULL
);
633 vcard_slist_property_free(uid
);
634 CURL
* curl
= prepare_curl(dav
, buffers
, PUT
, extra_url
);
637 etag
= VCard_get_etag(vcard
);
639 gchar
* match
= g_strconcat("If-Match: \"", etag
, "\"", NULL
);
641 list
= curl_slist_append(list
, match
);
642 list
= curl_slist_append(list
, "Content-Type: text/vcard");
643 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
644 gchar
* card
= VCard_get_as_string(vcard
);
645 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, card
);
646 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
647 curlres
= curl_easy_perform(curl
);
650 buf
= g_string_assign(buf
, buffers
->error_buf
);
656 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
659 buf
= g_string_assign(buf
, buffers
->data
->memory
);
660 g_string_append_printf(buf
, "\nERROR status: ");
661 g_string_append_printf(buf
, "%ld", code
);
665 gchar
* etag
= get_etag_header(buffers
->headers
->memory
);
667 VCard_set_etag(vcard
, etag
);
671 * Server did not respond a successful 201 with
672 * a the objects ETag. rfc6352 (6.3.2.3) only say
673 * SHOULD so make a request to the server for the
676 GSList
* uid
= VCard_get_property(vcard
, "UID");
677 prop
= (VCardProperty
*) uid
->data
;
678 etag
= curl_get_etag(dav
, prop
->value
, buf
);
679 vcard_slist_property_free(uid
);
682 buf
= g_string_assign(buf
, "Session result");
683 if (buffers
->data
->size
> 0) {
684 g_string_append_printf(buf
, "\nData\n");
685 g_string_append_printf(buf
, buffers
->data
->memory
);
687 if (buffers
->headers
->size
> 0) {
688 g_string_append_printf(buf
, "\nHeaders\n");
689 g_string_append_printf(buf
, buffers
->headers
->memory
);
694 VCard_set_etag(vcard
, etag
);
701 curl_slist_free_all(list
);
706 buf
= g_string_assign(buf
, "ERROR: Missing ETag");
710 curl_easy_cleanup(curl
);
714 buffers_free(buffers
);
720 * DELETE /calendars/johndoe/home/132456762153245.ics HTTP/1.1
721 * If-Match: "2134-314" (ETag)
723 * HTTP/1.1 204 No Content
725 gboolean
curl_delete_object(CarddavData
* dav
, VCard
* vcard
, GString
* buf
) {
726 gboolean res
= FALSE
;
728 CURLcode curlres
= 0;
729 Buffers
* buffers
= buffers_new();
730 struct curl_slist
*list
= NULL
;
733 GSList
* uid
= VCard_get_property(vcard
, "UID");
736 buf
= g_string_assign(buf
, "VCard missing UID");
739 VCardProperty
* prop
= (VCardProperty
*) uid
->data
;
740 gchar
* extra_url
= g_strconcat(prop
->value
, ".vcf", NULL
);
741 vcard_slist_property_free(uid
);
742 CURL
* curl
= prepare_curl(dav
, buffers
, DELETE
, extra_url
);
745 etag
= VCard_get_etag(vcard
);
747 gchar
* match
= g_strconcat("If-Match: \"", etag
, "\"", NULL
);
749 list
= curl_slist_append(list
, match
);
750 //list = curl_slist_append(list, "Content-Type: text/vcard");
751 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
752 curlres
= curl_easy_perform(curl
);
755 buf
= g_string_assign(buf
, buffers
->error_buf
);
761 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
764 buf
= g_string_assign(buf
, buffers
->data
->memory
);
765 g_string_append_printf(buf
, "\nERROR status: ");
766 g_string_append_printf(buf
, "%ld", code
);
770 buf
= g_string_assign(buf
, "Deleted: ");
771 g_string_append_printf(buf
, "%ld", code
);
775 curl_slist_free_all(list
);
779 buf
= g_string_assign(buf
, "ERROR: Missing ETag");
783 curl_easy_cleanup(curl
);
787 buffers_free(buffers
);
792 gboolean
curl_get_options(CarddavData
* dav
, GString
* buf
) {
793 gboolean res
= FALSE
;
794 CURLcode curlres
= 0;
795 Buffers
* buffers
= buffers_new();
797 CURL
* curl
= prepare_curl(dav
, buffers
, OPTIONS
, NULL
);
799 curlres
= curl_easy_perform(curl
);
802 buf
= g_string_assign(buf
, buffers
->error_buf
);
808 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
813 res
= !has_support(dav
, buffers
->headers
->memory
);
814 GString
* displayname
= g_string_new(NULL
);
815 if (!curl_get_displayname(dav
, displayname
))
816 dav
->displayname
= g_string_free_and_steal(displayname
);
818 g_string_free(displayname
, TRUE
);
821 curl_easy_cleanup(curl
);
825 buffers_free(buffers
);
830 gboolean
curl_get_displayname(CarddavData
* dav
, GString
* buf
) {
831 gboolean res
= FALSE
;
832 CURLcode curlres
= 0;
833 Buffers
* buffers
= buffers_new();
835 if (!buf
) return TRUE
;
837 CURL
* curl
= prepare_curl(dav
, buffers
, PROPFIND
, NULL
);
839 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, prop_request
);
840 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
841 curlres
= curl_easy_perform(curl
);
843 buf
= g_string_assign(buf
, buffers
->error_buf
);
848 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
853 gchar
* displayname
= find_text(buffers
->data
->memory
, "<displayname>", "</displayname>");
855 buf
= g_string_assign(buf
, displayname
);
860 curl_easy_cleanup(curl
);
865 buffers_free(buffers
);
870 gboolean
curl_collection_dirty(CarddavData
* dav
) {
871 gboolean dirty
= TRUE
;
872 Buffers
* buffers
= buffers_new();
873 CURLcode curlres
= 0;
874 struct curl_slist
*list
= NULL
;
876 CURL
* curl
= prepare_curl(dav
, buffers
, REPORT
, NULL
);
878 list
= curl_slist_append(list
, "Depth: 1");
879 list
= curl_slist_append(list
, "Content-Type: text/xml; charset=\"utf-8\"");
880 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
881 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, changed_request
);
882 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
883 curlres
= curl_easy_perform(curl
);
889 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
894 gchar
* etag
= get_etag(buffers
->data
->memory
);
896 if (g_strcmp0(etag
, dav
->etag
) == 0) {
900 dav
->etag
= g_strdup(etag
);
909 curl_easy_cleanup(curl
);
910 curl_slist_free_all(list
);
913 buffers_free(buffers
);
918 gboolean
curl_get_objects(CarddavData
* dav
, GString
* buf
) {
919 gboolean res
= FALSE
;
920 Buffers
* buffers
= buffers_new();
921 CURLcode curlres
= 0;
922 struct curl_slist
*list
= NULL
;
924 CURL
* curl
= prepare_curl(dav
, buffers
, REPORT
, NULL
);
926 list
= curl_slist_append(list
, "Depth: 1");
927 list
= curl_slist_append(list
, "Content-Type: text/xml; charset=\"utf-8\"");
928 curl_easy_setopt(curl
, CURLOPT_HTTPHEADER
, list
);
929 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, data_request
);
930 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
931 curlres
= curl_easy_perform(curl
);
933 buf
= g_string_assign(buf
, buffers
->error_buf
);
938 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
940 buf
= g_string_assign(buf
, "ERROR status: ");
941 g_string_append_printf(buf
, "%ld", code
);
945 buf
= g_string_assign(buf
, buffers
->data
->memory
);
948 curl_easy_cleanup(curl
);
949 curl_slist_free_all(list
);
952 buffers_free(buffers
);
957 gboolean
curl_get_resource_type(CarddavData
* dav
) {
958 Buffers
* buffers
= buffers_new();
959 gboolean res
= FALSE
;
960 CURLcode curlres
= 0;
961 GPtrArray
* types
= g_ptr_array_new_null_terminated(1, (GDestroyNotify
)g_free
, TRUE
);
963 CURL
* curl
= prepare_curl(dav
, buffers
, PROPFIND
, NULL
);
965 curl_easy_setopt(curl
, CURLOPT_POSTFIELDS
, prop_request
);
966 curl_easy_setopt(curl
, CURLOPT_POSTFIELDSIZE
, -1L);
967 curlres
= curl_easy_perform(curl
);
969 g_ptr_array_add(types
, g_strdup(buffers
->error_buf
));
974 curlres
= curl_easy_getinfo(curl
, CURLINFO_RESPONSE_CODE
, &code
);
979 gchar
* resourcetype
= find_text(buffers
->data
->memory
, "<resourcetype>", "</resourcetype>");
981 gchar
* tmp
= g_strdup(resourcetype
);
982 g_free(resourcetype
);
983 resourcetype
= find_text(tmp
, "<", "/>");
984 gchar
* s
= remove_ns(resourcetype
);
985 g_free(resourcetype
);
987 g_ptr_array_add(types
, g_strdup(s
));
989 resourcetype
= find_text(tmp
, "><", "/>");
990 gchar
* s
= remove_ns(resourcetype
);
991 g_ptr_array_add(types
, g_strdup(s
));
992 g_free(resourcetype
);
999 curl_easy_cleanup(curl
);
1002 if (types
->len
> 0) {
1003 gboolean authorized
= FALSE
;
1004 gpointer
* types_str
= g_ptr_array_free(types
, FALSE
);
1005 gchar
** start
= (gchar
**)types_str
;
1006 while (*types_str
) {
1007 CollectionType type
= get_collection_type(*types_str
);
1020 if (authorized
== FALSE
)
1021 dav
->type
= UNKNOWN
;
1025 buffers_free(buffers
);
1030 CarddavData
* curl_carddavdata_new() {
1031 return g_new0(CarddavData
, 1);
1034 void curl_carddavdata_free(CarddavData
* dav
) {
1036 g_free(dav
->displayname
);
1045 const gchar
* get_resource_type_name(CollectionType type
) {
1046 if (type
< TYPE_SIZE
)
1047 return CollectionType_string
[type
];