--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/libidav/resource.c Mon Aug 26 14:42:09 2013 +0200
@@ -0,0 +1,498 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2013 Olaf Wintermann. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/tree.h>
+
+#include "utils.h"
+#include "methods.h"
+#include "davql.h"
+#include "ucx/buffer.h"
+#include "ucx/utils.h"
+
+#include "resource.h"
+
+#define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
+
+DavResource* dav_resource_new(DavSession *sn, char *path) {
+ char *url = util_concat_path(sn->base_url, path);
+ char *href = util_url_path(url);
+ DavResource *res = dav_resource_new_href(sn, href);
+ free(url);
+ return res;
+}
+
+
+DavResource* dav_resource_new_href(DavSession *sn, char *href) {
+ UcxMempool *mp = sn->mp;
+ UcxAllocator *a = sn->allocator;
+
+ DavResource *res = ucx_mempool_calloc(mp, 1, sizeof(DavResource));
+ res->session = sn;
+
+ // set name, path and href
+ resource_set_info(res, href);
+
+ // initialize resource data
+ res->data = resource_data_new(sn);
+
+ return res;
+}
+
+void resource_set_info(DavResource *res, char *href_str) {
+ char *url_str = NULL;
+ curl_easy_getinfo(res->session->handle, CURLINFO_EFFECTIVE_URL, &url_str);
+ sstr_t name = sstr(util_resource_name(href_str));
+ sstr_t href = sstr(href_str);
+
+ sstr_t base_href = sstr(util_url_path(res->session->base_url));
+ sstr_t path = sstrsubs(href, base_href.length - 1);
+
+ UcxAllocator *a = res->session->allocator;
+ res->name = sstrdup_a(a, name).ptr;
+ res->href = sstrdup_a(a, href).ptr;
+ res->path = sstrdup_a(a, path).ptr;
+}
+
+DavResourceData* resource_data_new(DavSession *sn) {
+ DavResourceData *data = ucx_mempool_malloc(
+ sn->mp,
+ sizeof(DavResourceData));
+ if(!data) {
+ return NULL;
+ }
+ data->properties = ucx_map_new_a(sn->allocator, 32);
+ data->set = NULL;
+ data->remove = NULL;
+ data->content = NULL;
+ data->read = NULL;
+ data->length = 0;
+ return data;
+}
+
+void resource_add_property(DavResource *res, char *ns, char *name, char *val) {
+ if(!val) {
+ return;
+ }
+ UcxAllocator *a = res->session->allocator;
+
+ UcxKey key = dav_property_key(ns, name);
+ sstr_t v = sstrdup_a(a, sstr(val));
+ ucx_map_put(((DavResourceData*)res->data)->properties, key, v.ptr);
+ free(key.data);
+}
+
+char* resource_get_property(DavResource *res, char *ns, char *name) {
+ UcxKey key = dav_property_key(ns, name);
+ DavResourceData *data = (DavResourceData*)res->data;
+ char *property = ucx_map_get(data->properties, key);
+ free(key.data);
+ return property;
+}
+
+UcxKey dav_property_key(char *ns, char *name) {
+ sstr_t ns_str = sstr(ns);
+ sstr_t name_str = sstr(name);
+
+ sstr_t key;
+ key.length = ns_str.length + name_str.length + 1;
+ key.ptr = malloc(key.length + 1);
+ key = sstrncat(key, 3, ns_str, S(" "), name_str);
+
+ return ucx_key(key.ptr, key.length);
+}
+
+
+
+
+void resource_add_child(DavResource *parent, DavResource *child) {
+ child->next = NULL;
+ if(parent->children) {
+ DavResource *last = parent->children;
+ while(last->next) {
+ last = last->next;
+ }
+ last->next = child;
+ child->prev = last;
+ } else {
+ child->prev = NULL;
+ parent->children = child;
+ }
+ child->parent = parent;
+}
+
+char* dav_get_property(DavResource *res, char *name) {
+ char *pns;
+ char *pname;
+ dav_get_property_namespace(res->session->context, name, &pns, &pname);
+ return dav_get_property_ns(res, pns, pname);
+}
+
+char* dav_get_property_ns(DavResource *res, char *ns, char *name) {
+ char *property = resource_get_property(res, ns, name);
+ DavResourceData *data = res->data;
+ // resource_get_property only returns persistent properties
+ // check the remove and set list
+ if(property) {
+ // if the property is in the remove list, we return NULL
+ UCX_FOREACH(elm, data->remove) {
+ DavProperty *p = elm->data;
+ if(!strcmp(p->name, name) && !strcmp(p->ns->name, ns)) {
+ return NULL;
+ }
+ }
+ }
+ // the set list contains property updates
+ // we return an updated property if possible
+ UCX_FOREACH(elm, data->set) {
+ DavProperty *p = elm->data;
+ if(!strcmp(p->name, name) && !strcmp(p->ns->name, ns)) {
+ return p->value;
+ }
+ }
+ // no property update
+ return property;
+}
+
+void dav_set_property(DavResource *res, char *name, char *value) {
+ char *pns;
+ char *pname;
+ dav_get_property_namespace(res->session->context, name, &pns, &pname);
+ dav_set_property_ns(res, pns, pname, value);
+}
+
+void dav_set_property_ns(DavResource *res, char *ns, char *name, char *value) {
+ UcxAllocator *a = res->session->allocator;
+ DavResourceData *data = res->data;
+
+ DavProperty *property = a->malloc(a->pool, sizeof(DavProperty));
+ property->name = sstrdup_a(a, sstr(name)).ptr;
+ property->value = sstrdup_a(a, sstr(value)).ptr;
+ DavNamespace *namespace = a->malloc(a->pool, sizeof(DavNamespace));
+ namespace->prefix = NULL;
+ namespace->name = sstrdup_a(a, sstr(ns)).ptr;
+ property->ns = namespace;
+
+ data->set = ucx_list_append_a(a, data->set, property);
+}
+
+void dav_remove_property(DavResource *res, char *name) {
+ char *pns;
+ char *pname;
+ dav_get_property_namespace(res->session->context, name, &pns, &pname);
+ dav_remove_property_ns(res, pns, pname);
+}
+
+void dav_remove_property_ns(DavResource *res, char *ns, char *name) {
+ UcxAllocator *a = res->session->allocator;
+ DavResourceData *data = res->data;
+
+ DavProperty *property = a->malloc(a->pool, sizeof(DavProperty));
+ property->name = sstrdup_a(a, sstr(name)).ptr;
+ property->value = NULL;
+ DavNamespace *namespace = a->malloc(a->pool, sizeof(DavNamespace));
+ namespace->prefix = NULL;
+ namespace->name = sstrdup_a(a, sstr(ns)).ptr;
+ property->ns = namespace;
+
+ data->remove = ucx_list_append_a(a, data->remove, property);
+}
+
+
+void dav_set_content(DavResource *res, void *stream, dav_read_func read_func) {
+ DavResourceData *data = res->data;
+ data->content = stream;
+ data->read = read_func;
+ data->length = 0;
+}
+
+void dav_set_content_data(DavResource *res, char *content, size_t length) {
+ DavSession *sn = res->session;
+ DavResourceData *data = res->data;
+ data->content = content;
+ data->read = NULL;
+ data->length = length;
+}
+
+
+int dav_load(DavResource *res) {
+ DavSession *sn = res->session;
+ DavResourceData *data = res->data;
+ // clean map
+ UcxKey key;
+ void *value;
+ UcxMapIterator i = ucx_map_iterator(data->properties);
+ UCX_MAP_FOREACH(key, value, i) {
+ ucx_map_remove(data->properties, key);
+ }
+
+ char *url = util_concat_path(sn->base_url, res->path);
+
+ CURL *handle = sn->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+
+ UcxBuffer *rqbuf = create_allprop_propfind_request();
+ UcxBuffer *rpbuf = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
+
+ //fwrite(rpbuf->space, 1, rpbuf->size, stdout);
+ //printf("\n");
+
+ CURLcode ret = do_propfind_request(handle, rqbuf, rpbuf);
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK) {
+ //printf("response\n%s\n", rpbuf->space);
+ // TODO: use parse_propfind_response()
+ xmlDoc *doc = xmlReadMemory(rpbuf->space, rpbuf->size, url, NULL, 0);
+ if(!doc) {
+ return 1;
+ }
+
+ xmlNode *xml_root = xmlDocGetRootElement(doc);
+ xmlNode *node = xml_root->children;
+ while(node) {
+ if(node->type == XML_ELEMENT_NODE) {
+ if(xstreq(node->name, "response")) {
+ parse_response_tag(res, node, NULL, 0);
+ }
+ }
+ node = node->next;
+ }
+
+ set_davprops(res);
+ } else {
+ session_set_error(sn, ret, status);
+ }
+ return 0;
+}
+
+int dav_store(DavResource *res) {
+ DavSession *sn = res->session;
+ DavResourceData *data = res->data;
+
+ char *url = util_concat_path(sn->base_url, res->path);
+ CURL *handle = res->session->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+
+ // store content
+ if(data->content) {
+ CURLcode ret = do_put_request(handle, data->content, data->read, data->length);
+ int status = 0;
+ curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ res->session->error = 0;
+ // cleanup node data
+ if(!data->read) {
+ ucx_mempool_free(sn->mp, data->content);
+ }
+ data->content = NULL;
+ data->read = NULL;
+ data->length = 0;
+ } else {
+ session_set_error(sn, ret, status);
+ return 1;
+ }
+ }
+
+ // store properties
+ if(data->set || data->remove) {
+ UcxBuffer *request = create_proppatch_request(data);
+ UcxBuffer *response = ucx_buffer_new(NULL, 1024, UCX_BUFFER_AUTOEXTEND);
+
+ CURLcode ret = do_proppatch_request(handle, request, response);
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && status == 207) {
+ //printf("%s\n", response->space);
+ // TODO: parse response
+ // TODO: cleanup node data correctly
+ data->set = NULL;
+ data->remove = NULL;
+ } else {
+ session_set_error(sn, ret, status);
+ return 1;
+ }
+ }
+ sn->error = DAV_OK;
+ return 0;
+}
+
+int dav_get_content(DavResource *res, void *stream, dav_write_func write_fnc) {
+ char *url = util_concat_path(res->session->base_url, res->path);
+ CURL *handle = res->session->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+
+ curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, NULL);
+ curl_easy_setopt(handle, CURLOPT_PUT, 0L);
+ curl_easy_setopt(handle, CURLOPT_UPLOAD, 0L);
+
+ curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_fnc);
+ curl_easy_setopt(handle, CURLOPT_WRITEDATA, stream);
+
+ CURLcode ret = curl_easy_perform(handle);
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ res->session->error = DAV_OK;
+ return 0;
+ } else {
+ session_set_error(res->session, ret, status);
+ return 1;
+ }
+}
+
+DavResource* dav_create_child(DavResource *parent, char *name) {
+ // TODO
+ return NULL;
+}
+
+int dav_delete(DavResource *res) {
+ char *url = util_concat_path(res->session->base_url, res->path);
+ CURL *handle = res->session->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+
+ UcxBuffer *response = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
+ CURLcode ret = do_delete_request(handle, response);
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ res->session->error = DAV_OK;
+
+ // TODO: parse response
+ // TODO: free res
+
+ return 0;
+ } else {
+ session_set_error(res->session, ret, status);
+ return 1;
+ }
+}
+
+int dav_create(DavResource *res) {
+ char *url = util_concat_path(res->session->base_url, res->path);
+ char *parent = util_parent_path(res->path);
+
+ DavSession *sn = res->session;
+ DavResource *parent_res = dav_get(sn, parent, NULL);
+ if(!parent_res && sn->error == DAV_NOT_FOUND) {
+ parent_res = dav_resource_new(sn, parent);
+ parent_res->iscollection = 1;
+ int r = dav_create(parent_res);
+ if(r) {
+ free(parent);
+ return r;
+ }
+ } else if(parent_res && !parent_res->iscollection) {
+ sn->error = DAV_FORBIDDEN;
+ return 1;
+ } else if(sn->error != DAV_OK) {
+ return 1;
+ }
+
+ CURL *handle = res->session->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+ free(parent);
+
+ // create new collection or do an empty put request
+ CURLcode ret;
+ if(res->iscollection) {
+ ret = do_mkcol_request(handle);
+ } else {
+ ret = do_put_request(handle, "", NULL, 0);
+ }
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ res->session->error = DAV_OK;
+ } else {
+ session_set_error(res->session, ret, status);
+ return 1;
+ }
+
+ // do an minimal propfind request
+ UcxBuffer *rqbuf = create_propfind_request(NULL);
+ UcxBuffer *rpbuf = ucx_buffer_new(NULL, 4096, UCX_BUFFER_AUTOEXTEND);
+
+ //fwrite(rpbuf->space, 1, rpbuf->size, stdout);
+ //printf("\n");
+
+ ret = do_propfind_request(handle, rqbuf, rpbuf);
+ status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ //printf("response\n%s\n", rpbuf->space);
+ // TODO: use parse_propfind_response()
+ xmlDoc *doc = xmlReadMemory(rpbuf->space, rpbuf->size, url, NULL, 0);
+ if(!doc) {
+ return 1;
+ }
+
+ xmlNode *xml_root = xmlDocGetRootElement(doc);
+ xmlNode *node = xml_root->children;
+ while(node) {
+ if(node->type == XML_ELEMENT_NODE) {
+ if(xstreq(node->name, "response")) {
+ parse_response_tag(res, node, NULL, 0);
+ }
+ }
+ node = node->next;
+ }
+
+ set_davprops(res);
+ return 0;
+ } else {
+ session_set_error(sn, ret, status);
+ return 1;
+ }
+}
+
+int dav_exists(DavResource *res) {
+ DavSession *sn = res->session;
+ char *url = util_concat_path(sn->base_url, res->path);
+ CURL *handle = sn->handle;
+ curl_easy_setopt(handle, CURLOPT_URL, url);
+ free(url);
+
+ CURLcode ret = do_head_request(handle);
+ int status = 0;
+ curl_easy_getinfo (handle, CURLINFO_RESPONSE_CODE, &status);
+ if(ret == CURLE_OK && (status >= 200 && status < 300)) {
+ return 1;
+ } else {
+ session_set_error(sn, ret, status);
+ return 0;
+ }
+}