]> git.datanom.net - vcard-parser.git/commitdiff
All features added master
authorMichael Rasmussen <mir@datanom.net>
Mon, 21 Apr 2025 22:59:30 +0000 (00:59 +0200)
committerMichael Rasmussen <mir@datanom.net>
Mon, 21 Apr 2025 22:59:30 +0000 (00:59 +0200)
Signed-off-by: Michael Rasmussen <mir@datanom.net>
.gitignore
example/vcard-example.c
src/curl/curllib.c
src/curl/curllib.h
src/parser/globals.h
src/parser/vcard-parser.c
src/parser/vcard-parser.h
src/parser/vcard.c
src/parser/vcard.h

index edbfb05260a2584ff24d46f7f3aadf4aa7048860..3c013b2b532e68af57f0bef29d38c9f7167ff23b 100644 (file)
@@ -10,6 +10,7 @@
 *.ko
 *.obj
 *.elf
+.deps
 
 # Linker output
 *.ilk
index f8f1770cd42d937a53124f5ed0b3b6d89054458a..68962bacd8cb016cbf09a8ef6c80d463e4f1b492 100644 (file)
@@ -4,15 +4,30 @@
 
 #include <stdio.h>
 #include <glib.h>
+#include <glib/gstdio.h>
 #include "globals.h"
 #include "vcard.h"
 #include "curllib.h"
+#include "image.h"
+
+typedef enum {
+       GETDISPLAYNAME,
+       GETOPTIONS,
+       GETTYPE,
+       GETOBJECTS,
+       READFILE,
+       ADDOBJECT,
+       UPDATEOBJECT
+} Actions;
 
 typedef struct {
        gchar* uid;
        gchar* pwd;
        gchar* url;
        gboolean debug;
+       Actions action;
+       gchar* file;
+       gchar* vc;
 } Arguments;
 
 static void arguments_free(Arguments* a) {
@@ -20,6 +35,8 @@ static void arguments_free(Arguments* a) {
                g_free(a->pwd);
                g_free(a->uid);
                g_free(a->url);
+               g_free(a->file);
+               g_free(a->vc);
                g_free(a);
        }
 }
