]> git.datanom.net - vcard-parser.git/blob - src/curl/curllib.c
All features added
[vcard-parser.git] / src / curl / curllib.c
1 /*
2 * curllib.c
3 *
4 * Copyright 2016 Michael Rasmussen <mir@datanom.net>
5 *
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.
10 *
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.
15 *
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,
19 * MA 02110-1301, USA.
20 */
21
22 #include <string.h>
23 #include <stdlib.h>
24 #include <curl/curl.h>
25 #include <curl/easy.h>
26 #include "globals.h"
27 #include "curllib.h"
28 #include "vcard.h"
29
30 const char* const CollectionType_string[] = {"unknown", "principal","calendar","addressbook"};
31
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\">" \
35 "<D:prop>" \
36 "<D:getetag/>" \
37 "</D:prop>" \
38 "<C:filter test=\"anyof\">" \
39 "<C:prop-filter name=\"UID\">" \
40 "<C:text-match collation=\"i;unicode-casemap\" " \
41 "match-type=\"contains\">"
42
43 #define etag_request_back "</C:text-match>" \
44 "</C:prop-filter>" \
45 "</C:filter>" \
46 "</C:addressbook-query>"
47
48 #define prop_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
49 "<d:propfind xmlns:d=\"DAV:\">" \
50 "<d:prop>" \
51 "<d:displayname/>" \
52 "<d:current-user-privilege-set/>" \
53 "<d:resourcetype/>" \
54 "<d:getetag/>" \
55 "<d:getlastmodified/>" \
56 "<d:getcontenttype/>" \
57 "</d:prop>" \
58 "</d:propfind>"
59
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\">" \
63 "<d:prop>" \
64 "<d:getetag />" \
65 "</d:prop>" \
66 "</card:addressbook-query>"
67
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\">" \
71 "<d:prop>" \
72 "<d:getetag />" \
73 "<card:address-data />" \
74 "</d:prop>" \
75 "</card:addressbook-query>"
76
77 typedef enum {
78 PROPFIND,
79 OPTIONS,
80 REPORT,
81 PUT,
82 DELETE
83 } Request;
84
85 typedef struct {
86 char * memory;
87 size_t size;
88 } MemoryStruct;
89
90 typedef struct {
91 char trace_ascii; /* 1 or 0 */
92 } Data;
93
94 typedef struct {
95 MemoryStruct* headers;
96 MemoryStruct* data;
97 char error_buf[CURL_ERROR_SIZE];
98 } Buffers;
99
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;
106
107 return buffers;
108 }
109
110 static void buffers_free(Buffers* buffers) {
111 if (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);
118 g_free(buffers);
119 }
120 }
121
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 : "",
127 buffers->error_buf);
128 }
129
130 /**
131 * This function is burrowed from the libcurl documentation
132 * @param text
133 * @param stream
134 * @param ptr
135 * @param size
136 * @param nohex
137 */
138 static void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex) {
139 size_t i;
140 size_t c;
141
142 unsigned int width=0x10;
143
144 if(nohex)
145 /* without the hex output, we can fit more on screen */
146 width = 0x40;
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);
150 if(!nohex) {
151 /* hex not disabled, show it */
152 for(c = 0; c < width; c++) {
153 if(i+c < size)
154 fprintf(stream, "%02x ", ptr[i+c]);
155 else
156 fputs(" ", stream);
157 }
158 }
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) {
162 i+=(c+2-width);
163 break;
164 }
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) {
168 i+=(c+3-width);
169 break;
170 }
171 }
172 fputc('\n', stream); /* newline */
173 }
174 fflush(stream);
175 }
176
177 /**
178 * This function is burrowed from the libcurl documentation
179 * @param handle
180 * @param type
181 * @param data
182 * @param size
183 * @param userp
184 * @return
185 */
186 static int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp) {
187 Data* config = (Data *)userp;
188 const char* text;
189 (void)handle; /* prevent compiler warning */
190
191 switch (type) {
192 case CURLINFO_TEXT:
193 fprintf(stderr, "== Info: %s", data);
194 default: /* in case a new one is introduced to shock us */
195 return 0;
196 case CURLINFO_HEADER_OUT:
197 text = "=> Send header";
198 break;
199 case CURLINFO_DATA_OUT:
200 text = "=> Send data";
201 break;
202 case CURLINFO_SSL_DATA_OUT:
203 text = "=> Send SSL data";
204 break;
205 case CURLINFO_HEADER_IN:
206 text = "<= Recv header";
207 break;
208 case CURLINFO_DATA_IN:
209 text = "<= Recv data";
210 break;
211 case CURLINFO_SSL_DATA_IN:
212 text = "<= Recv SSL data";
213 break;
214 }
215 dump(text, stderr, data, size, config->trace_ascii);
216 return 0;
217 }
218
219 /**
220 * This function is burrowed from the libcurl documentation
221 * @param ptr
222 * @param size
223 * @return void* to memory region
224 */
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
228 * */
229 if(ptr)
230 return realloc(ptr, size);
231 else
232 return malloc(size);
233 }
234
235 /**
236 * This function is burrowed from the libcurl documentation
237 * @param ptr
238 * @param size
239 * @param nmemb
240 * @param data
241 * @return number of written bytes
242 */
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);
247
248 if (mem->memory) {
249 memcpy(&(mem->memory[mem->size]), ptr, realsize);
250 mem->size += realsize;
251 mem->memory[mem->size] = 0;
252 }
253 return realsize;
254 }
255
256 static CURL* get_curl(CarddavData* data, const gchar* extra_url) {
257 CURL* curl;
258 gchar* userpwd;
259 Data config;
260 gchar* url;
261
262 curl = curl_easy_init();
263 if (curl) {
264 if (data->pwd) {
265 userpwd = g_strconcat(data->user, ":", data->pwd, NULL);
266 curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
267 } else {
268 userpwd = g_strconcat(data->user, NULL);
269 curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
270 }
271 g_free(userpwd);
272 curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
273 curl_easy_setopt(curl, CURLOPT_USERAGENT, "carddavParser");
274
275 if (extra_url)
276 url = g_strconcat(data->url, "/", extra_url, NULL);
277 else
278 url = g_strconcat(data->url, NULL);
279 curl_easy_setopt(curl, CURLOPT_URL, url);
280 g_free(url);
281
282 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
283 curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteMemoryCallback);
284 if (data->debug) {
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);
289 }
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);
293 }
294
295 return curl;
296 }
297
298 static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type, const gchar* extra_url) {
299 CURL* curl = get_curl(dav, extra_url);
300 if (curl) {
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);
304 switch (type) {
305 case OPTIONS:
306 curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "OPTIONS");
307 break;
308 case PROPFIND:
309 curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PROPFIND");
310 break;
311 case REPORT:
312 curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
313 break;
314 case PUT:
315 curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
316 break;
317 case DELETE:
318 curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
319 break;
320 }
321 }
322
323 return curl;
324 }
325
326 static gboolean has_support(CarddavData* dav, const gchar* headers) {
327 gboolean support = FALSE;
328
329 //g_print("%s\n", headers);
330 gchar* start = g_strstr_len(headers, -1, "DAV");
331 if (start) {
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;
337 while (*tmp) {
338 gchar *opt, *option;
339 gchar* end = g_strstr_len(*tmp, -1, "\r");
340 if (end) {
341 gchar* str = g_strndup(*tmp, end - *tmp);
342 opt = g_ascii_strup(str, -1);
343 g_free(str);
344 option = g_strstrip(opt);
345 } else {
346 opt = g_ascii_strup(*tmp, -1);
347 option = g_strstrip(opt);
348 }
349 if (g_strcmp0(option, "ADDRESSBOOK") == 0)
350 support = TRUE;
351 if (g_strcmp0(option, "EXTENDED-MKCOL") == 0)
352 dav->mkcol = TRUE;
353 g_free(opt);
354 tmp++;
355 }
356 }
357 g_strfreev(options);
358 }
359 g_strfreev(values);
360 }
361
362 return support;
363 }
364
365 static gchar* find_text(const gchar* string, const gchar* start, const gchar* end) {
366 gchar* text = NULL;
367
368 if (start && end) {
369 gchar* s_start = g_strstr_len(string, -1, start);
370 if (s_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)));
374 }
375 }
376 }
377
378 return text;
379 }
380
381 static gchar* remove_ns(const gchar* s) {
382 gchar* s1 = NULL;
383
384 if (s) {
385 gchar* s_start = g_strstr_len(s, -1, ":");
386 if (s_start) {
387 s1 = g_strndup(s_start + 1, strlen(s_start + 1));
388 } else {
389 s1 = g_strdup(s);
390 }
391 g_strstrip(s1);
392 }
393
394 return s1;
395 }
396
397 static gchar* remove_start_end(const gchar* s, const gchar* begin, const gchar* end) {
398 gchar* s1 = NULL;
399
400 if (s) {
401 gchar* s_start = g_strstr_len(s, -1, begin);
402 if (s_start) {
403 gchar* s_end = g_strstr_len(s_start + 1, -1, end);
404 if (s_end)
405 s1 = g_strndup(s_start + strlen(begin), s_end - (s_start + strlen(begin)));
406 }
407 g_strstrip(s1);
408 }
409
410 return s1;
411 }
412
413
414 static CollectionType get_collection_type(const gchar* s) {
415 CollectionType type = UNKNOWN;
416 int len = sizeof(CollectionType_string)/sizeof(CollectionType_string[0]);
417
418 if (s) {
419 for (int i = 0; i < len; ++i) {
420 if (g_strcmp0(CollectionType_string[i], s) == 0) {
421 type = i;
422 break;
423 }
424 }
425 }
426
427 return type;
428 }
429
430
431 static gchar* get_etag(const gchar* string) {
432 gchar* etag= NULL;
433
434 etag = find_text(string, "<getetag>", "</getetag>");
435
436 return etag;
437 }
438
439 static gchar* get_etag_ns(const gchar* string, const gchar* ns) {
440 gchar* etag= NULL;
441
442 if (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);
446 g_free(etag_begin);
447 g_free(etag_end);
448 } else {
449 etag = find_text(string, "<getetag>", "</getetag>");
450 }
451
452 return etag;
453 }
454
455 static gchar* get_etag_header(const gchar* headers) {
456 gchar* etag = NULL;
457 int j = 0;
458
459 gchar* raw = find_text(headers, "ETag:", "\n");
460 if (raw) {
461 etag = g_strdup(raw);
462 for (int i = 0; i < strlen(raw); i++) {
463 int l = raw[i] - 32;
464 if (l != 2 && l != 60 && raw[i] != '\r') {
465 etag[j] = raw[i];
466 j++;
467 }
468 }
469 etag[j] = 0;
470 g_strstrip(etag);
471
472 g_free(raw);
473 }
474
475 return etag;
476 }
477
478 gchar* curl_get_etag(CarddavData* dav, const gchar* uid, GString* buf) {
479 gchar* etag = NULL;
480 Buffers* buffers = buffers_new();
481 CURLcode curlres = 0;
482 struct curl_slist *list = NULL;
483
484 if (uid) {
485 CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
486 if (curl) {
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);
494 g_free(request);
495 if (curlres == 0) {
496 long code;
497 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
498 if (code == 207) {
499 etag = get_etag_ns(buffers->data->memory, "d");
500 gchar* clean = remove_start_end(etag, "&quot;", "&quot;");
501 if (clean) {
502 g_free(etag);
503 etag = clean;
504 }
505 }
506 }
507 curl_easy_cleanup(curl);
508 curl_slist_free_all(list);
509 }
510 } else {
511 if (buf)
512 buf = g_string_assign(buf, "Missing UID");
513 }
514
515 buffers_free(buffers);
516
517 return etag;
518 }
519
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;
525
526 GSList* uid = VCard_get_property(vcard, "UID");
527 if (uid == NULL) {
528 if (buf)
529 buf = g_string_assign(buf, "VCard missing UID");
530 return TRUE;
531 }
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);
536 g_free(extra_url);
537 if (curl) {
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);
545 if (curlres != 0) {
546 if (buf) {
547 buf = g_string_assign(buf, buffers->error_buf);
548 }
549 res = TRUE;
550 }
551 else {
552 long code;
553 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
554 if (code != 201) {
555 if (buf) {
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);
559 }
560 res = TRUE;
561 } else {
562 gchar* etag = get_etag_header(buffers->headers->memory);
563 if (etag) {
564 VCard_set_etag(vcard, etag);
565 g_free(etag);
566 } else {
567 /*
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
571 * objects ETag
572 */
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);
577 if (etag == NULL) {
578 if (buf) {
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);
583 }
584 if (buffers->headers->size > 0) {
585 g_string_append_printf(buf, "\nHeaders\n");
586 g_string_append_printf(buf, buffers->headers->memory);
587 }
588 }
589 res = TRUE;
590 } else {
591 VCard_set_etag(vcard, etag);
592 g_free(etag);
593 }
594 }
595 }
596 }
597 curl_easy_cleanup(curl);
598 g_free(card);
599 curl_slist_free_all(list);
600 } else {
601 res = TRUE;
602 }
603 buffers_free(buffers);
604
605 return res;
606 }
607
608 /*
609 * PUT /calendars/johndoe/home/132456762153245.ics HTTP/1.1
610 * Content-Type: text/calendar; charset=utf-8
611 * If-Match: "2134-314" (ETag)
612 *
613 * HTTP/1.1 204 No Content
614 * ETag: "2134-315"
615 */
616
617 gboolean curl_update_object(CarddavData* dav, VCard* vcard, GString* buf) {
618 gboolean res = FALSE;
619
620 CURLcode curlres = 0;
621 Buffers* buffers = buffers_new();
622 struct curl_slist *list = NULL;
623 gchar* etag = NULL;
624
625 GSList* uid = VCard_get_property(vcard, "UID");
626 if (uid == NULL) {
627 if (buf)
628 buf = g_string_assign(buf, "VCard missing UID");
629 return TRUE;
630 }
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);
635 g_free(extra_url);
636 if (curl) {
637 etag = VCard_get_etag(vcard);
638 if (etag) {
639 gchar* match = g_strconcat("If-Match: \"", etag, "\"", NULL);
640 g_free(etag);
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);
648 if (curlres != 0) {
649 if (buf) {
650 buf = g_string_assign(buf, buffers->error_buf);
651 }
652 res = TRUE;
653 }
654 else {
655 long code;
656 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
657 if (code != 204) {
658 if (buf) {
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);
662 }
663 res = TRUE;
664 } else {
665 gchar* etag = get_etag_header(buffers->headers->memory);
666 if (etag) {
667 VCard_set_etag(vcard, etag);
668 g_free(etag);
669 } else {
670 /*
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
674 * objects ETag
675 */
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);
680 if (etag == NULL) {
681 if (buf) {
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);
686 }
687 if (buffers->headers->size > 0) {
688 g_string_append_printf(buf, "\nHeaders\n");
689 g_string_append_printf(buf, buffers->headers->memory);
690 }
691 }
692 res = TRUE;
693 } else {
694 VCard_set_etag(vcard, etag);
695 g_free(etag);
696 }
697 }
698 }
699 }
700 print_buffers(NULL);
701 curl_slist_free_all(list);
702 g_free(card);
703 g_free(match);
704 } else {
705 if (buf) {
706 buf = g_string_assign(buf, "ERROR: Missing ETag");
707 }
708 res = TRUE;
709 }
710 curl_easy_cleanup(curl);
711 } else {
712 res = TRUE;
713 }
714 buffers_free(buffers);
715
716 return res;
717 }
718
719 /*
720 * DELETE /calendars/johndoe/home/132456762153245.ics HTTP/1.1
721 * If-Match: "2134-314" (ETag)
722 *
723 * HTTP/1.1 204 No Content
724 */
725 gboolean curl_delete_object(CarddavData* dav, VCard* vcard, GString* buf) {
726 gboolean res = FALSE;
727
728 CURLcode curlres = 0;
729 Buffers* buffers = buffers_new();
730 struct curl_slist *list = NULL;
731 gchar* etag = NULL;
732
733 GSList* uid = VCard_get_property(vcard, "UID");
734 if (uid == NULL) {
735 if (buf)
736 buf = g_string_assign(buf, "VCard missing UID");
737 return TRUE;
738 }
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);
743 g_free(extra_url);
744 if (curl) {
745 etag = VCard_get_etag(vcard);
746 if (etag) {
747 gchar* match = g_strconcat("If-Match: \"", etag, "\"", NULL);
748 g_free(etag);
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);
753 if (curlres != 0) {
754 if (buf) {
755 buf = g_string_assign(buf, buffers->error_buf);
756 }
757 res = TRUE;
758 }
759 else {
760 long code;
761 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
762 if (code != 204) {
763 if (buf) {
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);
767 }
768 res = TRUE;
769 } else {
770 buf = g_string_assign(buf, "Deleted: ");
771 g_string_append_printf(buf, "%ld", code);
772 }
773 }
774 print_buffers(NULL);
775 curl_slist_free_all(list);
776 g_free(match);
777 } else {
778 if (buf) {
779 buf = g_string_assign(buf, "ERROR: Missing ETag");
780 }
781 res = TRUE;
782 }
783 curl_easy_cleanup(curl);
784 } else {
785 res = TRUE;
786 }
787 buffers_free(buffers);
788
789 return res;
790 }
791
792 gboolean curl_get_options(CarddavData* dav, GString* buf) {
793 gboolean res = FALSE;
794 CURLcode curlres = 0;
795 Buffers* buffers = buffers_new();
796
797 CURL* curl = prepare_curl(dav, buffers, OPTIONS, NULL);
798 if (curl) {
799 curlres = curl_easy_perform(curl);
800 if (curlres != 0) {
801 if (buf) {
802 buf = g_string_assign(buf, buffers->error_buf);
803 }
804 res = TRUE;
805 }
806 else {
807 long code;
808 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
809 if (code != 200) {
810 res = TRUE;
811 }
812 else {
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);
817 else
818 g_string_free(displayname, TRUE);
819 }
820 }
821 curl_easy_cleanup(curl);
822 } else {
823 res = TRUE;
824 }
825 buffers_free(buffers);
826
827 return res;
828 }
829
830 gboolean curl_get_displayname(CarddavData* dav, GString* buf) {
831 gboolean res = FALSE;
832 CURLcode curlres = 0;
833 Buffers* buffers = buffers_new();
834
835 if (!buf) return TRUE;
836
837 CURL* curl = prepare_curl(dav, buffers, PROPFIND, NULL);
838 if (curl) {
839 curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_request);
840 curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
841 curlres = curl_easy_perform(curl);
842 if (curlres != 0) {
843 buf = g_string_assign(buf, buffers->error_buf);
844 res = TRUE;
845 }
846 else {
847 long code;
848 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
849 if (code != 207) {
850 res = TRUE;
851 }
852 else {
853 gchar* displayname = find_text(buffers->data->memory, "<displayname>", "</displayname>");
854 if (displayname) {
855 buf = g_string_assign(buf, displayname);
856 g_free(displayname);
857 }
858 }
859 }
860 curl_easy_cleanup(curl);
861 } else {
862 res = TRUE;
863 }
864
865 buffers_free(buffers);
866
867 return res;
868 }
869
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;
875
876 CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
877 if (curl) {
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);
884 if (curlres != 0) {
885 dirty = TRUE;
886 }
887 else {
888 long code;
889 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
890 if (code != 207) {
891 dirty = TRUE;
892 }
893 else {
894 gchar* etag = get_etag(buffers->data->memory);
895 if (etag) {
896 if (g_strcmp0(etag, dav->etag) == 0) {
897 dirty = FALSE;
898 } else {
899 g_free(dav->etag);
900 dav->etag = g_strdup(etag);
901 dirty = TRUE;
902 }
903 } else {
904 dirty = TRUE;
905 }
906 g_free(etag);
907 }
908 }
909 curl_easy_cleanup(curl);
910 curl_slist_free_all(list);
911 }
912
913 buffers_free(buffers);
914
915 return dirty;
916 }
917
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;
923
924 CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
925 if (curl) {
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);
932 if (curlres != 0) {
933 buf = g_string_assign(buf, buffers->error_buf);
934 res = TRUE;
935 }
936 else {
937 long code;
938 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
939 if (code != 207) {
940 buf = g_string_assign(buf, "ERROR status: ");
941 g_string_append_printf(buf, "%ld", code);
942 res = TRUE;
943 }
944 else {
945 buf = g_string_assign(buf, buffers->data->memory);
946 }
947 }
948 curl_easy_cleanup(curl);
949 curl_slist_free_all(list);
950 }
951
952 buffers_free(buffers);
953
954 return res;
955 }
956
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);
962
963 CURL* curl = prepare_curl(dav, buffers, PROPFIND, NULL);
964 if (curl) {
965 curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_request);
966 curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
967 curlres = curl_easy_perform(curl);
968 if (curlres != 0) {
969 g_ptr_array_add(types, g_strdup(buffers->error_buf));
970 res = TRUE;
971 }
972 else {
973 long code;
974 curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
975 if (code != 207) {
976 res = TRUE;
977 }
978 else {
979 gchar* resourcetype = find_text(buffers->data->memory, "<resourcetype>", "</resourcetype>");
980 if (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);
986 if (s) {
987 g_ptr_array_add(types, g_strdup(s));
988 g_free(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);
993 g_free(s);
994 }
995 g_free(tmp);
996 }
997 }
998 }
999 curl_easy_cleanup(curl);
1000 }
1001
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);
1008 switch (type) {
1009 case PRINCIPAL:
1010 case CALENDAR:
1011 case ADDRESSBOOK:
1012 dav->type = type;
1013 authorized = TRUE;
1014 break;
1015 default:
1016 break;
1017 }
1018 types_str++;
1019 }
1020 if (authorized == FALSE)
1021 dav->type = UNKNOWN;
1022 g_strfreev(start);
1023 }
1024
1025 buffers_free(buffers);
1026
1027 return res;
1028 }
1029
1030 CarddavData* curl_carddavdata_new() {
1031 return g_new0(CarddavData, 1);
1032 }
1033
1034 void curl_carddavdata_free(CarddavData* dav) {
1035 if (dav) {
1036 g_free(dav->displayname);
1037 g_free(dav->pwd);
1038 g_free(dav->url);
1039 g_free(dav->user);
1040 g_free(dav->etag);
1041 g_free(dav);
1042 }
1043 }
1044
1045 const gchar* get_resource_type_name(CollectionType type) {
1046 if (type < TYPE_SIZE)
1047 return CollectionType_string[type];
1048
1049 return NULL;
1050 };
This page took 1.77261 seconds and 6 git commands to generate.