--- /dev/null
+/*
+ * caldav.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 <stdio.h>
+#include <unistd.h>
+#include "caldav.h"
+#include "curllib.h"
+#include "xml.h"
+
+static gchar* get_timerange(Runtime* runtime) {
+ gchar* timerange = NULL;
+
+ if (runtime->start && runtime->finish) {
+ GDateTime* s_utc = g_date_time_to_utc(runtime->start);
+ GDateTime* f_utc = g_date_time_to_utc(runtime->finish);
+ gchar* start = g_date_time_format(s_utc, "%Y%m%dT%H%M%SZ");
+ gchar* finish = g_date_time_format(f_utc, "%Y%m%dT%H%M%SZ");
+ g_date_time_unref(s_utc);
+ g_date_time_unref(f_utc);
+
+ timerange = g_strconcat(
+ "<c:time-range start=\"", start, "\"",
+ " end=\"", finish, "\"/>",
+ NULL);
+ g_free(start);
+ g_free(finish);
+ }
+
+ return timerange;
+}
+
+/*
+ * Operation Depth RequestType
+ * CALENDARINFO 0 PROPFIND
+ * GETOBJECTS 1 REPORT
+ * CHANGEINFO 1 REPORT
+ * UPDATEOBJECTS - PUT
+ * ADDOBJECTS - PUT
+ * DELETEOBJECTS - DELETE
+ * DISCOVER 0 PROPFIND
+ * OPTIONSINFO 0 OPTIONS
+ * LOCKING 0
+*/
+static Request* request_init(Runtime* r) {
+ Request* rq = request_new();
+ GString* href = g_string_new("");
+ gchar* timerange = NULL;
+
+ switch (*r->operation) {
+ case CALENDARINFO:
+ rq->request = PROPFIND;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<d:propfind xmlns:d=\"DAV:\" xmlns:cs=\"http://calendarserver.org/ns/\">",
+ "<d:prop><d:displayname /><cs:getctag /></d:prop></d:propfind>",
+ NULL);
+ break;
+ case GETOBJECTS:
+ rq->request = REPORT;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 1"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ if (r->hrefs) {
+ for (GSList* l = r->hrefs; l; l = g_slist_next(l)) {
+ HrefData* h = (HrefData *) l->data;
+ gchar* elem = g_strconcat("<d:href>", h->href, "</d:href>", NULL);
+ href = g_string_append(href, elem);
+ g_free(elem);
+ }
+ }
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<c:calendar-multiget xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ "<d:prop><d:getetag /><c:calendar-data /></d:prop>",
+ g_string_free(href, FALSE), "</c:calendar-multiget>",
+ NULL);
+ break;
+ case GETALLOBJECTS:
+ rq->request = REPORT;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 1"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ timerange = get_timerange(r);
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<c:calendar-query xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ "<d:prop><d:getetag /><c:calendar-data /></d:prop>",
+ "<c:filter><c:comp-filter name=\"VCALENDAR\">",
+ "<c:comp-filter name=\"VEVENT\">",timerange ? timerange : "",
+ "</c:comp-filter></c:comp-filter>",
+ "</c:filter></c:calendar-query>",
+ NULL);
+ if (timerange)
+ g_free(timerange);
+ break;
+ case CHANGEINFO:
+ rq->request = REPORT;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 1"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ timerange = get_timerange(r);
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<c:calendar-query xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ "<d:prop><d:getetag /></d:prop><c:filter><c:comp-filter name=\"VCALENDAR\">",
+ "<c:comp-filter name=\"VEVENT\">",timerange ? timerange : "",
+ "</c:comp-filter></c:comp-filter>",
+ "</c:filter></c:calendar-query>",
+ NULL);
+ if (timerange)
+ g_free(timerange);
+ break;
+ case UPDATEOBJECTS:
+ rq->request = PUT;
+ rq->headers = g_slist_append(rq->headers, g_strconcat("If-Match: \"", r->etag ? r->etag : "", "\"", NULL));
+ rq->data = g_strdup(r->component ? r->component : "");
+ break;
+ case ADDOBJECTS:
+ rq->request = PUT;
+ rq->headers = g_slist_append(rq->headers, g_strdup("If-None-Match: *"));
+ rq->data = g_strdup(r->component ? r->component : "");
+ break;
+ case DELETEOBJECTS:
+ rq->request = DELETE;
+ rq->headers = g_slist_append(rq->headers, g_strconcat("If-Match: \"", r->etag ? r->etag : "", "\"", NULL));
+ break;
+ case DISCOVER:
+ rq->request = PROPFIND;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ break;
+ case SIMPLEGET:
+ rq->request = GET;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ break;
+ case OPTIONSINFO:
+ rq->request = OPTIONS;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ break;
+ case LOCKING:
+ rq->request = LOCK;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Timeout: Second-60"));
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<D:lockinfo xmlns:D=\"DAV:\"><D:lockscope><D:exclusive/></D:lockscope>",
+ " <D:locktype><D:write/></D:locktype></D:lockinfo>",
+ NULL);
+ break;
+ case UNLOCKING:
+ rq->request = UNLOCK;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 0"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ break;
+ case FREEBUSY:
+ rq->request = REPORT;
+ rq->headers = g_slist_append(rq->headers, g_strdup("Depth: 1"));
+ rq->headers = g_slist_append(rq->headers, g_strdup("Prefer: return-minimal"));
+ timerange = get_timerange(r);
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<c:free-busy-query xmlns:D=\"DAV:\"",
+ " xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ timerange ? timerange : "", "</c:free-busy-query>",
+ NULL);
+ if (timerange)
+ g_free(timerange);
+ break;
+ default:
+ request_free(rq);
+ rq = NULL;
+ }
+
+ if (rq) {
+ rq->headers = g_slist_append(rq->headers, g_strdup("Content-Type: application/xml; charset=utf-8"));
+ rq->username = g_strdup(r->username);
+ rq->password = g_strdup(r->password);
+ rq->url = g_strdup(r->url);
+ }
+
+ return rq;
+}
+
+static gchar* get_host_part(const gchar* url) {
+ gchar* host_part = NULL;
+
+ gchar* s = g_strstr_len(url, -1, "://");
+ if (!s) {
+ s = (gchar *) url;
+ } else {
+ s += 3;
+ }
+
+ gchar* s1 = g_strstr_len(s, -1, "/");
+
+ if (s1) {
+ host_part = g_strndup(url, s1 - url);
+ } else {
+ host_part = g_strdup(url);
+ }
+
+ return host_part;
+}
+
+static GSList* gchar_list_copy(GSList* list) {
+ GSList* headers = NULL;
+ for (GSList* l = list; l; l = g_slist_next(l)) {
+ gchar* h = g_strdup((gchar *) l->data);
+ headers = g_slist_append(headers, h);
+ }
+
+ return headers;
+}
+
+static void debug_request(Request* rq) {
+ printf("HTTP Headers:\n");
+ for (GSList* l = rq->headers; l; l = g_slist_next(l)) {
+ printf("%s\n", (gchar *) l->data);
+ }
+ switch (rq->request) {
+ case DELETE: printf("DELETE "); break;
+ case PROPFIND: printf("PROPFIND "); break;
+ case PUT: printf("PUT "); break;
+ case REPORT: printf("REPORT "); break;
+ case GET: printf("GET "); break;
+ case OPTIONS: printf("OPTIONS "); break;
+ case LOCK: printf("LOCK "); break;
+ case UNLOCK: printf("UNLOCK "); break;
+ }
+ printf("%s\n", rq->url);
+ printf("DATA:\n%s\n", rq->data ? rq->data : "None");
+}
+
+static void debug_response(Response* r) {
+ printf("HTTP Status: %i\nHTTP headers:\n", r->status);
+ for (GSList* l = r->headers; l; l = g_slist_next(l)) {
+ printf("%s\n", (gchar *) l->data);
+ }
+}
+
+static guint execute_options(gpointer ptr);
+static void caldav_response_free(Operation op, CaldavResponse* cr);
+
+static gchar* execute_locking(Runtime* runtime, const gchar* lock_token, guint* status) {
+ gchar* token = NULL;
+ Request* rq = NULL;
+ Response* r = NULL;
+
+ Runtime* tmp = runtime_copy(runtime);
+ if (!tmp->options) {
+ *tmp->operation = OPTIONSINFO;
+ guint status = execute_options((gpointer) tmp);
+ if (status != 200)
+ return NULL;
+ caldav_response_free(*tmp->operation, tmp->output);
+ runtime->options = slist_copy_gchar(tmp->options);
+ }
+
+ if (tmp->options && has_option(tmp, "lock")) {
+ if (lock_token) {
+ *tmp->operation = UNLOCKING;
+ rq = request_init(tmp);
+ rq->headers = g_slist_append(rq->headers,
+ g_strconcat("Lock-Token: ", lock_token, NULL));
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+ r = request_send(rq, runtime->debug);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+ }
+ } else {
+ *tmp->operation = LOCKING;
+ rq = request_init(tmp);
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+ r = request_send(rq, runtime->debug);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+
+ if (r->status != 423)
+ token = find_header(r->headers, "Lock-Token");
+ else
+ token = g_strdup(r->data);
+ }
+ }
+ }
+
+ if (status)
+ *status = r->status;
+
+ response_free(r);
+ request_free(rq);
+ runtime_free(tmp);
+
+ return token;
+}
+
+static guint execute_default(gpointer ptr) {
+ Runtime* runtime = (Runtime *) ptr;
+ Request* rq = request_init(runtime);
+ guint status = 500;
+ gchar* lock_token = NULL;
+
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+
+ if (*runtime->operation == DELETEOBJECTS) {
+ lock_token = execute_locking(runtime, NULL, &status);
+ if (status == 423) {
+ runtime->output = g_new0(CaldavResponse, 1);
+ runtime->output->data = (gpointer) g_strdup(lock_token);
+ runtime->output->status = status;
+ g_free(lock_token);
+ request_free(rq);
+ return status;
+ }
+ }
+ if (lock_token) {
+ rq->headers = g_slist_append(rq->headers,
+ g_strconcat("Lock-Token: ", lock_token, NULL));
+ }
+ Response* r = request_send(rq, runtime->debug);
+ if (lock_token) {
+ execute_locking(runtime, lock_token, &status);
+ g_free(lock_token);
+ lock_token = NULL;
+ }
+ request_free(rq);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+
+ runtime->output = g_new0(CaldavResponse, 1);
+ runtime->output->data = (gpointer) g_strdup(r->data);
+
+ if (runtime->file)
+ fprintf(runtime->file, r->data);
+
+ runtime->output->status = status = r->status;
+
+ runtime->output->headers = gchar_list_copy(r->headers);
+
+ response_free(r);
+ }
+
+ return status;
+}
+
+static guint execute_options(gpointer ptr) {
+ Runtime* runtime = (Runtime *) ptr;
+ Request* rq = request_init(runtime);
+ guint status = 500;
+
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+ Response* r = request_send(rq, runtime->debug);
+ request_free(rq);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+
+ gchar* headers = find_header(r->headers, "Allow");
+ if (headers) {
+ gchar** options = g_strsplit(headers, ",", 0);
+ for (int i = 0; options[i]; i++) {
+ gchar* tmp = g_strdup(options[i]);
+ tmp = g_strstrip(tmp);
+ runtime->options = g_slist_append(runtime->options, g_strdup(tmp));
+ g_free(tmp);
+ }
+ g_strfreev(options);
+ g_free(headers);
+ }
+
+ if (runtime->file) {
+ for (GSList* l = runtime->options; l; l = g_slist_next(l)) {
+ fprintf(runtime->file, "%s\n", (gchar *) l->data);
+ }
+ }
+
+ runtime->output = g_new0(CaldavResponse, 1);
+ runtime->output->status = status = r->status;
+
+ runtime->output->headers = gchar_list_copy(r->headers);
+
+ response_free(r);
+ }
+
+ return status;
+}
+
+static guint execute_freebusy(gpointer ptr) {
+ Runtime* runtime = (Runtime *) ptr;
+
+ Request* rq = request_init(runtime);
+ guint status = 500;
+
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+ Response* r = request_send(rq, runtime->debug);
+ request_free(rq);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+
+ runtime->output = g_new0(CaldavResponse, 1);
+ runtime->output->data = (gpointer) g_strdup(r->data);
+
+ if (runtime->file)
+ fprintf(runtime->file, r->data);
+
+ runtime->output->status = status = r->status;
+
+ runtime->output->headers = gchar_list_copy(r->headers);
+
+ response_free(r);
+ }
+
+ return status;
+}
+
+static guint execute_discover(gpointer ptr) {
+ Runtime* runtime = (Runtime *) ptr;
+ Response* r = NULL;
+ Request* rq = NULL;
+ GSList* list = NULL;
+ guint status = 500;
+
+ rq = request_init(runtime);
+ if (rq) {
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<d:propfind xmlns:d=\"DAV:\">",
+ "<d:prop><d:current-user-principal /></d:prop></d:propfind>",
+ NULL);
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+ r = request_send(rq, runtime->debug);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+ list = find_element("//d:current-user-principal/*", r->data, "d", "DAV:");
+ response_free(r);
+ if (list) {
+ /* Change URL to where "current-user-principal" is located */
+ gchar* s = get_host_part(runtime->url);
+ g_free(runtime->url);
+ runtime->url = g_strconcat(s, list->data, NULL);
+ g_free(s);
+ slist_free_gchar(list);
+ list = NULL;
+ }
+ g_free(rq->data);
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<d:propfind xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ "<d:prop><c:calendar-home-set /></d:prop></d:propfind>",
+ NULL);
+ r = request_send(rq, runtime->debug);
+ list = find_element("//c:calendar-home-set/*", r->data,
+ "c", "urn:ietf:params:xml:ns:caldav");
+ response_free(r);
+ if (list) {
+ /* Change URL to where "calendar-home-set" is located */
+ gchar* s = get_host_part(runtime->url);
+ g_free(runtime->url);
+ runtime->url = g_strconcat(s, list->data, NULL);
+ g_free(s);
+ slist_free_gchar(list);
+ list = NULL;
+ }
+ g_free(rq->data);
+ rq->data = g_strconcat(
+ "<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
+ "<d:propfind xmlns:d=\"DAV:\" xmlns:cs=\"http://calendarserver.org/ns/\" ",
+ "xmlns:c=\"urn:ietf:params:xml:ns:caldav\">",
+ "<d:prop><d:resourcetype/><d:displayname/><cs:getctag/>",
+ "<c:supported-calendar-component-set/></d:prop></d:propfind>",
+ NULL);
+ for (GSList* l = rq->headers; l; l = g_slist_next(l)) {
+ if (g_strcmp0(l->data, "Depth: 0") == 0) {
+ g_free(l->data);
+ l->data = g_strdup("Depth: 1");
+ }
+
+ }
+ r = request_send(rq, runtime->debug);
+ gchar* s = get_host_part(runtime->url);
+ list = find_calendars(s, r->data);
+ g_free(s);
+
+ runtime->output = g_new0(CaldavResponse, 1);
+ GSList* data = NULL;
+ for (GSList* l = list; l; l = g_slist_next(l)) {
+ Calendar* c = calendar_copy((Calendar *) l->data);
+ data = g_slist_append(data, c);
+ }
+ runtime->output->data = (gpointer) data;
+
+ if (runtime->file) {
+ for (GSList* l = list; l; l = g_slist_next(l)) {
+ calendar_dump(runtime->file, (Calendar *) l->data);
+ }
+ }
+ g_slist_foreach(list, (GFunc)calendar_free, NULL);
+ g_slist_free(list);
+ list = NULL;
+
+ runtime->output->headers = gchar_list_copy(r->headers);
+
+ runtime->output->status = status = r->status;
+
+ response_free(r);
+ request_free(rq);
+ }
+
+ return status;
+}
+
+static guint execute_add_update(gpointer ptr) {
+ Runtime* runtime = (Runtime *) ptr;
+ Request* rq = request_init(runtime);
+ guint status = 500;
+ gchar* lock_token = NULL;
+
+ if (rq) {
+ if (runtime->debug) {
+ debug_request(rq);
+ }
+
+ if (*runtime->operation == UPDATEOBJECTS) {
+ lock_token = execute_locking(runtime, NULL, &status);
+ if (status == 423) {
+ runtime->output = g_new0(CaldavResponse, 1);
+ runtime->output->data = (gpointer) g_strdup(lock_token);
+ runtime->output->status = status;
+ g_free(lock_token);
+ request_free(rq);
+ return status;
+ }
+ }
+ if (lock_token) {
+ rq->headers = g_slist_append(rq->headers,
+ g_strconcat("Lock-Token: ", lock_token, NULL));
+ }
+ Response* r = request_send(rq, runtime->debug);
+ if (lock_token) {
+ execute_locking(runtime, lock_token, &status);
+ g_free(lock_token);
+ lock_token = NULL;
+ }
+ request_free(rq);
+
+ if (runtime->debug) {
+ debug_response(r);
+ }
+
+ runtime->output = g_new0(CaldavResponse, 1);
+ if (r->status == 201 || r->status == 204) {
+ gchar* etag = find_header(r->headers, "ETag");
+ if (etag == NULL) {
+ Runtime* r_new = runtime_copy(runtime);
+ *r_new->operation = SIMPLEGET;
+ guint s = execute(r_new);
+ if (s == 200 && r_new->output && r_new->output->headers) {
+ etag = find_header(r_new->output->headers, "ETag");
+ }
+ runtime_free(r_new);
+ }
+ runtime->output->data = (gpointer) g_strdup(etag);
+ if (runtime->file) {
+ if (etag)
+ fprintf(runtime->file, "ETag: %s\n", etag);
+ else
+ fprintf(runtime->file, "%s\n", "No ETag returned");
+ }
+ g_free(etag);
+ } else {
+ runtime->output->data = (gpointer) g_strdup(r->data);
+ if (runtime->file)
+ fprintf(runtime->file, "%s\n", r->data);
+ }
+
+ runtime->output->status = status = r->status;
+
+ runtime->output->headers = gchar_list_copy(r->headers);
+
+ response_free(r);
+ }
+
+ return status;
+}
+
+static void caldav_response_free(Operation op, CaldavResponse* cr) {
+ GSList* list = NULL;
+
+ if (cr) {
+ if (cr->headers) {
+ slist_free_gchar(cr->headers);
+ cr->headers = NULL;
+ }
+ if (cr->data) {
+ switch (op) {
+ case DISCOVER:
+ list = (GSList *) cr->data;
+ g_slist_foreach(list, (GFunc)calendar_free, NULL);
+ g_slist_free(list);
+ break;
+ case OPTIONSINFO:
+ list = (GSList *) cr->data;
+ slist_free_gchar(list);
+ break;
+ default:
+ g_free((gchar *)cr->data);
+ }
+ cr->data = NULL;
+ }
+ }
+}
+
+gchar* find_header(GSList* list, const gchar* header) {
+ g_return_val_if_fail(header != NULL, NULL);
+
+ GString* hit = NULL;
+
+ for (GSList* l = list; l; l = g_slist_next(l)) {
+ gchar* s = (gchar *) l->data;
+ gchar** t = g_strsplit(s, ":", 2);
+ for (int i = 0; t[i]; i++) {
+ gchar* s1 = g_utf8_casefold(g_strstrip(t[i]), -1);
+ gchar* s2 = g_utf8_casefold(header, -1);
+ if (g_strcmp0(s1, s2) == 0) {
+ if (hit) {
+ hit = g_string_append(hit, ", ");
+ hit = g_string_append(hit, g_strstrip(t[i+1]));
+ } else {
+ hit = g_string_new(g_strstrip(t[i+1]));
+ }
+ }
+ g_free(s1);
+ g_free(s2);
+ }
+ }
+
+ return (hit) ? g_string_free(hit, FALSE) : NULL;
+}
+
+void slist_free_gchar(GSList* list) {
+ if (list) {
+ g_slist_foreach(list, (GFunc)g_free, NULL);
+ g_slist_free(list);
+ list = NULL;
+ }
+}
+
+Runtime* runtime_new() {
+ Runtime* r = g_new0(Runtime, 1);
+ r->default_executor = TRUE;
+
+ return r;
+}
+
+Calendar* calendar_copy(Calendar* cal) {
+ Calendar* new_cal = NULL;
+
+ if (!cal)
+ return NULL;
+
+ new_cal = g_new0(Calendar, 1);
+ new_cal->displayname = g_strdup(cal->displayname);
+ new_cal->url = g_strdup(cal->url);
+ new_cal->ctag = g_strdup(cal->ctag);
+ new_cal->components = g_slist_copy(cal->components);
+
+ return new_cal;
+}
+
+void calendar_dump(FILE* file, Calendar* cal) {
+ g_return_if_fail(file && cal);
+
+ fprintf(file, "------- Display Name: %s -------\n", cal->displayname);
+ fprintf(file, "URL: %s\n", cal->url);
+ fprintf(file, "CTAG: %s\n", cal->ctag);
+ fprintf(file, "Supported components\n");
+ for (GSList* l = cal->components; l; l = g_slist_next(l)) {
+ Component c = GPOINTER_TO_UINT(l->data);
+ gchar* value = component_to_string(c);
+ fprintf(file, "\t%s\n", value);
+ g_free(value);
+ }
+}
+
+void calendar_free(Calendar* cal) {
+ if (cal) {
+ if (cal->url) {
+ g_free(cal->url);
+ cal->url = NULL;
+ }
+ if (cal->ctag) {
+ g_free(cal->ctag);
+ cal->ctag = NULL;
+ }
+ if (cal->displayname) {
+ g_free(cal->displayname);
+ cal->displayname = NULL;
+ }
+ if (cal->components) {
+ g_slist_free(cal->components);
+ cal->components = NULL;
+ }
+ g_free(cal);
+ cal = NULL;
+ }
+}
+
+void runtime_free(Runtime* runtime) {
+ if (runtime) {
+ if (runtime->username) {
+ g_free(runtime->username);
+ runtime->username = NULL;
+ }
+ if (runtime->password) {
+ g_free(runtime->password);
+ runtime->password = NULL;
+ }
+ if (runtime->url) {
+ g_free(runtime->url);
+ runtime->url = NULL;
+ }
+ if (runtime->etag) {
+ g_free(runtime->etag);
+ runtime->etag = NULL;
+ }
+ if (runtime->component) {
+ g_free(runtime->component);
+ runtime->component = NULL;
+ }
+ if (runtime->hrefs) {
+ slist_free_gchar(runtime->hrefs);
+ runtime->hrefs = NULL;
+ }
+ if (runtime->options) {
+ slist_free_gchar(runtime->options);
+ runtime->options = NULL;
+ }
+ if (runtime->output && runtime->default_executor) {
+ caldav_response_free(*runtime->operation, runtime->output);
+ runtime->output = NULL;
+ }
+ if (runtime->operation) {
+ g_free(runtime->operation);
+ runtime->operation = NULL;
+ }
+ if (runtime->executor) {
+ runtime->executor = NULL;
+ }
+ if (runtime->start) {
+ g_date_time_unref(runtime->start);
+ runtime->start = NULL;
+ }
+ if (runtime->finish) {
+ g_date_time_unref(runtime->finish);
+ runtime->finish = NULL;
+ }
+ g_free(runtime);
+ runtime = NULL;
+ }
+}
+
+guint execute(Runtime* runtime) {
+ g_return_val_if_fail(runtime && runtime->operation, 500);
+
+ switch (*runtime->operation) {
+ case DISCOVER:
+ runtime->executor = execute_discover;
+ break;
+ case ADDOBJECTS:
+ case UPDATEOBJECTS:
+ runtime->executor = execute_add_update;
+ break;
+ case OPTIONSINFO:
+ runtime->executor = execute_options;
+ break;
+ case FREEBUSY:
+ runtime->executor = execute_freebusy;
+ break;
+ default:
+ runtime->executor = execute_default;
+ }
+
+ return runtime->executor(runtime);
+}
+
+gboolean is_component(const gchar* value, Component component) {
+ g_return_val_if_fail(value != NULL, FALSE);
+
+ if (g_strcmp0(value, "VEVENT") == 0 && component == VEVENT)
+ return TRUE;
+ else if (g_strcmp0(value, "VTODO") == 0 && component == VTODO)
+ return TRUE;
+ else if (g_strcmp0(value, "VFREEBUSY") == 0 && component == VFREEBUSY)
+ return TRUE;
+ else if (g_strcmp0(value, "VJOURNAL") == 0 && component == VJOURNAL)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+gchar* component_to_string(Component component) {
+ if (component == VEVENT)
+ return g_strdup("VEVENT");
+ else if (component == VTODO)
+ return g_strdup("VTODO");
+ else if (component == VFREEBUSY)
+ return g_strdup("VFREEBUSY");
+ else if (component == VJOURNAL)
+ return g_strdup("VJOURNAL");
+ else
+ return NULL;
+}
+
+Component string_to_component(const gchar* value) {
+ g_return_val_if_fail(value != NULL, VUNKNOWN);
+
+ if (g_strcmp0(value, "VEVENT") == 0)
+ return VEVENT;
+ else if (g_strcmp0(value, "VTODO") == 0)
+ return VTODO;
+ else if (g_strcmp0(value, "VFREEBUSY") == 0)
+ return VFREEBUSY;
+ else if (g_strcmp0(value, "VJOURNAL") == 0)
+ return VJOURNAL;
+ else
+ return VUNKNOWN;
+}
+
+gchar* status_str(Runtime* runtime) {
+ gchar* str = NULL;
+
+ g_return_val_if_fail(runtime && runtime->output, NULL);
+
+ switch (runtime->output->status) {
+ case 200: str = g_strdup("OK"); break;
+ case 201: str = g_strdup("Created"); break;
+ case 204: str = g_strdup("No Content"); break;
+ case 207: str = g_strdup("Multi-Status"); break;
+ case 400: str = g_strdup("Bad Request"); break;
+ case 401: str = g_strdup("Unauthorized"); break;
+ case 403: str = g_strdup("Forbidden"); break;
+ case 404: str = g_strdup("Not Found"); break;
+ case 405: str = g_strdup("Method Not Allowed"); break;
+ case 406: str = g_strdup("Not Acceptable"); break;
+ case 409: str = g_strdup("Conflict"); break;
+ case 410: str = g_strdup("Gone"); break;
+ case 412: str = g_strdup("Precondition Failed"); break;
+ case 415: str = g_strdup("Unsupported Media Type"); break;
+ case 423: str = g_strdup("Locked"); break;
+ case 424: str = g_strdup("Failed Dependency"); break;
+ case 500: str = g_strdup("Internal Server Error"); break;
+ case 501: str = g_strdup("Not Implemented"); break;
+ case 503: str = g_strdup("Service Unavailable"); break;
+ case 507: str = g_strdup("Insufficient Storage"); break;
+ default: str = g_strdup_printf("%d: Unexpected status", runtime->output->status);
+ }
+
+ return str;
+}
+
+HrefData* href_data_new(const gchar* href, const gchar* data) {
+ g_return_val_if_fail(href != NULL, NULL);
+
+ HrefData* h = g_new0(HrefData, 1);
+ h->href = g_strdup(href);
+ h->data = data ? g_strdup(data) : NULL;
+
+ return h;
+}
+
+void href_data_free(HrefData* href_data) {
+ if (href_data) {
+ if (href_data->href) {
+ g_free(href_data->href);
+ href_data->href = NULL;
+ }
+ if (href_data->data) {
+ g_free(href_data->data);
+ href_data->data = NULL;
+ }
+ g_free(href_data);
+ href_data = NULL;
+ }
+}
+
+gboolean has_option(Runtime* runtime, const gchar* option) {
+ g_return_val_if_fail(runtime && option, FALSE);
+ gboolean has = FALSE;
+
+ gchar* s2 = g_utf8_casefold(option, -1);
+ if (runtime->options) {
+ for (GSList* l = runtime->options; l && ! has; l = g_slist_next(l)) {
+ gchar* s1 = g_utf8_casefold((gchar *) l->data, -1);
+ if (g_strcmp0(s1, s2) == 0) {
+ has = TRUE;
+ }
+ g_free(s1);
+ }
+ }
+ g_free(s2);
+
+ return has;
+}
+
+Runtime* runtime_copy(Runtime* runtime) {
+ Runtime* new = NULL;
+
+ g_return_val_if_fail(runtime != NULL, NULL);
+
+ new = runtime_new();
+ new->username = g_strdup(runtime->username);
+ new->password = g_strdup(runtime->password);
+ new->url = g_strdup(runtime->url);
+ new->debug = runtime->debug;
+ new->operation = g_new0(Operation, 1);
+ *new->operation = *runtime->operation;
+ new->executor = runtime->executor;
+ new->default_executor = runtime->default_executor;
+ new->etag = g_strdup(runtime->etag);
+ new->component = g_strdup(runtime->component);
+ new->hrefs = slist_copy_gchar(runtime->hrefs);
+ new->options = slist_copy_gchar(runtime->options);
+
+ return new;
+}
+
+GSList* slist_copy_gchar(GSList* list) {
+ GSList* new = NULL;
+
+ for (GSList* l = list; l; l = g_slist_next(l)) {
+ new = g_slist_append(new, g_strdup(l->data));
+ }
+
+ return new;
+}
+
+GDateTime* get_date_time_from_string(const gchar* datetime) {
+ GDateTime* dt = NULL;
+ g_return_val_if_fail(datetime != NULL, NULL);
+
+ gchar** dt_part = g_strsplit(datetime, "T", 0);
+ if (!dt_part || dt_part[2] != NULL) {
+ g_strfreev(dt_part);
+ return NULL;
+ }
+
+ gchar** d_part = g_strsplit(dt_part[0], "-", 0);
+ if (!d_part || d_part[3] != NULL) {
+ g_strfreev(dt_part);
+ g_strfreev(d_part);
+ return NULL;
+ }
+
+ gchar** t_part = g_strsplit(dt_part[1], ":", 0);
+ if (!t_part || t_part[3] != NULL) {
+ g_strfreev(dt_part);
+ g_strfreev(t_part);
+ return NULL;
+ }
+
+ g_strfreev(dt_part);
+ char* endptr;
+ dt = g_date_time_new_local(
+ atoi(d_part[0]), atoi(d_part[1]), atoi(d_part[2]),
+ atoi(t_part[0]), atoi(t_part[1]), strtod(t_part[2], &endptr));
+
+ g_strfreev(d_part);
+ g_strfreev(t_part);
+
+ return dt;
+}
projects / caldav.git / blobdiff