@@ -29,6 +46,7 @@ static Arguments* parse_commandline(GOptionContext* opt_context, gint argc, gcha
        static gchar* uid = NULL;
        static gchar* pwd = NULL;
        static gchar* url = NULL;
+       static gchar* action = NULL;
        static gboolean debug = FALSE;
        GError *error = NULL;
 
@@ -37,6 +55,8 @@ static Arguments* parse_commandline(GOptionContext* opt_context, gint argc, gcha
                { "password", 'p', 0, G_OPTION_ARG_STRING, &pwd, "Password for the account", "P"},
                { "url", 'l', 0, G_OPTION_ARG_STRING, &url, "URL to the server", "<http|https>://foo.bar[/collection]"},
                { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "Enable debug mode", NULL },
+               { "action", 'a', 0, G_OPTION_ARG_STRING, &action, "Request to make",
+                       "GetOptions, GetDisplayname, GetType, GetObjects, ReadFile, AddObject, UpdateObject"},
                { NULL }
        };
 
@@ -59,6 +79,52 @@ static Arguments* parse_commandline(GOptionContext* opt_context, gint argc, gcha
                args->uid = uid;
                args->url = url;
                args->debug = debug;
+               if (action) {
+                       if (g_ascii_strcasecmp(action, "GETDISPLAYNAME") == 0)
+                               args->action = GETDISPLAYNAME;
+                       else if (g_ascii_strcasecmp(action, "GETOPTIONS") == 0)
+                               args->action = GETOPTIONS;
+                       else if (g_ascii_strcasecmp(action, "GETTYPE") == 0)
+                               args->action = GETTYPE;
+                       else if (g_ascii_strcasecmp(action, "GETOBJECTS") == 0)
+                               args->action = GETOBJECTS;
+                       else if (g_ascii_strcasecmp(action, "READFILE") == 0)
+                               args->action = READFILE;
+                       else if (g_ascii_strcasecmp(action, "ADDOBJECT") == 0)
+                               args->action = ADDOBJECT;
+                       else if (g_ascii_strcasecmp(action, "UPDATEOBJECT") == 0)
+                               args->action = UPDATEOBJECT;
+                       else {
+                               g_printerr("%s: Unknown action\n", action);
+                               g_free(args);
+                               args = NULL;
+                               goto CLEAN;
+                       }
+                       g_free(action);
+               } else {
+                       g_printerr("Missing action\n");
+                       g_free(args);
+                       args = NULL;
+                       goto CLEAN;
+               }
+
+               if (args->action == READFILE) {
+                       for (int c = argc - 1; c > 0; c--) {
+                               g_free(args->file);
+                               args->file = g_strdup(argv[c]);
+                       }
+               }
+
+               if (args->action == ADDOBJECT || args->action == UPDATEOBJECT) {
+                       GString* vc = g_string_new(NULL);
+                       for (int c = 1; c < argc; c++) {
+                               if (c > 1)
+                                       vc = g_string_append_c(vc, ' ');
+                               vc = g_string_append(vc, g_strdup(argv[c]));
+                       }
+                       args->vc = g_string_free_and_steal(vc);
+               }
+
                goto OK;
        }
 
@@ -69,6 +135,8 @@ static Arguments* parse_commandline(GOptionContext* opt_context, gint argc, gcha
                        g_free(pwd);
                if (url)
                        g_free(url);
+               if (action)
+                       g_free(action);
 
        OK:
                return args;
@@ -118,28 +186,129 @@ int main(int argc, char *argv[]) {
                }
 */
 
-               CarddavData* data = g_new0(CarddavData, 1);
+               CarddavData* data = curl_carddavdata_new();
                data->debug = args->debug;
                data->url = g_strdup(args->url);
                data->user = g_strdup(args->uid);
                data->pwd = g_strdup(args->pwd);
                data->mkcol = FALSE;
-               arguments_free(args);
 
-               GString* buf = g_string_new(NULL);
-               if (curl_get_options(data, buf)) {
-                       g_print("ERROR\n%s\n", buf->str);
-               } else {
-                       g_print("OK\nDisplayname: %s\nMKCOL support: %s\n", data->displayname, data->mkcol ? "True" : "False");
-               }
-               g_string_free(buf, TRUE);
-               gboolean res = curl_get_resource_type(data);
-               if (res) {
-                       g_printerr("Unautorized\n");
-               } else {
-                       g_print("CollectionType: %s\n", get_resource_type_name(data->type));
+               GString* buf = NULL;
+               switch (args->action) {
+                       case GETOPTIONS:
+                               buf = g_string_new(NULL);
+                               if (curl_get_options(data, buf)) {
+                                       g_print("ERROR\n%s\n", buf->str);
+                               } else {
+                                       g_print("OK\nDisplayname: %s\nMKCOL support: %s\n", data->displayname, data->mkcol ? "True" : "False");
+                               }
+                               g_string_free(buf, TRUE);
+                               break;
+
+                       case GETDISPLAYNAME:
+                               buf = g_string_new(NULL);
+                               if (curl_get_options(data, buf)) {
+                                       g_print("ERROR\n%s\n", buf->str);
+                               } else {
+                                       g_print("OK\nDisplayname: %s\n", data->displayname);
+                               }
+                               g_string_free(buf, TRUE);
+                               break;
+
+                       case GETTYPE:
+                               gboolean res = curl_get_resource_type(data);
+                               if (res) {
+                                       g_printerr("Unautorized\n");
+                               } else {
+                                       g_print("CollectionType: %s\n", get_resource_type_name(data->type));
+                               }
+                               gboolean dirty = curl_collection_dirty(data);
+                               g_print("Etag: %s\nCollection dirty: %s\n", data->etag, dirty ? "YES" : "NO");
+                               break;
+
+                       case GETOBJECTS:
+                               buf = g_string_new(NULL);
+                               res = curl_get_objects(data, buf);
+                               g_print("Objects:\n%s\n", res ? "ERROR": buf->str);
+                               g_string_free(buf, TRUE);
+                               break;
+
+                       case READFILE:
+                               // "/home/mir/git/vcard-parser/example/mir_book.vcf"
+                               FILE* file = g_fopen(args->file, "r");
+                               if (file) {
+                                       GSList* cards = VCard_new_from_file(file, VCARD_VERSION_DETECT, TRUE);
+                                       fclose(file);
+                                       VCard_print_list(cards);
+                                       g_print("\n");
+                                       vcard_slist_property_free(cards);
+                               } else {
+                                       g_printerr("%s: Read error\n", args->file);
+                               }
+                               break;
+
+                       case ADDOBJECT:
+                               VCard* vcard = VCard_new();
+                               VCard_set_email(vcard, EMAIL_HOME, "mir@miras.org");
+                               VCard_set_email(vcard, EMAIL_WORK, "mr.it@cbs.dk");
+                               VCard_set_name(vcard, "Michael", "Rasmussen");
+                               VCard_set_company(vcard, "No Name");
+                               VCard_set_telefon(vcard, TEL_DEFAULT, "40757616");
+                               VCard_set_telefon(vcard, TEL_HOME, "40757616");
+                               VCard_set_address(vcard, ADDR_HOME, "Helmer Søgårds Alle 7, st.th", NULL, "Kastrup", "2770", "Denmark");
+                               VCard_set_photo_image(vcard, PHOTO_JPG, hacker_jpeg);
+
+                               buf = g_string_new(NULL);
+                               res = curl_set_object(data, vcard,  buf);
+                               gchar* output;
+                               if (res) {
+                                       output = g_strconcat("ERROR: ", buf->str, NULL);
+                               } else {
+                                       gchar* tmp = VCard_get_etag(vcard);
+                                       output = g_strconcat("ETag: ", tmp, "\n", NULL);
+                                       g_free(tmp);
+                               }
+                               g_print(output);
+                               g_free(output);
+                               g_string_free(buf, TRUE);
+
+                               // Update
+                               buf = g_string_new(NULL);;
+                               VCard_set_company(vcard, "Some changed Name");
+                               res = curl_update_object(data, vcard,  buf);
+                               if (res) {
+                                       output = VCard_get_etag(vcard);
+                                       g_print("Error updating (UID:%s", output);
+                                       g_free(output);
+                               } else {
+                                       gchar* tmp = VCard_get_etag(vcard);
+                                       output = g_strconcat("ETag: ", tmp, "\n", NULL);
+                                       g_free(tmp);
+                                       g_print(output);
+                                       g_free(output);
+                               }
+                               g_string_free(buf, TRUE);
+
+                               // Delete
+                               buf = g_string_new(NULL);;
+                               res = curl_delete_object(data, vcard,  buf);
+                               if (res) {
+                                       output = VCard_get_etag(vcard);
+                                       g_print("Error updating (UID:%s", output);
+                                       g_free(output);
+                               } else {
+                                       g_print(buf->str);
+                               }
+                               g_string_free(buf, TRUE);
+
+                               VCard_free(vcard);
+                               break;
+                       case UPDATEOBJECT:
+                               g_print("%s\n", args->vc);
+                               break;
                }
-               curl_free_CarddavData(data);
+               arguments_free(args);
+               curl_carddavdata_free(data);
        } else {
                gchar* help = g_option_context_get_help(opt_context, TRUE, NULL);
                g_print("%s\n", help);
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);
        }
 }
