]> git.datanom.net - vcard-parser.git/blobdiff - src/curl/curllib.c
All features added
[vcard-parser.git] / src / curl / curllib.c
index 6b18dd01683240354e4943b08cc0225994ee2ca4..6a0d2baae2a2b8d9655539a5cfd58265c64df3bf 100644 (file)
 #include <curl/easy.h>
 #include "globals.h"
 #include "curllib.h"
+#include "vcard.h"
 
 const char* const CollectionType_string[] = {"unknown", "principal","calendar","addressbook"};
 
+#define etag_request_head "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
+                                                 "<C:addressbook-query xmlns:D=\"DAV:\" " \
+                                                 "xmlns:C=\"urn:ietf:params:xml:ns:carddav\">" \
+                                                 "<D:prop>" \
+                                                 "<D:getetag/>" \
+                                                 "</D:prop>" \
+                                                 "<C:filter test=\"anyof\">" \
+                                                 "<C:prop-filter name=\"UID\">" \
+                                                 "<C:text-match collation=\"i;unicode-casemap\" " \
+                                                 "match-type=\"contains\">"
+
+#define etag_request_back "</C:text-match>" \
+                                                 "</C:prop-filter>" \
+                                                 "</C:filter>" \
+                                                 "</C:addressbook-query>"
+
 #define prop_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
-                                        "<A:propfind xmlns:A=\"DAV:\">" \
-                                        "<A:prop>" \
-                                        "<A:displayname/>" \
-                                        "<A:current-user-privilege-set/>" \
-                                        "<A:resourcetype/>" \
-                                        "<A:getetag/>" \
-                                        "<A:getlastmodified/>" \
-                                        "<A:getcontenttype/>" \
-                                        "</A:prop>" \
-                                        "</A:propfind>"
+                                        "<d:propfind xmlns:d=\"DAV:\">" \
+                                        "<d:prop>" \
+                                        "<d:displayname/>" \
+                                        "<d:current-user-privilege-set/>" \
+                                        "<d:resourcetype/>" \
+                                        "<d:getetag/>" \
+                                        "<d:getlastmodified/>" \
+                                        "<d:getcontenttype/>" \
+                                        "</d:prop>" \
+                                        "</d:propfind>"
+
+#define changed_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
+                                               "<card:addressbook-query xmlns:d=\"DAV:\" " \
+                                               "xmlns:card=\"urn:ietf:params:xml:ns:carddav\">" \
+                                               "<d:prop>" \
+                                               "<d:getetag />" \
+                                               "</d:prop>" \
+                                               "</card:addressbook-query>"
+
+#define data_request "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" \
+                                        "<card:addressbook-query xmlns:d=\"DAV:\" " \
+                                        "xmlns:card=\"urn:ietf:params:xml:ns:carddav\">" \
+                                        "<d:prop>" \
+                                        "<d:getetag />" \
+                                        "<card:address-data />" \
+                                        "</d:prop>" \
+                                        "</card:addressbook-query>"
 
 typedef enum {
        PROPFIND,
-       OPTIONS
+       OPTIONS,
+       REPORT,
+       PUT,
+       DELETE
 } Request;
 
 typedef struct {
@@ -82,6 +119,14 @@ static void buffers_free(Buffers* buffers) {
        }
 }
 
