+/*
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include <glib.h>
+#include "config.h"
+#include "curllib.h"
+#include "caldav.h"
+#include "xml.h"
+
+static gboolean curl_not_initialized = TRUE;
+static struct Data config;
+
+struct MemoryStruct {
+ char * memory;
+ size_t size;
+};
+
+struct Data {
+ char trace_ascii; /* 1 or 0 */
+};
+
+/**
+ * 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) {
+ struct Data* config = (struct 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;
+ struct MemoryStruct* mem = (struct 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 struct curl_slist* gslist_to_slist(GSList* list) {
+ struct curl_slist* s = NULL;
+
+ for (GSList* elem = list; elem; elem = g_slist_next(elem)) {
+ s = curl_slist_append(s, elem->data);
+ }
+
+ return s;
+}
+
+static void curl_set_request(CURL* curl, RequestType type) {
+ gchar* req = NULL;
+
+ switch (type) {
+ case DELETE: req = g_strdup("DELETE"); break;
+ case PROPFIND: req = g_strdup("PROPFIND"); break;
+ case PUT: req = g_strdup("PUT"); break;
+ case REPORT: req = g_strdup("REPORT"); break;
+ case GET: req = g_strdup("GET"); break;
+ case OPTIONS: req = g_strdup("OPTIONS"); break;
+ case LOCK: req = g_strdup("LOCK"); break;
+ case UNLOCK: req = g_strdup("UNLOCK"); break;
+ }
+ curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, req);
+ g_free(req);
+}
+
+static CURL* get_curl(Request* request, gboolean debug) {
+ CURL* curl;
+ gchar* userpwd;
+
+ curl = curl_easy_init();
+ if (curl) {
+ if (request->password) {
+ userpwd = g_strconcat(request->username, ":", request->password, NULL);
+ curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
+ } else {
+ userpwd = g_strconcat(request->username, NULL);
+ curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
+ }
+ g_free(userpwd);
+ curl_set_request(curl, request->request);
+ curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+ curl_easy_setopt(curl, CURLOPT_USERAGENT, PACKAGE_STRING);
+ curl_easy_setopt(curl, CURLOPT_URL, request->url);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
+ curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteMemoryCallback);
+ if (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);
+ if (request->request != DELETE && request->request != GET && request->request != OPTIONS) {
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request->data);
+ curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,
+ (request->data) ? strlen(request->data) : 0);
+ }
+ }
+
+ return curl;
+}
+
+static GSList* memory_struct_to_gslist(struct MemoryStruct buffer) {
+ GSList* list = NULL;
+ gchar **elems, **e;
+
+ if (buffer.size > 0) {
+ elems = g_strsplit(buffer.memory, "\n", 0);
+ for (e = elems; *e != NULL; ++e) {
+ if (g_strcmp0(*e, "\r") != 0 || g_strcmp0(*e, "") != 0)
+ list = g_slist_prepend(list, g_strdup(*e));
+ }
+ g_strfreev(elems);
+ }
+
+ return list;
+}
+
+Request* request_new() {
+ Request* r = g_new0(Request, 1);
+
+ return r;
+}
+
+
+void request_free(Request* request) {
+ if (request) {
+ if (request->headers) {
+ slist_free_gchar(request->headers);
+ request->headers = NULL;
+ }
+ if (request->data) {
+ g_free(request->data);
+ request->data = NULL;
+ }
+ if (request->username) {
+ g_free(request->username);
+ request->username = NULL;
+ }
+ if (request->password) {
+ g_free(request->password);
+ request->password = NULL;
+ }
+ if (request->url) {
+ g_free(request->url);
+ request->url = NULL;
+ }
+ g_free(request);
+ request = NULL;
+ }
+}
+
+Response* request_send(Request* request, gboolean debug) {
+ g_return_val_if_fail(request != NULL, NULL);
+
+ Response* r = g_new0(Response, 1);
+ CURLcode curlres = 0;
+ struct MemoryStruct data;
+ struct MemoryStruct headers;
+ char error_buf[CURL_ERROR_SIZE];
+ struct curl_slist* http_headers;
+
+ data.memory = NULL;
+ data.size = 0;
+ headers.memory = NULL;
+ headers.size = 0;
+
+ if (curl_not_initialized) {
+ curl_global_init(CURL_GLOBAL_ALL);
+ curl_not_initialized = FALSE;
+ }
+
+ CURL* curl = get_curl(request, debug);
+ if (curl) {
+ http_headers = gslist_to_slist(request->headers);
+ curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_headers);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&data);
+ curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
+ curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
+ curlres = curl_easy_perform(curl);
+ if (curlres != CURLE_OK) {
+ request->data = g_strdup(error_buf);
+ }
+ else {
+ curlres = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &r->status);
+ r->headers = memory_struct_to_gslist(headers);
+ r->data = g_strndup(data.memory, data.size);
+ if (r->status == 207 && (request->request == DELETE || request->request == PUT)) {
+ /* Error code is returnded inside XML response */
+ GSList* response = find_element("//d:status", r->data, "d", "DAV:");
+ if (response) {
+ if (g_strstr_len((gchar *) response->data, -1, "423")) {
+ r->status = 423;
+ }
+ }
+ slist_free_gchar(response);
+ }
+ }
+ if (data.memory)
+ free(data.memory);
+ if (headers.memory)
+ free(headers.memory);
+ curl_slist_free_all(http_headers);
+ curl_easy_cleanup(curl);
+ }
+
+ return r;
+}
+
+void response_free(Response* response) {
+ if (response) {
+ if (response->headers) {
+ slist_free_gchar(response->headers);
+ response->headers = NULL;
+ }
+ if (response->data) {
+ g_free(response->data);
+ response->data = NULL;
+ }
+ g_free(response);
+ response = NULL;
+ }
+}
projects / caldav.git / blobdiff