index f44f2cea1c657a0fbc10a7ea310d91f21b777abc..6eb569d76752db3e110b69a29e9345e1ec88ba45 100644 (file)
@@ -28,18 +28,19 @@ G_BEGIN_DECLS
 
 #include "globals.h"
 
-/*
-gboolean curl_get_objects(VCalData* vcal, GString* buf);
-gboolean curl_set_objects(VCalData* vcal, GString* buf);
-gboolean curl_update_objects(VCalData* vcal, GString* buf);
-gboolean curl_delete_objects(VCalData* vcal, GString* buf);
-gboolean curl_get_freebusy(VCalData* vcal, GString* buf);
-*/
+gboolean curl_set_object(CarddavData* dav, VCard* vcard, GString* buf);
+gchar* curl_get_etag(CarddavData* dav, const gchar* uid, GString* buf);
+gboolean curl_update_object(CarddavData* dav, VCard* vcard, GString* buf);
+gboolean curl_delete_object(CarddavData* dav, VCard* vcard, GString* buf);
+
 gboolean curl_get_options(CarddavData* dav, GString* buf);
 gboolean curl_get_displayname(CarddavData* dav, GString* buf);
 gboolean curl_get_resource_type(CarddavData* dav);
-void curl_free_CarddavData(CarddavData* dav);
+CarddavData* curl_carddavdata_new();
+void curl_carddavdata_free(CarddavData* dav);
 const gchar* get_resource_type_name(CollectionType type);
+gboolean curl_collection_dirty(CarddavData* dav);
+gboolean curl_get_objects(CarddavData* dav, GString* buf);
 
 G_END_DECLS
 
index eefb5aca76f22af809b67148fc82b367e8f354b7..2dc6f251562612e4a0d62e0fcf139465b4b80abb 100644 (file)
@@ -52,8 +52,42 @@ typedef struct {
        gboolean debug;
        gboolean mkcol;
        CollectionType type;
+       gchar* etag;
 } CarddavData;
 
+typedef enum {
+       TEL_DEFAULT,
+       TEL_HOME,
+       TEL_WORK,
+       TEL_MOBIL
+} TelefonType;
+
+typedef enum {
+       ADDR_DEFAULT,
+       ADDR_HOME,
+       ADDR_WORK,
+       ADDR_OTHER
+} AddressType;
+
+typedef enum {
+       PHOTO_DEFAULT,
+       PHOTO_GIF,
+       PHOTO_PNG,
+       PHOTO_JPG
+} PhotoType;
+
+typedef enum {
+       EMAIL_DEFAULT,
+       EMAIL_HOME,
+       EMAIL_WORK,
+       EMAIL_OTHER
+} EmailType;
+
+typedef struct {
+       gchar* name;
+       gchar* value;
+} VCardProperty;
+
 G_END_DECLS
 
 #endif
index 380c19e15ebbd2fd83a187dd5842dd4f185282b1..fc6f6f5cf402d042fc6baa6b8e4d0654a164cabc 100644 (file)
@@ -80,14 +80,6 @@ static gchar* Properties[VCARD_PROPERTIES+1] = {
        NULL
 };
 