+static void print_buffers(Buffers* buffers) {
+       if (buffers == NULL) return;
+       g_print("Headers: %s\nData: %s\nError: %s\n",
+               buffers->headers->size > 0 ? buffers->headers->memory : "",
+               buffers->data->size > 0 ? buffers->data->memory : "",
+               buffers->error_buf);
+}
+
 /**
  * This function is burrowed from the libcurl documentation
  * @param text
@@ -208,10 +253,11 @@ static size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* da
        return realsize;
 }
 
-static CURL* get_curl(CarddavData* data) {
+static CURL* get_curl(CarddavData* data, const gchar* extra_url) {
        CURL* curl;
        gchar* userpwd;
        Data config;
+       gchar* url;
 
        curl = curl_easy_init();
        if (curl) {
@@ -225,7 +271,14 @@ static CURL* get_curl(CarddavData* data) {
                g_free(userpwd);
                curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
                curl_easy_setopt(curl, CURLOPT_USERAGENT, "carddavParser");
-               curl_easy_setopt(curl, CURLOPT_URL, data->url);
+
+               if (extra_url)
+                       url = g_strconcat(data->url, "/", extra_url, NULL);
+               else
+                       url = g_strconcat(data->url, NULL);
+               curl_easy_setopt(curl, CURLOPT_URL, url);
+               g_free(url);
+
                curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
                curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteMemoryCallback);
                if (data->debug) {
@@ -242,8 +295,8 @@ static CURL* get_curl(CarddavData* data) {
        return curl;
 }
 
-static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type) {
-       CURL* curl = get_curl(dav);
+static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type, const gchar* extra_url) {
+       CURL* curl = get_curl(dav, extra_url);
        if (curl) {
                curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)buffers->data);
                curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)buffers->headers);
@@ -255,6 +308,15 @@ static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type) {
                        case PROPFIND:
                                curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PROPFIND");
                                break;
+                       case REPORT:
+                               curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
+                               break;
+                       case PUT:
+                               curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+                               break;
+                       case DELETE:
+                               curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+                               break;
                }
        }
 
@@ -264,7 +326,7 @@ static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type) {
 static gboolean has_support(CarddavData* dav, const gchar* headers) {
        gboolean support = FALSE;
 
-       g_print("%s\n", headers);
+       //g_print("%s\n", headers);
        gchar* start = g_strstr_len(headers, -1, "DAV");
        if (start) {
                gchar** values = g_strsplit(start, ":", 0);
@@ -316,9 +378,8 @@ static gchar* find_text(const gchar* string, const gchar* start, const gchar* en
        return text;
 }
 
-static gchar* remove_ns(gchar* s) {
+static gchar* remove_ns(const gchar* s) {
        gchar* s1 = NULL;
-       //gchar* tmp = NULL;
 
        if (s) {
                gchar* s_start = g_strstr_len(s, -1, ":");
@@ -328,12 +389,28 @@ static gchar* remove_ns(gchar* s) {
                        s1 = g_strdup(s);
                }
                g_strstrip(s1);
-               //g_free(tmp);
        }
 
        return s1;
 }
 
+static gchar* remove_start_end(const gchar* s, const gchar* begin, const gchar* end) {
+       gchar* s1 = NULL;
+
+       if (s) {
+               gchar* s_start = g_strstr_len(s, -1, begin);
+               if (s_start) {
+                       gchar* s_end = g_strstr_len(s_start + 1, -1, end);
+                       if (s_end)
+                               s1 = g_strndup(s_start + strlen(begin), s_end - (s_start + strlen(begin)));
+               }
+               g_strstrip(s1);
+       }
+
+       return s1;
+}
+
+
 static CollectionType get_collection_type(const gchar* s) {
        CollectionType type = UNKNOWN;
        int len = sizeof(CollectionType_string)/sizeof(CollectionType_string[0]);
@@ -350,28 +427,374 @@ static CollectionType get_collection_type(const gchar* s) {
        return type;
 }
 
-/*
-gboolean curl_get_objects(VCalData* vcal, GString* buf) {
+
+static gchar* get_etag(const gchar* string) {
+       gchar* etag= NULL;
+
+       etag = find_text(string, "<getetag>", "</getetag>");
+
+       return etag;
 }
 
-gboolean curl_set_objects(VCalData* vcal, GString* buf) {
+static gchar* get_etag_ns(const gchar* string, const gchar* ns) {
+       gchar* etag= NULL;
+
+       if (ns) {
+               gchar* etag_begin = g_strconcat("<", ns, ":", "getetag>", NULL);
+               gchar* etag_end = g_strconcat("</", ns, ":", "getetag>", NULL);
+               etag = find_text(string, etag_begin, etag_end);
+               g_free(etag_begin);
+               g_free(etag_end);
+       } else {
+               etag = find_text(string, "<getetag>", "</getetag>");
+       }
+
+       return etag;
 }
 
-gboolean curl_update_objects(VCalData* vcal, GString* buf) {
+static gchar* get_etag_header(const gchar* headers) {
+       gchar* etag = NULL;
+       int j = 0;
+
+       gchar* raw = find_text(headers, "ETag:", "\n");
+       if (raw) {
+               etag = g_strdup(raw);
+               for (int i = 0; i < strlen(raw); i++) {
+                       int l = raw[i] - 32;
+                       if (l != 2 && l != 60 && raw[i] != '\r') {
+                               etag[j] = raw[i];
+                               j++;
+                       }
+               }
+               etag[j] = 0;
+               g_strstrip(etag);
+
+               g_free(raw);
+       }
+
+       return etag;
 }
 
-gboolean curl_delete_objects(VCalData* vcal, GString* buf) {
+gchar* curl_get_etag(CarddavData* dav, const gchar* uid, GString* buf) {
+       gchar* etag = NULL;
+       Buffers* buffers = buffers_new();
+       CURLcode curlres = 0;
+       struct curl_slist *list = NULL;
+
+       if (uid) {
+               CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
+               if (curl) {
+                       list = curl_slist_append(list, "Depth: 1");
+                       list = curl_slist_append(list, "Content-Type: text/xml; charset=\"utf-8\"");
+                       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+                       gchar* request = g_strconcat(etag_request_head, uid, etag_request_back, NULL);
+                       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
+                       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+                       curlres = curl_easy_perform(curl);
+                       g_free(request);
+                       if (curlres == 0) {
+                               long code;
+                               curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                               if (code == 207) {
+                                       etag = get_etag_ns(buffers->data->memory, "d");
+                                       gchar* clean = remove_start_end(etag, "&quot;", "&quot;");
+                                       if (clean) {
+                                               g_free(etag);
+                                               etag = clean;
+                                       }
+                               }
+                       }
+                       curl_easy_cleanup(curl);
+                       curl_slist_free_all(list);
+               }
+       } else {
+               if (buf)
+                       buf = g_string_assign(buf, "Missing UID");
+       }
+
+       buffers_free(buffers);
+
+       return etag;
 }
 
-gboolean curl_get_freebusy(VCalData* vcal, GString* buf) {
+gboolean curl_set_object(CarddavData* dav, VCard* vcard, GString* buf) {
+       gboolean res = FALSE;
+       CURLcode curlres = 0;
+       Buffers* buffers = buffers_new();
+       struct curl_slist *list = NULL;
+
+       GSList* uid = VCard_get_property(vcard, "UID");
+       if (uid == NULL) {
+               if (buf)
+                       buf = g_string_assign(buf, "VCard missing UID");
+               return TRUE;
+       }
+       VCardProperty* prop = (VCardProperty*) uid->data;
+       gchar* extra_url = g_strconcat(prop->value, ".vcf", NULL);
+       vcard_slist_property_free(uid);
+       CURL* curl = prepare_curl(dav, buffers, PUT, extra_url);
+       g_free(extra_url);
+       if (curl) {
+               list = curl_slist_append(list, "If-None-Match: *");
+               list = curl_slist_append(list, "Content-Type: text/vcard");
+               curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+               gchar* card = VCard_get_as_string(vcard);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDS, card);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+               curlres = curl_easy_perform(curl);
+               if (curlres != 0) {
+                       if (buf) {
+                               buf = g_string_assign(buf, buffers->error_buf);
+                       }
+                       res = TRUE;
+               }
+               else {
+                       long code;
+                       curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                       if (code != 201) {
+                               if (buf) {
+                                       buf = g_string_assign(buf, buffers->data->memory);
+                                       g_string_append_printf(buf, "\nERROR status: ");
+                                       g_string_append_printf(buf, "%ld", code);
+                               }
+                               res = TRUE;
+                       } else {
+                               gchar* etag = get_etag_header(buffers->headers->memory);
+                               if (etag) {
+                                       VCard_set_etag(vcard, etag);
+                                       g_free(etag);
+                               } else {
+                                       /*
+                                        * Server did not respond a successful 201 with
+                                        * a the objects ETag. rfc6352 (6.3.2.3) only say
+                                        * SHOULD so make a request to the server for the
+                                        * objects ETag
+                                        */
+                                       GSList* uid = VCard_get_property(vcard, "UID");
+                                       prop = (VCardProperty*) uid->data;
+                                       etag = curl_get_etag(dav, prop->value, buf);
+                                       vcard_slist_property_free(uid);
+                                       if (etag == NULL) {
+                                               if (buf) {
+                                                       buf = g_string_assign(buf, "Session result");
+                                                       if (buffers->data->size > 0) {
+                                                               g_string_append_printf(buf, "\nData\n");
+                                                               g_string_append_printf(buf, buffers->data->memory);
+                                                       }
+                                                       if (buffers->headers->size > 0) {
+                                                               g_string_append_printf(buf, "\nHeaders\n");
+                                                               g_string_append_printf(buf, buffers->headers->memory);
+                                                       }
+                                               }
+                                               res = TRUE;
+                                       } else {
+                                               VCard_set_etag(vcard, etag);
+                                               g_free(etag);
+                                       }
+                               }
+                       }
+               }
+               curl_easy_cleanup(curl);
+               g_free(card);
+               curl_slist_free_all(list);
+       } else {
+               res = TRUE;
+       }
+       buffers_free(buffers);
+
+       return res;
 }
