From: Michael Rasmussen Date: Mon, 21 Apr 2025 22:59:30 +0000 (+0200) Subject: All features added X-Git-Url: http://git.datanom.net/vcard-parser.git/commitdiff_plain/d4b85e4731a7305ab6a57fea45796fc90ae76e39?ds=inline All features added Signed-off-by: Michael Rasmussen --- diff --git a/.gitignore b/.gitignore index edbfb05..3c013b2 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ *.ko *.obj *.elf +.deps # Linker output *.ilk diff --git a/example/vcard-example.c b/example/vcard-example.c index f8f1770..68962ba 100644 --- a/example/vcard-example.c +++ b/example/vcard-example.c @@ -4,15 +4,30 @@ #include #include +#include #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", "://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); diff --git a/src/curl/curllib.c b/src/curl/curllib.c index 6b18dd0..6a0d2ba 100644 --- a/src/curl/curllib.c +++ b/src/curl/curllib.c @@ -25,24 +25,61 @@ #include #include "globals.h" #include "curllib.h" +#include "vcard.h" const char* const CollectionType_string[] = {"unknown", "principal","calendar","addressbook"}; +#define etag_request_head "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" + +#define etag_request_back "" \ + "" \ + "" \ + "" + #define prop_request "" \ - "" \ - "" \ - "" \ - "" \ - "" \ - "" \ - "" \ - "" \ - "" \ - "" + "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" + +#define changed_request "" \ + "" \ + "" \ + "" \ + "" \ + "" + +#define data_request "" \ + "" \ + "" \ + "" \ + "" \ + "" \ + "" 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, "", ""); + + 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("", NULL); + etag = find_text(string, etag_begin, etag_end); + g_free(etag_begin); + g_free(etag_end); + } else { + etag = find_text(string, "", ""); + } + + 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, """, """); + 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); } } diff --git a/src/curl/curllib.h b/src/curl/curllib.h index f44f2ce..6eb569d 100644 --- a/src/curl/curllib.h +++ b/src/curl/curllib.h @@ -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 diff --git a/src/parser/globals.h b/src/parser/globals.h index eefb5ac..2dc6f25 100644 --- a/src/parser/globals.h +++ b/src/parser/globals.h @@ -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 diff --git a/src/parser/vcard-parser.c b/src/parser/vcard-parser.c index 380c19e..fc6f6f5 100644 --- a/src/parser/vcard-parser.c +++ b/src/parser/vcard-parser.c @@ -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 { diff --git a/src/parser/vcard-parser.h b/src/parser/vcard-parser.h index d812ab8..b8d30f9 100644 --- a/src/parser/vcard-parser.h +++ b/src/parser/vcard-parser.h @@ -27,6 +27,7 @@ G_BEGIN_DECLS #include +#include 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 diff --git a/src/parser/vcard.c b/src/parser/vcard.c index d7fd301..adfe12e 100644 --- a/src/parser/vcard.c +++ b/src/parser/vcard.c @@ -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; +} + diff --git a/src/parser/vcard.h b/src/parser/vcard.h index b523527..a83c5e3 100644 --- a/src/parser/vcard.h +++ b/src/parser/vcard.h @@ -29,11 +29,13 @@ G_BEGIN_DECLS #include #include -//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