-static void vcard_property_free(gpointer data) {
-       if (!data) return;
-       VCardProperty* vp = (VCardProperty*) data;
-       g_free(vp->name);
-       g_free(vp->value);
-       g_free(vp);
-}
-
 static Property get_property(const gchar* property) {
        for (Property i = N; i < VCARD_PROPERTIES; i++) {
                if (g_strcmp0(Properties[i], property) == 0) return i;
@@ -215,10 +207,27 @@ static VCardParserResponse vcard_parse(gchar** text, VCardVersion version, GHash
                        support = check_support(property, version);
                }
                if (support) {
+                       GString* val = g_string_new(NULL);
+                       if (c[1]) {
+                               val = g_string_append(val, c[1]);
+                               guint l = g_strv_length(c);
+                               if (l > 2) {
+                                       for (guint j = 2; j < l; j++) {
+                                               val = g_string_append(val, ";");
+                                               val = g_string_append(val, c[j]);
+                                       }
+                               }
+                               if (b[1]) {
+                                       val = g_string_append(val, ":");
+                                       val = g_string_append(val, b[1]);
+                               }
+                       } else {
+                               val = g_string_append(val, b[1]);
+                       }
                        GSList* value = g_hash_table_lookup(*vcard, c[0]);
-                       VCardProperty* vp = g_new(VCardProperty, 1);
-                       vp->name = g_strdup(b[0]);
-                       vp->value = g_strdup(b[1]);
+                       VCardProperty* vp = g_new0(VCardProperty, 1);
+                       vp->name = g_strdup(c[0]); //b[0]
+                       vp->value = g_string_free_and_steal(val); //b[1]
                        value = g_slist_append(value, vp);
                        g_hash_table_insert(*vcard, g_strdup(c[0]), value);
                } else {
@@ -251,29 +260,25 @@ Property vcard_max_property(VCardVersion version) {
 }
 
 void destroy_hash_table(GHashTable* ht) {
-       GHashTableIter iter;
-       gpointer key, value;
-
-       g_hash_table_iter_init (&iter, ht);
-       while (g_hash_table_iter_next(&iter, &key, &value)) {
-               if (value)
-                       g_slist_free_full((GSList *) value, vcard_property_free);
-       }
-
        g_hash_table_destroy(ht);
 }
 
-void init_g_hash_table(GHashTable** ht, VCardVersion version) {
-       if (!ht) return;
+GHashTable* init_g_hash_table(VCardVersion version) {
+       GHashTable* ht = NULL;
 
        Property property = vcard_max_property(version);
        if (property < VCARD_PROPERTIES) {
-               *ht = g_hash_table_new_full(
-                       g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL);
+
+               ht = g_hash_table_new_full(
+                       g_str_hash, g_str_equal, (GDestroyNotify) g_free,
+                       (GDestroyNotify) vcard_slist_property_free);
+
                for (Property i = N; i <= property; i++) {
-                       g_hash_table_insert(*ht, g_strdup(Properties[i]), NULL);
+                       g_hash_table_insert(ht, g_strdup(Properties[i]), NULL);
                }
        }
+
+       return ht;
 }
 
 VCardVersion str_2_vcard_version(const gchar* version) {
@@ -321,7 +326,7 @@ VCardParserResponse vcard_parse_text(const gchar* text, VCardVersion* version, G
                if (g_strcmp0(g_strchomp(buf[0]), "BEGIN:VCARD") == 0 && g_strcmp0(g_strchomp(buf[l-1]), "END:VCARD") == 0) {
                        r = has_required_version((const gchar **)buf, version);
                        if (r == VCARD_PARSER_OK) {
-                               init_g_hash_table(vcard, *version);
+                               *vcard =init_g_hash_table(*version);
                                if (vcard && *vcard) {
                                        r = vcard_parse(buf, *version, vcard);
                                } else {
index d812ab8a01c70d4e6ba8fee91dd8a678ad2f9e74..b8d30f9909aac7ddb53866a7d51cc215683e143a 100644 (file)
@@ -27,6 +27,7 @@
 G_BEGIN_DECLS
 
 #include <globals.h>
+#include <vcard.h>
 
 typedef enum {
        // vCard 2.1 properties and up
@@ -102,16 +103,11 @@ typedef enum {
        VCARD_PARSER_ERROR,
 } VCardParserResponse;
 
-typedef struct {
-       gchar* name;
-       gchar* value;
-} VCardProperty;
-
 VCardVersion str_2_vcard_version(const gchar* version);
 gchar* vcard_version_2_str(VCardVersion version);
 Property vcard_max_property(VCardVersion version);
 VCardParserResponse vcard_parse_text(const gchar* text, VCardVersion* version, GHashTable** vcard);
-void init_g_hash_table(GHashTable** ht, VCardVersion version);
+GHashTable* init_g_hash_table(VCardVersion version);
 void destroy_hash_table(GHashTable* ht);
 
 G_END_DECLS
index d7fd301f86d0142d56a28bf282f2cf2ccbf8e73f..adfe12edc3c671d7372efa821b4a9f3d4fb4529d 100644 (file)
@@ -33,6 +33,7 @@ struct _VCard {
        VCardParserResponse     state;
        VCardVersion            version;
        GHashTable*                     vcard;
+       gchar*                          etag;
 };
 
 static char *replaceWord(const char *s, const char *oldW, const char *newW) {
@@ -65,6 +66,26 @@ static char *replaceWord(const char *s, const char *oldW, const char *newW) {
     return result;
 }
 
+static gchar* make_line(const gchar* name, const gchar* value) {
+       gchar* line = NULL;
+
+       if (name != NULL) {
+               if (g_ascii_strncasecmp("TEL", name, 3) == 0) {
+                       line = g_strdup_printf("%s;%s", name, value);
+               } else if (g_ascii_strncasecmp("ADR", name, 3) == 0) {
+                       line = g_strdup_printf("%s;%s", name, value);
+               } else if (g_ascii_strncasecmp("PHOTO", name, 3) == 0) {
+                       line = g_strdup_printf("%s;%s", name, value);
+               }  else if (g_ascii_strncasecmp("EMAIL", name, 3) == 0) {
+                       line = g_strdup_printf("%s;%s", name, value);
+               } else {
+                       line = g_strdup_printf("%s:%s", name, value);
+               }
+       }
+
+       return line;
+}
+
 static void hash_table_cb(gpointer key, gpointer value, gpointer data) {
        GSList* list = (GSList*) value;
        gchar** str = (gchar**) data;
@@ -74,14 +95,16 @@ static void hash_table_cb(gpointer key, gpointer value, gpointer data) {
 
        while (list) {
                VCardProperty* vp = (VCardProperty*) list->data;
+
                gchar* s0 = replaceWord(vp->value, "\n", "\n ");
+               gchar* line = make_line(vp->name, s0);
+               g_free(s0);
                if (!*str)
-                       s = g_strconcat(vp->name, ":", s0, NULL);
+                       s = g_strdup(line);
                else {
-                       s = g_strconcat(*str, "\n", vp->name, ":", s0, NULL);
+                       s = g_strdup_printf("%s\n%s", *str, line);
                        g_free(*str);
                }
-               g_free(s0);
                *str = g_strdup(s);
                g_free(s);
                list = list->next;
@@ -114,34 +137,202 @@ static gchar** make_chunks(const gchar* text) {
        return chunks;
 }
 
-void VCard_free(VCard* object) {
-       if (object == NULL) return;
+static VCardProperty* VCardProperty_new(const gchar* key, const gchar* value) {
+                       VCardProperty* vp = g_new0(VCardProperty, 1);
+                       vp->name = g_strdup(key);
+                       vp->value = g_strdup(value);
 
-       if (object->vcard)
-               destroy_hash_table(object->vcard);
-       g_free(object);
+                       return vp;
+}
+
+static void remove_tel_prop(GSList* list, TelefonType type) {
+       VCardProperty* vp = NULL;
+       GSList* search = list;
+
+       if (search) {
+               while (search) {
+                       vp = (VCardProperty*) search->data;
+                       if (vp) {
+                               gchar* tel = (gchar*)vp->value;
+                               switch (type) {
+                                       case TEL_DEFAULT:
+                                       case TEL_MOBIL:
+                                               if (g_strstr_len(tel, -1, "TYPE=MOBIL")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case TEL_HOME:
+                                               if (g_strstr_len(tel, -1, "TYPE=HOME")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case TEL_WORK:
+                                               if (g_strstr_len(tel, -1, "TYPE=WORK")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                               }
+
+                       }
+                       search = search->next;
+               }
+       }
+}
+
+static void remove_adr_prop(GSList* list, AddressType type) {
+       VCardProperty* vp = NULL;
+       GSList* search = list;
+
+       if (search) {
+               while (search) {
+                       vp = (VCardProperty*) search->data;
+                       if (vp) {
+                               gchar* adr = (gchar*)vp->value;
+                               switch (type) {
+                                       case ADDR_DEFAULT:
+                                       case ADDR_HOME:
+                                               if (g_strstr_len(adr, -1, "TYPE=HOME")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case ADDR_WORK:
+                                               if (g_strstr_len(adr, -1, "TYPE=WORK")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case ADDR_OTHER:
+                                               if (g_strstr_len(adr, -1, "TYPE=OTHER")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                               }
+
+                       }
+                       search = search->next;
+               }
+       }
 }
 
-void VCard_list_free(GSList* list) {
+static void remove_email_prop(GSList* list, EmailType type) {
+       VCardProperty* vp = NULL;
+       GSList* search = list;
+
+       if (search) {
+               while (search) {
+                       vp = (VCardProperty*) search->data;
+                       if (vp) {
+                               gchar* email = (gchar*)vp->value;
+                               switch (type) {
+                                       case EMAIL_DEFAULT:
+                                       case EMAIL_HOME:
+                                               if (g_strstr_len(email, -1, "TYPE=HOME")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case EMAIL_WORK:
+                                               if (g_strstr_len(email, -1, "TYPE=WORK")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                                       case EMAIL_OTHER:
+                                               if (g_strstr_len(email, -1, "TYPE=OTHER")) {
+                                                       list = g_slist_remove(list, vp);
+                                                       vcard_property_free(vp);
+                                               }
+                                               break;
+                               }
+
+                       }
+                       search = search->next;
+               }
+       }
+}
+
+gchar* VCard_get_as_string(VCard* object) {
+       gchar* card = NULL;
+       if (object == NULL) return NULL;
+
+       if (object && object->vcard) {
+               gchar* version = vcard_version_2_str(object->version);
+               gchar* s = g_strdup_printf("BEGIN:VCARD\nVERSION:%s", version);
+               g_free(version);
+               g_hash_table_foreach(object->vcard, hash_table_cb, &s);
+               card = g_strdup_printf("%s\nEND:VCARD", s);
+               g_free(s);
+       }
+
+       return card;
+}
+
+void vcard_slist_property_free(gpointer data) {
+       if (data == NULL) return;
+
+       GSList* list = (GSList *) data;
+       g_slist_free_full(list, (GDestroyNotify) vcard_property_free);
+}
+
+void vcard_property_free(gpointer data) {
+       if (!data) return;
+       VCardProperty* vp = (VCardProperty*) data;
+       g_free(vp->name);
+       g_free(vp->value);
+       g_free(vp);
+}
+
+void print_slist(GSList* list) {
        GSList* tmp = list;
 
-       while(tmp) {
-               VCard* object = (VCard*) tmp->data;
-               VCard_free(object);
+       while (tmp) {
+               VCardProperty* vp = (VCardProperty*) tmp->data;
+               g_print("Name: %s\n", vp->name);
+               g_print("Value: %s\n", vp->value);
                tmp = tmp->next;
        }
+}
+
+static gpointer slist_copy_func(gconstpointer src, gpointer data) {
+       const VCardProperty* vp = (const VCardProperty*) src;
+       VCardProperty* new_vp = VCardProperty_new(vp->name, vp->value);
 
-       if(list)
-               g_slist_free(list);
+       return (gpointer) new_vp;
 }
 
-VCard* VCard_new(VCardVersion version) {
+void VCard_free(VCard* object) {
+       if (object == NULL) return;
+
+       if (object->vcard)
+               destroy_hash_table(object->vcard);
+       g_free(object->etag);
+       g_free(object);
+}
+
+VCard* VCard_version_new(VCardVersion version, gboolean init) {
        VCard* vc = g_new0(VCard, 1);
        vc->version = version;
+       if (init) {
+               vc->vcard = init_g_hash_table(vc->version);
+               gchar* uuid = g_uuid_string_random();
+               VCardProperty* prop = VCardProperty_new("UID", g_strdup(uuid));
+               g_free(uuid);
+               GSList* uid = g_slist_prepend(NULL, prop);
+               VCard_set_property(vc, "UID", uid);
+       }
 
        return vc;
 }
 
+VCard* VCard_new() {
+       return VCard_version_new(DEFAULT_VCARD_VERSION, TRUE);
+}
+
 GSList* VCard_new_from_text(const gchar* text, VCardVersion version, gboolean skip_broken) {
        GSList* list = NULL;
        VCard* vc = NULL;
@@ -150,9 +341,7 @@ GSList* VCard_new_from_text(const gchar* text, VCardVersion version, gboolean sk
 
        gchar** chunks = make_chunks(text);
        for (int i =  0; i < g_strv_length(chunks); i++) {
-               //vc = g_new0(VCard, 1);
-               //vc->version = version;
-               vc = VCard_new(version);
+               vc = VCard_version_new(version, FALSE);
 
                VCardParserResponse r = vcard_parse_text(chunks[i], &vc->version, &vc->vcard);
                if (r != VCARD_PARSER_OK && skip_broken) {
@@ -169,11 +358,25 @@ GSList* VCard_new_from_text(const gchar* text, VCardVersion version, gboolean sk
 
 GSList* VCard_new_from_file(FILE* file, VCardVersion version, gboolean skip_broken) {
        GSList* list = NULL;
-       //VCard* vc = g_new0(VCard, 1);
-
-       //vc->version = version;
-       VCard* vc = VCard_new(version);
-       list = g_slist_prepend(list, vc);
+       gchar* buf = NULL;
+       size_t n = 0;
+       int buf_size = 500;
+       GString* text = g_string_new(NULL);
+
+       if (file) {
+               buf = g_new0(gchar, buf_size);
+               while ((n = fread(buf, sizeof(char), buf_size, file)) == buf_size) {
+                       text = g_string_append_len(text, buf, buf_size);
+                       g_free(buf);
+                       buf = g_new0(gchar, buf_size);
+               }
+               if (n > 0)
+                       text = g_string_append_len(text, buf, n);
+               g_free(buf);
+               buf = g_string_free_and_steal(text);
+               list = VCard_new_from_text(buf, version, skip_broken);
+               g_free(buf);
+       }
 
        return list;
 }
@@ -249,17 +452,320 @@ gchar* VCard_get_state(VCard* object) {
 }
 
 GSList* VCard_get_property(VCard* object, const gchar* property) {
-       GSList *values = NULL, *tmp;
-       GSList *iter;
+       GSList* values = NULL;
+       GSList* tmp = NULL;
+       GSList *iter = NULL;
        VCardProperty* vp = NULL;
 
        if (object && object->vcard && property) {
                tmp = g_hash_table_lookup(object->vcard, property);
                for (iter = tmp; iter; iter = g_slist_next(iter)) {
                        vp = (VCardProperty*) iter->data;
-                       values = g_slist_prepend(values, g_strdup_printf("%s:%s", vp->name, vp->value));
+                       VCardProperty* prop = VCardProperty_new(vp->name, vp->value);
+                       values = g_slist_prepend(values, prop);
         }
        }
 
        return values;
 }
+
+void VCard_set_property(VCard* object, const gchar* property, GSList* props) {
+       GSList *values = NULL;
+
+       if (object && object->vcard && property && props) {
+               //print_slist(props);
+               values = g_hash_table_lookup(object->vcard, property);
+               if (values) {
+                       /* Remove before adding new */
+                       g_hash_table_remove(object->vcard, property);
+               }
+               g_hash_table_replace(object->vcard, g_strdup(property), props);
+       }
+}
+
+void VCard_set_etag(VCard* vcard, const gchar* etag) {
+       if (vcard == NULL) return;
+
+       if (vcard->etag)
+               g_free(vcard->etag);
+
+       vcard->etag = g_strdup(etag);
+}
+
+void VCard_set_name(VCard* vcard, const gchar* firstname, const gchar* lastname) {
+       GSList *fn_value = NULL;
+       GSList *n_value = NULL;
+
+       if (vcard == NULL) return;
+
+       if (firstname == NULL || lastname == NULL) {
+               VCard_set_property(vcard, "N", NULL);
+               VCard_set_property(vcard, "FN", NULL);
+       } else {
+               gchar* name = g_strconcat(firstname, " ", lastname, NULL);
+               VCardProperty* prop = VCardProperty_new("FN", name);
+               fn_value = g_slist_prepend(fn_value, prop);
+               VCard_set_property(vcard, "FN", fn_value);
+               g_free(name);
+               name = g_strconcat(lastname, ";", firstname, ";", NULL);
+               prop = VCardProperty_new("N", name);
+               n_value = g_slist_prepend(n_value, prop);
+               VCard_set_property(vcard, "N", n_value);
+               g_free(name);
+       }
+}
+
+void VCard_set_company(VCard* vcard, const gchar* company) {
+       GSList* org_value = NULL;
+       if (vcard == NULL) return;
+
+       if (company == NULL) {
+               VCard_set_property(vcard, "ORG", NULL);
+       }
+
+       VCardProperty* prop = VCardProperty_new("ORG", company);
+       org_value = g_slist_prepend(org_value, prop);
+       VCard_set_property(vcard, "ORG", org_value);
+}
+
+void VCard_set_telefon(VCard* vcard, TelefonType type, const gchar* number) {
+       gchar* tel = NULL;
+       GSList* values = NULL;
+       if (vcard == NULL) return;
+
+       GSList* tel_value = VCard_get_property(vcard, "TEL");
+       if (number == NULL) {
+               if (tel_value) {
+                       remove_tel_prop(tel_value, type);
+                       VCard_set_property(vcard, "TEL", tel_value);
+               }
+       } else {
+               switch (type) {
+                       case TEL_DEFAULT:
+                       case TEL_MOBIL:
+                               tel = g_strconcat("TYPE=MOBIL,VOICE:", number, NULL);
+                               break;
+                       case TEL_HOME:
+                               tel = g_strconcat("TYPE=HOME,VOICE:", number, NULL);
+                               break;
+                       case TEL_WORK:
+                               tel = g_strconcat("TYPE=WORK,VOICE:", number, NULL);
+                               break;
+               }
+               if (tel_value) {
+                       values = g_slist_copy_deep(tel_value, slist_copy_func, NULL);
+               }
+               VCardProperty* prop = VCardProperty_new("TEL", tel);
+               values = g_slist_prepend(values, prop);
+               VCard_set_property(vcard, "TEL", values);
+               g_free(tel);
+       }
+}
+
+void VCard_set_address(VCard* vcard, AddressType type, const gchar* address, const gchar* state, const gchar* city,    const gchar* zip, const gchar* country) {
+       gchar* addr = NULL;
+       GSList* values = NULL;
+       if (vcard == NULL) return;
+
+       GSList* addr_value = VCard_get_property(vcard, "ADR");
+       if (address == NULL || city == NULL || zip == NULL || country == NULL) {
+               if (addr_value) {
+                       remove_adr_prop(addr_value, type);
+                       VCard_set_property(vcard, "ADR", addr_value);
+               }
+       } else {
+               gchar* state = NULL;
+               if (state)
+                       state = g_strconcat(state, ";", NULL);
+               else
+                       state = g_strdup("");
+
+               switch (type) {
+                       case ADDR_DEFAULT:
+                       case ADDR_HOME:
+                               addr = g_strdup_printf("TYPE=HOME:;;%s;%s;%s;%s;%s;", address, city, zip, state, country);
+                               //, address, ";", city, ";", zip, ";", state, ";", country, ";" , NULL);
+                               break;
+                       case ADDR_WORK:
+                               addr = g_strconcat("TYPE=WORK:;;", address, ";", city, ";", zip, ";", state, country, ";" , NULL);
+                               break;
+                       case ADDR_OTHER:
+                               addr = g_strconcat("TYPE=OTHER:;;", address, ";", city, ";", zip, ";", state, country, ";" , NULL);
+                               break;
+               }
+               g_free(state);
+               if (addr_value) {
+                       values = g_slist_copy_deep(addr_value, slist_copy_func, NULL);
+               }
+               VCardProperty* prop = VCardProperty_new("ADR", addr);
+               values = g_slist_prepend(values, prop);
+               VCard_set_property(vcard, "ADR", values);
+               g_free(addr);
+       }
+}
+
+void VCard_set_photo_uri(VCard* vcard, PhotoType type, const gchar* uri) {
+       gchar* photo = NULL;
+       if (vcard == NULL) return;
+
+       GSList* photo_value = VCard_get_property(vcard, "PHOTO");
+       if (uri == NULL) {
+               if (photo_value) {
+                       VCard_set_property(vcard, "PHOTO", NULL);
+               }
+       } else {
+               switch (type) {
+                       case PHOTO_DEFAULT:
+                       case PHOTO_JPG:
+                               photo = g_strconcat("VALUE=URI;TYPE=", "JPG:;", uri, NULL);
+                               break;
+                       case PHOTO_GIF:
+                               photo = g_strconcat("VALUE=URI;TYPE=", "GIF:;", uri, NULL);
+                               break;
+                       case PHOTO_PNG:
+                               photo = g_strconcat("VALUE=URI;TYPE=", "PNG:;", uri, NULL);
+                               break;
+               }
+               VCardProperty* prop = VCardProperty_new("PHOTO", photo);
+               photo_value = g_slist_prepend(photo_value, prop);
+               VCard_set_property(vcard, "PHOTO", photo_value);
+               g_free(photo);
+       }
+}
+
+void VCard_set_photo_image(VCard* vcard, PhotoType type, const gchar* image) {
+       gchar* photo = NULL;
+       if (vcard == NULL) return;
+
+       GSList* photo_value = VCard_get_property(vcard, "PHOTO");
+       if (image == NULL) {
+               if (photo_value) {
+                       VCard_set_property(vcard, "PHOTO", NULL);
+               }
+       } else {
+               switch (type) {
+                       case PHOTO_DEFAULT:
+                       case PHOTO_JPG:
+                               photo = g_strconcat("TYPE=jpeg;", "ENCODING=b:", image, NULL);
+                               break;
+                       case PHOTO_GIF:
+                               photo = g_strconcat("TYPE=gif;", "ENCODING=b:", image, NULL);
+                               break;
+                       case PHOTO_PNG:
+                               photo = g_strconcat("TYPE=png;", "ENCODING=b:", image, NULL);
+                               break;
+               }
+               VCardProperty* prop = VCardProperty_new("PHOTO", photo);
+               photo_value = g_slist_prepend(photo_value, prop);
+               VCard_set_property(vcard, "PHOTO", photo_value);
+               g_free(photo);
+       }
+}
+
+gchar* VCard_get_etag(VCard* vcard) {
+       if (vcard == NULL) return NULL;
+
+       return g_strdup(vcard->etag);
+}
+
+gchar* VCard_get_name(VCard* vcard) {
+       gchar* res = NULL;
+       if (vcard == NULL) return NULL;
+
+       GSList* fn = VCard_get_property(vcard, "FN");
+       if (fn) {
+               res = g_strdup(fn->data);
+               vcard_slist_property_free(fn);
+       }
+       return res;
+}
+
+gchar* VCard_get_company(VCard* vcard) {
+       gchar* res = NULL;
+       if (vcard == NULL) return NULL;
+
+       GSList* org = VCard_get_property(vcard, "ORG");
+       if (org) {
+               res = g_strdup(org->data);
+               vcard_slist_property_free(org);
+       }
+       return res;
+}
+
+GSList* VCard_get_telefon(VCard* vcard, TelefonType type) {
+       GSList* tel = NULL;
+       if (vcard == NULL) return NULL;
+
+       // TODO: return only telefon according to type
+
+       tel = VCard_get_property(vcard, "TEL");
+       return tel;
+}
+
+GSList* VCard_get_address(VCard* vcard, AddressType type) {
+       GSList* addr = NULL;
+       if (vcard == NULL) return NULL;
+
+       // TODO: return only address according to type
+
+       addr = VCard_get_property(vcard, "ADR");
+       return addr;
+}
+
+gchar* VCard_get_photo(VCard* vcard) {
+       gchar* res = NULL;
+       if (vcard == NULL) return NULL;
+
+       GSList* photo = VCard_get_property(vcard, "PHOTO");
+       if (photo) {
+               res = g_strdup(photo->data);
+               vcard_slist_property_free(photo);
+       }
+       return res;
+}
+
+void VCard_set_email(VCard* vcard, EmailType type, const gchar* email_addr) {
+       gchar* email = NULL;
+       GSList* values = NULL;
+       if (vcard == NULL) return;
+
+       GSList* email_value = VCard_get_property(vcard, "EMAIL");
+       if (email_addr == NULL) {
+               if (email_value) {
+                       remove_email_prop(email_value, type);
+                       VCard_set_property(vcard, "EMAIL", email_value);
+               }
+       } else {
+               switch (type) {
+                       case EMAIL_DEFAULT:
+                       case EMAIL_HOME:
+                               email = g_strconcat("TYPE=HOME:", email_addr, NULL);
+                               break;
+                       case EMAIL_WORK:
+                               email = g_strconcat("TYPE=WORK:", email_addr, NULL);
+                               break;
+                       case EMAIL_OTHER:
+                               email = g_strconcat("TYPE=OTHER:", email_addr, NULL);
+                               break;
+               }
+               if (email_value) {
+                       //print_slist(email_value);
+                       values = g_slist_copy_deep(email_value, slist_copy_func, NULL);
+               }
+               VCardProperty* prop = VCardProperty_new("EMAIL", email);
+               values = g_slist_prepend(values, prop);
+               VCard_set_property(vcard, "EMAIL", values);
+               g_free(email);
+       }
+}
+
+GSList* VCard_get_email(VCard* vcard, EmailType type) {
+       GSList* email = NULL;
+       if (vcard == NULL) return NULL;
+
+       // TODO: return only email according to type
+
+       email = VCard_get_property(vcard, "EMAIL");
+       return email;
+}
+
index b5235278212ef877f92273f6f5ef1e47d91a0430..a83c5e3f34514e7b83534eaede6c15346e45932f 100644 (file)
@@ -29,11 +29,13 @@ G_BEGIN_DECLS
 #include <stdio.h>
 #include <globals.h>
 
-//VCard* VCard_new(VCardVersion version);
+#define DEFAULT_VCARD_VERSION VCARD_VERSION_3_0
+
+VCard* VCard_version_new(VCardVersion version, gboolean init);
+VCard* VCard_new();
 GSList* VCard_new_from_text(const gchar* text, VCardVersion version, gboolean skip_broken);
 GSList* VCard_new_from_file(FILE* file, VCardVersion version, gboolean skip_broken);
 void VCard_free(VCard* object);
-void VCard_list_free(GSList* list);
 
 void VCard_print_list(GSList* list);
 void VCard_print_list_fd(GSList* list, int fd);
@@ -41,6 +43,29 @@ void VCard_print(VCard* object);
 void VCard_print_fd(VCard* object, int fd);
 gchar* VCard_get_state(VCard* object);
 GSList* VCard_get_property(VCard* object, const gchar* property);
+void VCard_set_property(VCard* object, const gchar* property, GSList* props);
+void vcard_property_free(gpointer data);
+void vcard_slist_property_free(gpointer data);
+
+void VCard_set_name(VCard* vcard, const gchar* firstname, const gchar* lastname);
+void VCard_set_company(VCard* vcard, const gchar* company);
+void VCard_set_telefon(VCard* vcard, TelefonType type, const gchar* number);
+void VCard_set_address(VCard* vcard, AddressType type, const gchar* address, const gchar* state, const gchar* city, const gchar* zip, const gchar* country);
+void VCard_set_photo_uri(VCard* vcard, PhotoType type, const gchar* uri);
+void VCard_set_photo_image(VCard* vcard, PhotoType type, const gchar* image);
+void VCard_set_email(VCard* vcard, EmailType type, const gchar* email);
+void VCard_set_etag(VCard* vcard, const gchar* etag);
+
+gchar* VCard_get_name(VCard* vcard);
+gchar* VCard_get_company(VCard* vcard);
+GSList* VCard_get_telefon(VCard* vcard, TelefonType type);
+GSList* VCard_get_address(VCard* vcard, AddressType type);
+gchar* VCard_get_photo(VCard* vcard);
+GSList* VCard_get_email(VCard* vcard, EmailType type);
+gchar* VCard_get_as_string(VCard* object);
+gchar* VCard_get_etag(VCard* vcard);
+
+void print_slist(GSList* list);
 
 G_END_DECLS
 
This page took 1.732082 seconds and 5 git commands to generate.