+/*
+ * curllib.c
+ *
+ * Copyright 2016 Michael Rasmussen <mir@datanom.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include "globals.h"
+#include "curllib.h"
+
+const char* const CollectionType_string[] = {"unknown", "principal","calendar","addressbook"};
+
+#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>"
+
+typedef enum {
+ PROPFIND,
+ OPTIONS
+} Request;
+
+typedef struct {
+ char * memory;
+ size_t size;
+} MemoryStruct;
+
+typedef struct {
+ char trace_ascii; /* 1 or 0 */
+} Data;
+
+typedef struct {
+ MemoryStruct* headers;
+ MemoryStruct* data;
+ char error_buf[CURL_ERROR_SIZE];
+} Buffers;
+
+static Buffers* buffers_new() {
+ Buffers* buffers = g_new0(Buffers, 1);
+ buffers->data = g_new0(MemoryStruct, 1);
+ buffers->data->size = 0;
+ buffers->headers = g_new0(MemoryStruct, 1);
+ buffers->headers->size = 0;
+
+ return buffers;
+}
+
+static void buffers_free(Buffers* buffers) {
+ if (buffers) {
+ if (buffers->data->memory)
+ g_free(buffers->data->memory);
+ g_free(buffers->data);
+ if (buffers->headers->memory)
+ g_free(buffers->headers->memory);
+ g_free(buffers->headers);
+ g_free(buffers);
+ }
+}
+
+/**
+ * This function is burrowed from the libcurl documentation
+ * @param text
+ * @param stream
+ * @param ptr
+ * @param size
+ * @param nohex
+ */
+static void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex) {
+ size_t i;
+ size_t c;
+
+ unsigned int width=0x10;
+
+ if(nohex)
+ /* without the hex output, we can fit more on screen */
+ width = 0x40;
+ fprintf(stream, "%s, %zd bytes (0x%zx)\n", text, size, size);
+ for(i=0; i<size; i+= width) {
+ fprintf(stream, "%04zx: ", i);
+ if(!nohex) {
+ /* hex not disabled, show it */
+ for(c = 0; c < width; c++) {
+ if(i+c < size)
+ fprintf(stream, "%02x ", ptr[i+c]);
+ else
+ fputs(" ", stream);
+ }
+ }
+ for(c = 0; (c < width) && (i+c < size); c++) {
+ /* check for 0D0A; if found, skip past and start a new line of output */
+ if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ i+=(c+2-width);
+ break;
+ }
+ fprintf(stream, "%c",(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
+ /* check again for 0D0A, to avoid an extra \n if it's at width */
+ if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ i+=(c+3-width);
+ break;
+ }
+ }
+ fputc('\n', stream); /* newline */
+ }
+ fflush(stream);
+}
+
+/**
+ * This function is burrowed from the libcurl documentation
+ * @param handle
+ * @param type
+ * @param data
+ * @param size
+ * @param userp
+ * @return
+ */
+static int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp) {
+ Data* config = (Data *)userp;
+ const char* text;
+ (void)handle; /* prevent compiler warning */
+
+ switch (type) {
+ case CURLINFO_TEXT:
+ fprintf(stderr, "== Info: %s", data);
+ default: /* in case a new one is introduced to shock us */
+ return 0;
+ case CURLINFO_HEADER_OUT:
+ text = "=> Send header";
+ break;
+ case CURLINFO_DATA_OUT:
+ text = "=> Send data";
+ break;
+ case CURLINFO_SSL_DATA_OUT:
+ text = "=> Send SSL data";
+ break;
+ case CURLINFO_HEADER_IN:
+ text = "<= Recv header";
+ break;
+ case CURLINFO_DATA_IN:
+ text = "<= Recv data";
+ break;
+ case CURLINFO_SSL_DATA_IN:
+ text = "<= Recv SSL data";
+ break;
+ }
+ dump(text, stderr, data, size, config->trace_ascii);
+ return 0;
+}
+
+/**
+ * This function is burrowed from the libcurl documentation
+ * @param ptr
+ * @param size
+ * @return void* to memory region
+ */
+static void* myrealloc(void* ptr, size_t size) {
+/* There might be a realloc() out there that doesn't like reallocing
+ * NULL pointers, so we take care of it here
+ * */
+ if(ptr)
+ return realloc(ptr, size);
+ else
+ return malloc(size);
+}
+
+/**
+ * This function is burrowed from the libcurl documentation
+ * @param ptr
+ * @param size
+ * @param nmemb
+ * @param data
+ * @return number of written bytes
+ */
+static size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data) {
+ size_t realsize = size * nmemb;
+ MemoryStruct* mem = (MemoryStruct *)data;
+ mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
+
+ if (mem->memory) {
+ memcpy(&(mem->memory[mem->size]), ptr, realsize);
+ mem->size += realsize;
+ mem->memory[mem->size] = 0;
+ }
+ return realsize;
+}
+
+static CURL* get_curl(CarddavData* data) {
+ CURL* curl;
+ gchar* userpwd;
+ Data config;
+
+ curl = curl_easy_init();
+ if (curl) {
+ if (data->pwd) {
+ userpwd = g_strconcat(data->user, ":", data->pwd, NULL);
+ curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
+ } else {
+ userpwd = g_strconcat(data->user, NULL);
+ curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
+ }
+ 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);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
+ curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteMemoryCallback);
+ if (data->debug) {
+ config.trace_ascii = 1;
+ curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
+ curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &config);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+ }
+ curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+ curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
+ curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
+ }
+
+ return curl;
+}
+
+static CURL* prepare_curl(CarddavData* dav, Buffers* buffers, Request type) {
+ CURL* curl = get_curl(dav);
+ if (curl) {
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)buffers->data);
+ curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)buffers->headers);
+ curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *)buffers->error_buf);
+ switch (type) {
+ case OPTIONS:
+ curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "OPTIONS");
+ break;
+ case PROPFIND:
+ curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PROPFIND");
+ break;
+ }
+ }
+
+ return curl;
+}
+
+static gboolean has_support(CarddavData* dav, const gchar* headers) {
+ gboolean support = FALSE;
+
+ g_print("%s\n", headers);
+ gchar* start = g_strstr_len(headers, -1, "DAV");
+ if (start) {
+ gchar** values = g_strsplit(start, ":", 0);
+ if (values && g_strv_length(values) > 1) {
+ gchar** options = g_strsplit(values[1], ",", 0);
+ if (options && g_strv_length(options) > 0) {
+ gchar** tmp = options;
+ while (*tmp) {
+ gchar *opt, *option;
+ gchar* end = g_strstr_len(*tmp, -1, "\r");
+ if (end) {
+ gchar* str = g_strndup(*tmp, end - *tmp);
+ opt = g_ascii_strup(str, -1);
+ g_free(str);
+ option = g_strstrip(opt);
+ } else {
+ opt = g_ascii_strup(*tmp, -1);
+ option = g_strstrip(opt);
+ }
+ if (g_strcmp0(option, "ADDRESSBOOK") == 0)
+ support = TRUE;
+ if (g_strcmp0(option, "EXTENDED-MKCOL") == 0)
+ dav->mkcol = TRUE;
+ g_free(opt);
+ tmp++;
+ }
+ }
+ g_strfreev(options);
+ }
+ g_strfreev(values);
+ }
+
+ return support;
+}
+
+static gchar* find_text(const gchar* string, const gchar* start, const gchar* end) {
+ gchar* text = NULL;
+
+ if (start && end) {
+ gchar* s_start = g_strstr_len(string, -1, start);
+ if (s_start) {
+ gchar* s_end = g_strstr_len(s_start, -1, end);
+ if (s_start && s_end) {
+ text = g_strndup(s_start + strlen(start), s_end - (s_start + strlen(start)));
+ }
+ }
+ }
+
+ return text;
+}
+
+static gchar* remove_ns(gchar* s) {
+ gchar* s1 = NULL;
+ //gchar* tmp = NULL;
+
+ if (s) {
+ gchar* s_start = g_strstr_len(s, -1, ":");
+ if (s_start) {
+ s1 = g_strndup(s_start + 1, strlen(s_start + 1));
+ } else {
+ s1 = g_strdup(s);
+ }
+ g_strstrip(s1);
+ //g_free(tmp);
+ }
+
+ return s1;
+}
+
+static CollectionType get_collection_type(const gchar* s) {
+ CollectionType type = UNKNOWN;
+ int len = sizeof(CollectionType_string)/sizeof(CollectionType_string[0]);
+
+ if (s) {
+ for (int i = 0; i < len; ++i) {
+ if (g_strcmp0(CollectionType_string[i], s) == 0) {
+ type = i;
+ break;
+ }
+ }
+ }
+
+ return type;
+}
+
+/*
+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_get_options(CarddavData* dav, GString* buf) {
+ gboolean res;
+ CURLcode curlres = 0;
+ Buffers* buffers = buffers_new();
+
+ CURL* curl = prepare_curl(dav, buffers, OPTIONS);
+ if (curl) {
+ 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 != 200) {
+ res = TRUE;
+ }
+ else {
+ res = !has_support(dav, buffers->headers->memory);
+ GString* displayname = g_string_new(NULL);
+ if (!curl_get_displayname(dav, displayname))
+ dav->displayname = g_string_free_and_steal(displayname);
+ else
+ g_string_free(displayname, TRUE);
+ }
+ }
+ curl_easy_cleanup(curl);
+ } else {
+ res = TRUE;
+ }
+ buffers_free(buffers);
+
+ return res;
+}
+
+gboolean curl_get_displayname(CarddavData* dav, GString* buf) {
+ gboolean res;
+ CURLcode curlres = 0;
+ Buffers* buffers = buffers_new();
+
+ if (!buf) return TRUE;
+
+ CURL* curl = prepare_curl(dav, buffers, PROPFIND);
+ if (curl) {
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_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) {
+ res = TRUE;
+ }
+ else {
+ gchar* displayname = find_text(buffers->data->memory, "<displayname>", "</displayname>");
+ if (displayname) {
+ buf = g_string_assign(buf, displayname);
+ g_free(displayname);
+ }
+ res = FALSE;
+ }
+ }
+ curl_easy_cleanup(curl);
+ } else {
+ res = TRUE;
+ }
+
+ buffers_free(buffers);
+
+ return res;
+}
+
+gboolean curl_get_resource_type(CarddavData* dav) {
+ Buffers* buffers = buffers_new();
+ gboolean res = TRUE;
+ CURLcode curlres = 0;
+ GPtrArray* types = g_ptr_array_new_null_terminated(1, (GDestroyNotify)g_free, TRUE);
+
+ CURL* curl = prepare_curl(dav, buffers, PROPFIND);
+ if (curl) {
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDS, prop_request);
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, -1L);
+ curlres = curl_easy_perform(curl);
+ if (curlres != 0) {
+ g_ptr_array_add(types, g_strdup(buffers->error_buf));
+ res = TRUE;
+ }
+ else {
+ long code;
+ curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
+ if (code != 207) {
+ res = TRUE;
+ }
+ else {
+ gchar* resourcetype = find_text(buffers->data->memory, "<resourcetype>", "</resourcetype>");
+ if (resourcetype) {
+ gchar* tmp = g_strdup(resourcetype);
+ g_free(resourcetype);
+ resourcetype = find_text(tmp, "<", "/>");
+ gchar* s = remove_ns(resourcetype);
+ g_free(resourcetype);
+ if (s) {
+ g_ptr_array_add(types, g_strdup(s));
+ g_free(s);
+ resourcetype = find_text(tmp, "><", "/>");
+ gchar* s = remove_ns(resourcetype);
+ g_ptr_array_add(types, g_strdup(s));
+ g_free(resourcetype);
+ g_free(s);
+ }
+ g_free(tmp);
+ }
+ res = FALSE;
+ }
+ }
+ curl_easy_cleanup(curl);
+ }
+
+ if (types->len > 0) {
+ gboolean authorized = FALSE;
+ gpointer* types_str = g_ptr_array_free(types, FALSE);
+ gchar** start = (gchar**)types_str;
+ while (*types_str) {
+ CollectionType type = get_collection_type(*types_str);
+ switch (type) {
+ case PRINCIPAL:
+ case CALENDAR:
+ case ADDRESSBOOK:
+ dav->type = type;
+ authorized = TRUE;
+ break;
+ default:
+ break;
+ }
+ types_str++;
+ }
+ if (authorized == FALSE)
+ dav->type = UNKNOWN;
+ g_strfreev(start);
+ }
+
+ buffers_free(buffers);
+
+ return res;
+}
+
+void curl_free_CarddavData(CarddavData* dav) {
+ if (dav) {
+ g_free(dav->displayname);
+ g_free(dav->pwd);
+ g_free(dav->url);
+ g_free(dav->user);
+ g_free(dav);
+ }
+}
+
+const gchar* get_resource_type_name(CollectionType type) {
+ if (type < TYPE_SIZE)
+ return CollectionType_string[type];
+
+ return NULL;
+};