src/server/webdav/requestparser.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2019 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 <cx/string.h>
#include <cx/utils.h>
#include <cx/map.h>
#include <cx/hash_map.h>

#include "requestparser.h"
#include "webdav.h"

#include "../util/pool.h"

#define xstreq(a, b) !strcmp((const char*)a, (const char*)b)

void proplist_free(pool_handle_t *pool, WebdavPList *list) {
    while(list) {
        WebdavPList *next = list->next;
        pool_free(pool, list);
        list = next;
    }
}

WebdavProperty* prop_create(
        pool_handle_t *pool,
        WSNamespace *ns,
        const char *name)
{
    WebdavProperty *prop = pool_malloc(pool, sizeof(WebdavProperty));
    memset(prop, 0, sizeof(WebdavProperty));
    prop->lang = NULL;
    prop->name = (char*)name;
    prop->namespace = ns;
    return prop;
}

static int parse_prop(
        Session *sn,
        xmlNode *node,
        CxMap *propmap,
        WebdavPList **plist_begin,
        WebdavPList **plist_end,
        size_t *propcount,
        int proppatch,
        int *error)
{
    xmlNode *pnode = node->children;
    for(;pnode;pnode=pnode->next) {
        if(pnode->type != XML_ELEMENT_NODE) {
            continue;
        }
        
        const char* ns = (const char*)pnode->ns->href;
        const char* name = (const char*)pnode->name;
        
        // check for prop duplicates
        CxHashKey k = webdav_property_key((const char*)ns, (const char*)name);
        if(!k.data) {
            *error = proppatch ? PROPPATCH_PARSER_OOM : PROPFIND_PARSER_OOM;
            return 1;
        }
        void *c = cxMapGet(propmap, k);
        if(!c) {
            if(cxMapPut(propmap, k, (void*)1)) {
                *error = proppatch ? PROPPATCH_PARSER_OOM : PROPFIND_PARSER_OOM;
            }
            
            // no duplicate
            // create property elment and add it to the list
            WebdavProperty *prop = prop_create(sn->pool, pnode->ns, name);
            if(proppatch) {
                prop->value.node = pnode->children;
                prop->vtype = WS_VALUE_XML_NODE;
            }
            if(prop) {
                if(webdav_plist_add(sn->pool, plist_begin, plist_end, prop)) {
                    *error = proppatch ?
                        PROPPATCH_PARSER_OOM : PROPFIND_PARSER_OOM;
                }
                (*propcount)++;
            } else {
                *error = proppatch ? PROPPATCH_PARSER_OOM : PROPFIND_PARSER_OOM;
            }
        } else if(proppatch) {
            *error = PROPPATCH_PARSER_DUPLICATE;
        }
        
        free((void*)k.data);
        if(*error) {
            return 1;
        }
    }
    return 0;
}