+
+/*
+ * PUT /calendars/johndoe/home/132456762153245.ics HTTP/1.1
+ * Content-Type: text/calendar; charset=utf-8
+ * If-Match: "2134-314" (ETag)
+ *
+ * HTTP/1.1 204 No Content
+ * ETag: "2134-315"
 */
+
+gboolean curl_update_object(CarddavData* dav, VCard* vcard, GString* buf) {
+       gboolean res = FALSE;
+
+       CURLcode curlres = 0;
+       Buffers* buffers = buffers_new();
+       struct curl_slist *list = NULL;
+       gchar* etag = NULL;
+
+       GSList* uid = VCard_get_property(vcard, "UID");
+       if (uid == NULL) {
+               if (buf)
+                       buf = g_string_assign(buf, "VCard missing UID");
+               return TRUE;
+       }
+       VCardProperty* prop = (VCardProperty*) uid->data;
+       gchar* extra_url = g_strconcat(prop->value, ".vcf", NULL);
+       vcard_slist_property_free(uid);
+       CURL* curl = prepare_curl(dav, buffers, PUT, extra_url);
+       g_free(extra_url);
+       if (curl) {
+               etag = VCard_get_etag(vcard);
+               if (etag) {
+                       gchar* match = g_strconcat("If-Match: \"", etag, "\"", NULL);
+                       g_free(etag);
+                       list = curl_slist_append(list, match);
+                       list = curl_slist_append(list, "Content-Type: text/vcard");
+                       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+                       gchar* card = VCard_get_as_string(vcard);
+                       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, card);
+                       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+                       curlres = curl_easy_perform(curl);
+                       if (curlres != 0) {
+                               if (buf) {
+                                       buf = g_string_assign(buf, buffers->error_buf);
+                               }
+                               res = TRUE;
+                       }
+                       else {
+                               long code;
+                               curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                               if (code != 204) {
+                                       if (buf) {
+                                               buf = g_string_assign(buf, buffers->data->memory);
+                                               g_string_append_printf(buf, "\nERROR status: ");
+                                               g_string_append_printf(buf, "%ld", code);
+                                       }
+                                       res = TRUE;
+                               } else {
+                                       gchar* etag = get_etag_header(buffers->headers->memory);
+                                       if (etag) {
+                                               VCard_set_etag(vcard, etag);
+                                               g_free(etag);
+                                       } else {
+                                               /*
+                                                * Server did not respond a successful 201 with
+                                                * a the objects ETag. rfc6352 (6.3.2.3) only say
+                                                * SHOULD so make a request to the server for the
+                                                * objects ETag
+                                                */
+                                               GSList* uid = VCard_get_property(vcard, "UID");
+                                               prop = (VCardProperty*) uid->data;
+                                               etag = curl_get_etag(dav, prop->value, buf);
+                                               vcard_slist_property_free(uid);
+                                               if (etag == NULL) {
+                                                       if (buf) {
+                                                               buf = g_string_assign(buf, "Session result");
+                                                               if (buffers->data->size > 0) {
+                                                                       g_string_append_printf(buf, "\nData\n");
+                                                                       g_string_append_printf(buf, buffers->data->memory);
+                                                               }
+                                                               if (buffers->headers->size > 0) {
+                                                                       g_string_append_printf(buf, "\nHeaders\n");
+                                                                       g_string_append_printf(buf, buffers->headers->memory);
+                                                               }
+                                                       }
+                                                       res = TRUE;
+                                               } else {
+                                                       VCard_set_etag(vcard, etag);
+                                                       g_free(etag);
+                                               }
+                                       }
+                               }
+                       }
+                       print_buffers(NULL);
+                       curl_slist_free_all(list);
+                       g_free(card);
+                       g_free(match);
+               } else {
+                       if (buf) {
+                               buf = g_string_assign(buf, "ERROR: Missing ETag");
+                       }
+                       res = TRUE;
+               }
+               curl_easy_cleanup(curl);
+       } else {
+               res = TRUE;
+       }
+       buffers_free(buffers);
+
+       return res;
+}
+
+/*
+ * DELETE /calendars/johndoe/home/132456762153245.ics HTTP/1.1
+ * If-Match: "2134-314" (ETag)
+ *
+ * HTTP/1.1 204 No Content
+*/
+gboolean curl_delete_object(CarddavData* dav, VCard* vcard, GString* buf) {
+       gboolean res = FALSE;
+
+       CURLcode curlres = 0;
+       Buffers* buffers = buffers_new();
+       struct curl_slist *list = NULL;
+       gchar* etag = NULL;
+
+       GSList* uid = VCard_get_property(vcard, "UID");
+       if (uid == NULL) {
+               if (buf)
+                       buf = g_string_assign(buf, "VCard missing UID");
+               return TRUE;
+       }
+       VCardProperty* prop = (VCardProperty*) uid->data;
+       gchar* extra_url = g_strconcat(prop->value, ".vcf", NULL);
+       vcard_slist_property_free(uid);
+       CURL* curl = prepare_curl(dav, buffers, DELETE, extra_url);
+       g_free(extra_url);
+       if (curl) {
+               etag = VCard_get_etag(vcard);
+               if (etag) {
+                       gchar* match = g_strconcat("If-Match: \"", etag, "\"", NULL);
+                       g_free(etag);
+                       list = curl_slist_append(list, match);
+                       //list = curl_slist_append(list, "Content-Type: text/vcard");
+                       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+                       curlres = curl_easy_perform(curl);
+                       if (curlres != 0) {
+                               if (buf) {
+                                       buf = g_string_assign(buf, buffers->error_buf);
+                               }
+                               res = TRUE;
+                       }
+                       else {
+                               long code;
+                               curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                               if (code != 204) {
+                                       if (buf) {
+                                               buf = g_string_assign(buf, buffers->data->memory);
+                                               g_string_append_printf(buf, "\nERROR status: ");
+                                               g_string_append_printf(buf, "%ld", code);
+                                       }
+                                       res = TRUE;
+                               } else {
+                                       buf = g_string_assign(buf, "Deleted: ");
+                                       g_string_append_printf(buf, "%ld", code);
+                               }
+                       }
+                       print_buffers(NULL);
+                       curl_slist_free_all(list);
+                       g_free(match);
+               } else {
+                       if (buf) {
+                               buf = g_string_assign(buf, "ERROR: Missing ETag");
+                       }
+                       res = TRUE;
+               }
+               curl_easy_cleanup(curl);
+       } else {
+               res = TRUE;
+       }
+       buffers_free(buffers);
+
+       return res;
+}
+
 gboolean curl_get_options(CarddavData* dav, GString* buf) {
-       gboolean res;
+       gboolean res = FALSE;
        CURLcode curlres = 0;
        Buffers* buffers = buffers_new();
 
-       CURL* curl = prepare_curl(dav, buffers, OPTIONS);
+       CURL* curl = prepare_curl(dav, buffers, OPTIONS, NULL);
        if (curl) {
                curlres = curl_easy_perform(curl);
                if (curlres != 0) {
@@ -405,13 +828,13 @@ gboolean curl_get_options(CarddavData* dav, GString* buf) {
 }
 
 gboolean curl_get_displayname(CarddavData* dav, GString* buf) {
-       gboolean res;
+       gboolean res = FALSE;
        CURLcode curlres = 0;
        Buffers* buffers = buffers_new();
 
        if (!buf) return TRUE;
 
-       CURL* curl = prepare_curl(dav, buffers, PROPFIND);
+       CURL* curl = prepare_curl(dav, buffers, PROPFIND, NULL);
        if (curl) {
                curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_request);
                curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
@@ -432,7 +855,6 @@ gboolean curl_get_displayname(CarddavData* dav, GString* buf) {
                                        buf = g_string_assign(buf, displayname);
                                        g_free(displayname);
                                }
-                               res = FALSE;
                        }
                }
                curl_easy_cleanup(curl);
@@ -445,13 +867,100 @@ gboolean curl_get_displayname(CarddavData* dav, GString* buf) {
        return res;
 }
 
+gboolean curl_collection_dirty(CarddavData* dav) {
+       gboolean dirty = TRUE;
+       Buffers* buffers = buffers_new();
+       CURLcode curlres = 0;
+       struct curl_slist *list = NULL;
+
+       CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
+       if (curl) {
+               list = curl_slist_append(list, "Depth: 1");
+               list = curl_slist_append(list, "Content-Type: text/xml; charset=\"utf-8\"");
+               curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDS, changed_request);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+               curlres = curl_easy_perform(curl);
+               if (curlres != 0) {
+                       dirty = TRUE;
+               }
+               else {
+                       long code;
+                       curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                       if (code != 207) {
+                               dirty = TRUE;
+                       }
+                       else {
+                               gchar* etag = get_etag(buffers->data->memory);
+                               if (etag) {
+                                       if (g_strcmp0(etag, dav->etag) == 0) {
+                                               dirty = FALSE;
+                                       } else {
+                                               g_free(dav->etag);
+                                               dav->etag = g_strdup(etag);
+                                               dirty = TRUE;
+                                       }
+                               } else {
+                                       dirty = TRUE;
+                               }
+                               g_free(etag);
+                       }
+               }
+               curl_easy_cleanup(curl);
+               curl_slist_free_all(list);
+       }
+
+       buffers_free(buffers);
+
+       return dirty;
+}
+
+gboolean curl_get_objects(CarddavData* dav, GString* buf) {
+       gboolean res = FALSE;
+       Buffers* buffers = buffers_new();
+       CURLcode curlres = 0;
+       struct curl_slist *list = NULL;
+
+       CURL* curl = prepare_curl(dav, buffers, REPORT, NULL);
+       if (curl) {
+               list = curl_slist_append(list, "Depth: 1");
+               list = curl_slist_append(list, "Content-Type: text/xml; charset=\"utf-8\"");
+               curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data_request);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+               curlres = curl_easy_perform(curl);
+               if (curlres != 0) {
+                       buf = g_string_assign(buf, buffers->error_buf);
+                       res = TRUE;
+               }
+               else {
+                       long code;
+                       curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+                       if (code != 207) {
+                               buf = g_string_assign(buf, "ERROR status: ");
+                               g_string_append_printf(buf, "%ld", code);
+                               res = TRUE;
+                       }
+                       else {
+                               buf = g_string_assign(buf, buffers->data->memory);
+                       }
+               }
+               curl_easy_cleanup(curl);
+               curl_slist_free_all(list);
+       }
+
+       buffers_free(buffers);
+
+       return res;
+}
+
 gboolean curl_get_resource_type(CarddavData* dav) {
        Buffers* buffers = buffers_new();
-       gboolean res = TRUE;
+       gboolean res = FALSE;
        CURLcode curlres = 0;
        GPtrArray* types = g_ptr_array_new_null_terminated(1, (GDestroyNotify)g_free, TRUE);
 
-       CURL* curl = prepare_curl(dav, buffers, PROPFIND);
+       CURL* curl = prepare_curl(dav, buffers, PROPFIND, NULL);
        if (curl) {
                curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_request);
                curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
@@ -485,7 +994,6 @@ gboolean curl_get_resource_type(CarddavData* dav) {
                                        }
                                        g_free(tmp);
                                }
-                               res = FALSE;
                        }
                }
                curl_easy_cleanup(curl);
@@ -519,12 +1027,17 @@ gboolean curl_get_resource_type(CarddavData* dav) {
        return res;
 }
 
-void curl_free_CarddavData(CarddavData* dav) {
+CarddavData* curl_carddavdata_new() {
+       return g_new0(CarddavData, 1);
+}
+
+void curl_carddavdata_free(CarddavData* dav) {
        if (dav) {
                g_free(dav->displayname);
                g_free(dav->pwd);
                g_free(dav->url);
                g_free(dav->user);
+               g_free(dav->etag);
                g_free(dav);
        }
 }
This page took 0.522904 seconds and 5 git commands to generate.