libidav/resource.c

/*
 * 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 "crypto.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_path_to_url(sn, 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) {  
    DavResource *res = ucx_mempool_calloc(sn->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->mp->allocator;
    CURL *handle = res->session->handle;
    
    int nlen = 0;
    char *uname = curl_easy_unescape(handle, name.ptr, name.length , &nlen);
    int plen = 0;
    char *upath = curl_easy_unescape(handle, path.ptr, path.length, &plen); 
    
    res->name = sstrdup_a(a, sstrn(uname, nlen)).ptr;
    res->href = sstrdup_a(a, href).ptr;
    res->path = sstrdup_a(a, sstrn(upath, plen)).ptr;
    
    curl_free(uname);
    curl_free(upath);
}

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->mp->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;
    }
    
    UcxKey key = dav_property_key(ns, name);
    sstr_t v = sstrdup_a(res->session->mp->allocator, 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->mp->allocator;
    DavResourceData *data = res->data;
    
    DavProperty *property = dav_session_malloc(
            res->session,
            sizeof(DavProperty));
    property->name = sstrdup_a(a, sstr(name)).ptr;
    property->value = sstrdup_a(a, sstr(value)).ptr;
    
    DavNamespace *namespace = dav_session_malloc(
            res->session,
            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) {
    DavResourceData *data = res->data;
    UcxAllocator *a = res->session->mp->allocator;
    
    DavProperty *property = dav_session_malloc(
            res->session,
            sizeof(DavProperty));
    property->name = sstrdup_a(a, sstr(name)).ptr;
    property->value = NULL;
    
    DavNamespace *namespace = dav_session_malloc(
            res->session,
            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) {
    DavSession *sn = res->session;
    if((sn->flags & DAV_SESSION_ENCRYPT_FILE) == DAV_SESSION_ENCRYPT_FILE) {
        AESEncrypter *enc = aes_encrypter_new(sn->key, stream, read_func);
        DavResourceData *data = res->data;
        data->content = enc;
        data->read = (dav_read_func)aes_read;
        data->length = 0;
        dav_set_property_ns(
                res,
                "http://www.uap-core.de/",
                "crypto-key",
                sn->key->name);
    } else {
        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);
    }
    
    util_set_url(sn, res->path);
    
    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(sn->handle, rqbuf, rpbuf);
    int status = 0;
    curl_easy_getinfo (sn->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, NULL, 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;
    
    util_set_url(sn, res->path);;
    
    // store content
    if(data->content) {
        CURLcode ret = do_put_request(sn->handle, data->content, data->read, data->length);
        int status = 0;
        curl_easy_getinfo(sn->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(sn->handle, request, response);
        int status = 0;
        curl_easy_getinfo (sn->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) { 
    CURL *handle = res->session->handle;
    util_set_url(res->session, res->path);
    
    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) {
    CURL *handle = res->session->handle;
    util_set_url(res->session, res->path);
    
    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;
    util_set_url(res->session, res->path);
    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, NULL, 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;
    CURL *handle = sn->handle;
    util_set_url(sn, res->path);
    
    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;
    }
}