WebdavPropfindRequest* propfind_parse(
        Session *sn,
        Request *rq,
        const char *buf,
        size_t buflen,
        int *error)
{
    xmlDoc *doc = xmlReadMemory(buf, buflen, NULL, NULL, 0);
    if(!doc) {
        *error = PROPFIND_PARSER_INVALID_REQUEST;
        return NULL;
    }
    
    // ret vars
    *error = 0;
    
    WSBool allprop = FALSE;
    WSBool propname = FALSE;
    WebdavPList *plist_begin = NULL;
    WebdavPList *plist_end = NULL;
    size_t propcount = 0;
    int depth = webdav_getdepth(rq);
    
    xmlNode *root = xmlDocGetRootElement(doc);
    xmlNode *node = root->children;
    
    // check if the root element is DAV:propfind
    if(
            !(root->ns
            && xstreq(root->ns->href, "DAV:")
            && xstreq(root->name, "propfind")))
    {
        *error = PROPFIND_PARSER_NO_PROPFIND;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    CxAllocator *a = pool_allocator(sn->pool);
    CxMap *propmap = cxHashMapCreate(a, CX_STORE_POINTERS, 32); // value: intptr_t
    if(!propmap) {
        *error = PROPFIND_PARSER_OOM;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    int ret = 0;
    while(node && !ret) {
        if(node->type == XML_ELEMENT_NODE) {
            if(xstreq(node->ns->href, "DAV:") && !allprop && !propname) {
                // a propfind request can contain a prop element
                // with specified properties or the allprop or propname
                // element
                if(xstreq(node->name, "prop")) {
                    ret = parse_prop(
                            sn,
                            node,
                            propmap,
                            &plist_begin,
                            &plist_end,
                            &propcount,
                            0, // proppatch = false
                            error);
                } else if(xstreq(node->name, "allprop")) {
                    allprop = TRUE;
                } else if(xstreq(node->name, "propname")) {
                    propname = TRUE;
                }
            }
        }
        node = node->next;
    }
    
    cxMapDestroy(propmap); // no allocated content must be freed
    
    if(ret) {
        // parse_prop failed
        // in this case, error is already set
        xmlFreeDoc(doc);
        return NULL;
    }
    
    if(!allprop && !propname && propcount == 0) {
        *error = PROPFIND_PARSER_NO_PROPERTIES;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    WebdavPropfindRequest *request = pool_malloc(
            sn->pool,
            sizeof(WebdavPropfindRequest));
    if(!request) {
        *error = PROPFIND_PARSER_OOM;
        xmlFreeDoc(doc);
        return NULL;
    }
    request->sn = sn;
    request->rq = rq;
    request->properties = NULL;
    request->propcount = 0;
    request->depth = depth;
    request->doc = doc;
    if(allprop) {
        request->allprop = TRUE;
        request->propname = FALSE; // we cannot have allprop and propname
    } else if(propname) {
        request->allprop = FALSE;
        request->propname = TRUE;
    } else {
        request->allprop = FALSE;
        request->propname = FALSE;
        request->properties = plist_begin;
        request->propcount = propcount;
    }
    
    if(!request->properties && plist_begin) {
        proplist_free(sn->pool, plist_begin);
    }
    return request;
}

WebdavProppatchRequest* proppatch_parse(
        Session *sn,
        Request *rq,
        const char *buf,
        size_t buflen,
        int *error)
{
    return webdav_parse_set(
            sn, rq, buf, buflen, "DAV:", "propertyupdate", TRUE, error);
}

static xmlNode* find_child(xmlNode *node, const char *name) {
    xmlNode *c = node->children;
    while(c) {
        if(c->ns) {
            if(xstreq(c->ns->href, "DAV:") && xstreq(c->name, name)) {
                return c;
            }
        }
        c = c->next;
    }
    return NULL;
}

WebdavProppatchRequest* webdav_parse_set(
        Session *sn,
        Request *rq,
        const char *buf,
        size_t buflen,
        const char *rootns,
        const char *rootname,
        WSBool allowremove,
        int *error)
{
    xmlDoc *doc = xmlReadMemory(buf, buflen, NULL, NULL, 0);
    if(!doc) {
        *error = PROPPATCH_PARSER_INVALID_REQUEST;
        return NULL;
    }
    
    xmlNode *root = xmlDocGetRootElement(doc);
    xmlNode *node = root->children;
    
    // check if the root element is correct
    if(
            !(root->ns
            && xstreq(root->ns->href, rootns)
            && xstreq(root->name, rootname)))
    {
        *error = PROPPATCH_PARSER_NO_PROPERTYUPDATE;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    // ret vars
    *error = 0;
    
    CxAllocator *a = pool_allocator(sn->pool);
    // map for duplicate checking
    // value type: intptr_t
    CxMap *propmap = cxHashMapCreate(a, CX_STORE_POINTERS, 32);
    if(!propmap) {
        *error = PROPPATCH_PARSER_OOM;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    WebdavPList *set_begin = NULL;
    WebdavPList *set_end = NULL;
    WebdavPList *remove_begin = NULL;
    WebdavPList *remove_end = NULL;
    size_t set_count = 0;
    size_t remove_count = 0;
    
    int ret = 0;
    while(node && !ret) {
        if(node->type == XML_ELEMENT_NODE) {
            if(node->ns && xstreq(node->ns->href, "DAV:")) {
                // a propfind request can contain a prop element
                // with specified properties or the allprop or propname
                // element
                if(xstreq(node->name, "set")) {
                    xmlNode *prop = find_child(node, "prop");
                    ret = parse_prop(
                            sn,
                            prop,
                            propmap,
                            &set_begin,
                            &set_end,
                            &set_count,
                            TRUE, // proppatch = true
                            error);
                } else if(xstreq(node->name, "remove")) {
                    if(!allowremove) {
                        *error = PROPPATCH_PARSER_INVALID_REQUEST;
                        ret = 1;
                        break;
                    }
                    xmlNode *prop = find_child(node, "prop");
                    ret = parse_prop(
                            sn,
                            prop,
                            propmap,
                            &remove_begin,
                            &remove_end,
                            &remove_count,
                            TRUE, // proppatch = true
                            error);
                }
                    
            }
        }
        node = node->next;
    }
    
    cxMapDestroy(propmap); // allocated content must not be freed
    
    if(set_count + remove_count == 0) {
        *error = PROPPATCH_PARSER_NO_PROPERTIES;
        ret = 1;
    }
    
    if(ret) {
        xmlFreeDoc(doc);
        return NULL;
    }
    
    WebdavProppatchRequest *request = pool_malloc(
            sn->pool,
            sizeof(WebdavProppatchRequest));
    if(!request) {
        *error = PROPPATCH_PARSER_OOM;
        xmlFreeDoc(doc);
        return NULL;
    }
    request->sn = sn;
    request->rq = rq;
    request->doc = doc;
    request->set = set_begin;
    request->setcount = set_count;
    request->remove = remove_begin;
    request->removecount = remove_count;
    return request;
}

WebdavLockRequest* lock_parse(
        Session *sn,
        Request *rq,
        const char *buf,
        size_t buflen,
        int *error)
{
    xmlDoc *doc = xmlReadMemory(buf, buflen, NULL, NULL, 0);
    if(!doc) {
        *error = LOCK_PARSER_INVALID_REQUEST;
        return NULL;
    }
    
    xmlNode *root = xmlDocGetRootElement(doc);
    xmlNode *node = root->children;
    
    // check if the root element is correct
    if(
            !(root->ns
            && xstreq(root->ns->href, "DAV:")
            && xstreq(root->name, "lockinfo")))
    {
        *error = LOCK_PARSER_NO_LOCKINFO;
        xmlFreeDoc(doc);
        return NULL;
    }
    
    WebdavLockScope lockscope = WEBDAV_LOCK_SCOPE_UNKNOWN;
    WebdavLockType locktype = WEBDAV_LOCK_TYPE_UNKNOWN;
    WSXmlNode *owner = NULL;
    
    int ret = 0;
    while(node && !ret) {
        if(
                node->type == XML_ELEMENT_NODE
                && node->ns
                && xstreq(node->ns->href, "DAV:"))
        {
            char *name = (char*)node->name;
            if(xstreq(name, "lockscope")) {
                xmlNode *s = node->children;
                while(s) {
                    if(
                            s->type == XML_ELEMENT_NODE
                            && s->ns
                            && xstreq(s->ns->href, "DAV:"))
                    {
                        if(xstreq(s->name, "exclusive")) {
                            lockscope = WEBDAV_LOCK_EXCLUSIVE;
                        } else if(xstreq(s->name, "shared")) {
                            lockscope = WEBDAV_LOCK_SHARED;
                        } else {
                            // don't ignore unknown lockscope
                            *error = LOCK_PARSER_UNKNOWN_ELEMENT;
                            ret = 1;
                            break;
                        }
                    }
                    s = s->next;
                }
            } else if(xstreq(name, "locktype")) {
                xmlNode *t = node->children;
                while(t) {
                    if(
                            t->type == XML_ELEMENT_NODE
                            && t->ns
                            && xstreq(t->ns->href, "DAV:"))
                    {
                        if(xstreq(t->name, "write")) {
                            locktype = WEBDAV_LOCK_WRITE;
                        } else {
                            *error = LOCK_PARSER_UNKNOWN_ELEMENT;
                            ret = 1;
                            break;
                        }
                    }
                    t = t->next;
                }
            } else if(xstreq(name, "owner")) {
                owner = node->children;
            }
        }
        node = node->next;
    }
    
    if(ret) {
        xmlFreeDoc(doc);
        return NULL;
    }
    
    WebdavLockRequest *request = pool_malloc(
            sn->pool,
            sizeof(WebdavLockRequest));
    if(!request) {
        *error = LOCK_PARSER_OOM;
        xmlFreeDoc(doc);
        return NULL;
    }
    request->sn = sn;
    request->rq = rq;
    request->doc = doc;
    
    if(locktype == WEBDAV_LOCK_TYPE_UNKNOWN) {
        locktype = WEBDAV_LOCK_WRITE;
    }
    if(lockscope == WEBDAV_LOCK_SCOPE_UNKNOWN) {
        lockscope = WEBDAV_LOCK_EXCLUSIVE;
    }
    request->scope = lockscope;
    request->type = locktype;
    request->owner = owner;
    return request;
}