Mercurial > hg > webserver / file revision

/*
 * 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 <errno.h>

#include <cx/list.h>

#include "../daemon/session.h"
#include "../util/pblock.h"

#include "operation.h"

#define WEBDAV_PATH_MAX 8192


size_t webdav_num_backends(WebdavBackend *dav) {
    size_t count = 0;
    while(dav) {
        count++;
        dav = dav->next;
    }
    return count;
}

/****************************************************************************
 * 
 *                         PROPFIND OPERATION
 * 
 ****************************************************************************/

WebdavOperation* webdav_create_propfind_operation(
        Session *sn,
        Request *rq,
        WebdavBackend *dav,
        WebdavPList *reqprops,
        WebdavPropfindRequestList *requests,
        WebdavResponse *response)
{
    WebdavOperation *op = pool_malloc(sn->pool, sizeof(WebdavOperation));
    ZERO(op, sizeof(WebdavOperation));
    op->dav = dav;
    op->sn = sn;
    op->rq = rq;
    op->reqprops = reqprops;
    op->requests = requests;
    op->response = response;
    op->response_close = webdav_op_propfiond_close_resource;
    response->op = op;
    
    return op;
}

int webdav_op_propfind_begin(
        WebdavOperation *op,
        const char *href,
        VFS_DIR parent,
        struct stat *s)
{
    // create WebdavResource object for requested resource
    WebdavResource *resource = op->response->addresource(op->response, href);
    if(!resource) {
        return REQ_ABORTED;
    }
    
    // store data that we need when the resource will be closed
    op->stat = s;
    op->parent = parent;
    
    // get first propfind object
    WebdavPropfindRequest *propfind = op->requests->propfind;
    
    // execute propfind_do of the first backend for the first resource
    int ret = REQ_PROCEED;
    if(op->dav->propfind_do(propfind, op->response, NULL, resource, s)) {
        ret = REQ_ABORTED;
    } else {
        // propfind_do successful, close resource if needed
        // closing the resource will execute propfind_do of all remaining
        // backends
        if(!resource->isclosed) {
            ret = resource->close(resource);
        }
    }
    
    return ret;
}

typedef struct PathSearchElm {
    char   *href;
    char   *path;
    size_t hreflen;
    size_t pathlen;
    struct PathSearchElm *next;
} PathSearchElm;

/*
 * concats base + / + elm
 * if baseinit is true, only elm is copied
 */
static int path_buf_concat(
        pool_handle_t *pool,
        char **buf,
        size_t * restrict len,
        WSBool * restrict baseinit,
        const char *base,
        size_t baselen,
        const char *elm,
        size_t elmlen)
{
    if(base[baselen-1] == '/') {
        baselen--;
    }
    
    size_t newlen = baselen + elmlen + 1;
    if(newlen > WEBDAV_PATH_MAX) {
        log_ereport(LOG_FAILURE, "webdav: maximal path length exceeded");
        return 1;
    }
    
    // check if new path + terminator fits in the buffer
    if(newlen + 1 > *len) {
        *len = newlen + 128;
        char *newbuf = pool_realloc(pool, *buf, newlen);
        if(newbuf) {
            log_ereport(LOG_FAILURE, "webdav: path memory allocation failed");
            return 1;
        }
        *baseinit = FALSE;
        
        *buf = newbuf;
    }
    
    // if baseinit is true, the parent is already in the buffer
    // and we don't need to memcpy it again
    if(!(*baseinit)) {
        memcpy(*buf, base, baselen);
        (*buf)[baselen] = '/';
        *baseinit = TRUE;
    }
    // copy child and terminate string
    memcpy((*buf) + baselen + 1, elm, elmlen);
    (*buf)[newlen] = '\0';
    
    return 0;
}

static int propfind_child_cb(
        VFSContext *vfs,
        const char *href,
        const char *path,
        VFSDir *parent,
        struct stat *s,
        void *op)
{
    return webdav_op_propfind_begin(op, href, parent, s);
}

int webdav_op_propfind_children(
        WebdavOperation *op,
        VFSContext *vfs,
        const char *href,
        const char *path)
{
    WebdavPropfindRequest *request = op->requests->propfind;
    return webdav_op_iterate_children(
            vfs, request->depth, href, path, propfind_child_cb, op);
}

int webdav_op_propfiond_close_resource(
        WebdavOperation *op,
        WebdavResource *resource)
{
    // start with second backend and request, because
    // the first one was already called by webdav_op_propfind_begin
    WebdavBackend *dav = op->dav->next;
    WebdavPropfindRequestList *request = op->requests->next;
    
    // call propfind_do of all remaining backends
    int ret = REQ_PROCEED;
    while(dav && request) {
        if(dav->propfind_do(
                request->propfind,
                op->response,
                op->parent,
                resource,
                op->stat))
        {
            ret = REQ_ABORTED;
        }
        
        dav = dav->next;
        request = request->next;
    }
    return ret;
}

/*
 * Executes propfind_finish for each Backend
 */
int webdav_op_propfind_finish(WebdavOperation *op) {
    WebdavBackend *dav = op->dav;
    WebdavPropfindRequestList *requests = op->requests;
    
    int ret = REQ_PROCEED;
    while(dav && requests) {
        if(dav->propfind_finish(requests->propfind)) {
            ret = REQ_ABORTED;
        }
        
        dav = dav->next;
        requests = requests->next;
    }
    return ret;
}

/****************************************************************************
 * 
 *                         PROPPATCH OPERATION
 * 
 ****************************************************************************/

WebdavOperation* webdav_create_proppatch_operation(
        Session *sn,
        Request *rq,
        WebdavBackend *dav,
        WebdavProppatchRequest *proppatch,
        WebdavResponse *response)
{
    WebdavOperation *op = pool_malloc(sn->pool, sizeof(WebdavOperation));
    ZERO(op, sizeof(WebdavOperation));
    op->dav = dav;
    op->sn = sn;
    op->rq = rq;
    op->reqprops = NULL;
    op->response = response;
    op->proppatch = proppatch;
    op->response_close = webdav_op_proppatch_close_resource;
    response->op = op;
    
    return op;
}



int webdav_op_proppatch(
        WebdavOperation *op,
        const char *href,
        const char *path)
{
    WebdavProppatchRequest *orig_request = op->proppatch;
    CxAllocator *a = pool_allocator(op->sn->pool);
    
    // create WebdavResource object for the requested resource
    WebdavResource *resource = op->response->addresource(op->response, href);
    if(!resource) {
        return REQ_ABORTED;
    }
    
    // check ACL
    if(acl_evaluate(op->sn, op->rq, ACL_WRITE_XATTR)) {
        // ACL check failed, either unauthorized or forbidden
        // acl_evaluate() sets the http status code and may add
        // response headers for authentication
        if(op->rq->status_num == PROTOCOL_UNAUTHORIZED) {
            return REQ_ABORTED; // return here to send an authenticate response
        }
        
        // send multistatus response with status code 403 for each property
        log_ereport(LOG_VERBOSE, "webdav-proppatch: access forbidden");
        int ret = REQ_PROCEED;
        WebdavPList *plist = op->proppatch->set;
        for(int i=0;i<2;i++) {
            while(plist) {
                if(resource->addproperty(resource, plist->property, PROTOCOL_FORBIDDEN)) {
                    ret = REQ_ABORTED;
                    break; // OOM
                }
                plist = plist->next;
            }
            plist = op->proppatch->remove;
        }
        
        if(resource->close(resource)) {
            ret = REQ_ABORTED; // OOM
        }
        return ret;
    }
    
    VFSContext *ctx = NULL;
    VFSFile *file = NULL;
    
    // requests for each backends
    WebdavProppatchRequest **requests = pool_calloc(
            op->sn->pool,
            webdav_num_backends(op->dav),
            sizeof(WebdavProppatchRequest*));
    if(requests == NULL) {
        return REQ_ABORTED;
    }
    
    WebdavPList *prev_set = orig_request->set;
    WebdavPList *prev_remove = orig_request->remove;
    size_t set_count = orig_request->setcount;
    size_t remove_count = orig_request->removecount;
    
    int ret = REQ_PROCEED;
    
    // iterate backends and execute proppatch_do
    WebdavBackend *dav = op->dav;
    size_t numrequests = 0;
    while(dav) {
        WebdavPList *set = webdav_plist_clone_s(
                op->sn->pool,
                prev_set,
                &set_count);
        WebdavPList *remove = webdav_plist_clone_s(
                op->sn->pool,
                prev_remove,
                &remove_count);
        if((prev_set && !set) || (prev_remove && !remove)) {
            // clone failed, OOM
            ret = REQ_ABORTED;
            break;
        }
        
        // create new WebdavProppatchRequest object for this backend
        WebdavProppatchRequest *req = pool_malloc(
                op->sn->pool,
                sizeof(WebdavProppatchRequest));
        memcpy(req, orig_request, sizeof(WebdavProppatchRequest));
        req->dav = dav;
        req->set = orig_request->set;
        req->setcount = orig_request->setcount;
        req->remove = orig_request->remove;
        req->removecount = orig_request->removecount;
        req->userdata = NULL;
        
        // check if we need to open the file because the backend wants it
        if(!file && (dav->settings & WS_WEBDAV_PROPPATCH_USE_VFS)
                         == WS_WEBDAV_PROPPATCH_USE_VFS)
        {
            ctx = vfs_request_context(op->sn, op->rq);
            if(!ctx) {
                ret = REQ_ABORTED;
                break;
            }
            
            file = vfs_open(ctx, path, O_RDONLY);
            if(!file) {
                protocol_status(
                        op->sn,
                        op->rq,
                        util_errno2status(ctx->vfs_errno),
                        NULL);
                ret = REQ_ABORTED;
            }
        }
        
        // execute proppatch_do
        if(dav->proppatch_do(req, resource, file, &set, &remove)) {
            // return later, because we need do execute proppatch_finish
            // for all successfully called backends
            ret = REQ_ABORTED;
            break;
        }
        
        // proppatch_do should remove all handled props from set and remove
        // in the next iteration, the backend must use these reduced lists
        prev_set = set;
        prev_remove = remove;
        
        requests[numrequests++] = req;
        
        // continue with next backend
        dav = dav->next;
    }
    
    WSBool commit = FALSE;
    if(ret == REQ_PROCEED && resource->err == 0) {
        // no errors, no properties with errors -> save the changes
        commit = TRUE; 
    }
    
    // call proppatch_finish for each successfully called proppatch_do
    dav = op->dav;
    int i = 0;
    while(dav && i < numrequests) {
        if(dav->proppatch_finish(requests[i], resource, file, commit)) {
            ret = REQ_ABORTED;
        }
        i++;
        dav = dav->next;
    }
    
    if(file) {
        vfs_close(file);
    }
    
    if(resource->close(resource)) {
        ret = REQ_ABORTED;
    }
    
    return ret;
}

int webdav_op_proppatch_close_resource(
        WebdavOperation *op,
        WebdavResource *resource)
{
    return 0; // NOP
}


/****************************************************************************
 * 
 *                             VFS OPERATION
 * 
 ****************************************************************************/

WebdavVFSOperation* webdav_vfs_op(
        Session *sn,
        Request *rq,
        WebdavBackend *dav,
        WSBool precondition)
{
    WebdavVFSOperation *op = pool_malloc(sn->pool, sizeof(WebdavVFSOperation));
    if(!op) {
        return NULL;
    }
    ZERO(op, sizeof(WebdavVFSOperation));
    
    op->sn = sn;
    op->rq = rq;
    op->dav = dav;
    op->stat = NULL;
    op->stat_errno = 0;
    
    // create VFS context
    VFSContext *vfs = vfs_request_context(sn, rq);
    if(!vfs) {
        pool_free(sn->pool, op);
        return NULL;
    }
    op->vfs = vfs;
    
    char *path = pblock_findkeyval(pb_key_path, rq->vars);
    op->path = path;  
    
    return op;
}

WebdavVFSOperation webdav_vfs_sub_op(
        WebdavVFSOperation *op,
        char *path,
        struct stat *s)
{
    WebdavVFSOperation sub;
    sub.dav = op->dav;
    sub.path = path;
    sub.sn = op->sn;
    sub.vfs = op->vfs;
    sub.path = path;
    sub.stat = s;
    sub.stat_errno = 0;
    return sub;
}

int webdav_op_iterate_children(
        VFSContext *vfs,
        int depth,
        const char *href,
        const char *path,
        vfs_op_child_func func,
        void *userdata)
{
    pool_handle_t *pool = vfs->sn->pool;
    
    PathSearchElm *start_elm = pool_malloc(pool, sizeof(PathSearchElm));
    start_elm->href = pool_strdup(pool, href ? href : "");
    start_elm->path = pool_strdup(pool, path ? path : "");
    start_elm->hreflen = href ? strlen(href) : 0;
    start_elm->pathlen = path ? strlen(path) : 0;
    start_elm->next = NULL;
    
    PathSearchElm *stack = start_elm;
    PathSearchElm *stack_end = start_elm;
    
    // reusable buffer for full child path and href
    char *newpath = pool_malloc(pool, 256);
    size_t newpathlen = 256;
    
    char *newhref = pool_malloc(pool, 256);
    size_t newhreflen = 256;
    
    int err = 0;
    while(stack && !err) {
        PathSearchElm *cur_elm = stack;
        
        // when newpath is initialized with the parent path
        // set path_buf_init to TRUE
        WSBool href_buf_init = FALSE;
        WSBool path_buf_init = FALSE;
        
        VFS_DIR dir = vfs_opendir(vfs, cur_elm->path);
        if(!dir) {
            log_ereport(
                    LOG_FAILURE,
                    "webdav: propfind: cannot open directory %d",
                    vfs->vfs_errno);
            err = 1;
            break;
        }
        
        VFS_ENTRY f;
        while(vfs_readdir_stat(dir, &f)) {
            if(f.stat_errno != 0) {
                continue;
            }
            
            size_t child_len = strlen(f.name);
            
            // create new path and href for the child
            if(path_buf_concat(
                    pool,
                    &newhref,
                    &newhreflen,
                    &href_buf_init,
                    cur_elm->href,
                    cur_elm->hreflen,
                    f.name,
                    child_len))
            {
                err = 1;
                break;
            }
            if(path_buf_concat(
                    pool,
                    &newpath,
                    &newpathlen,
                    &path_buf_init,
                    cur_elm->path,
                    cur_elm->pathlen,
                    f.name,
                    child_len))
            {
                err = 1;
                break;
            }
            size_t childhreflen = cur_elm->hreflen + 1 + child_len;
            size_t childpathlen = cur_elm->pathlen + 1 + child_len;
            
            // execute callback func for this file
            if(func(vfs, newhref, newpath, dir, &f.stat, userdata)) {
                err = 1;
                break;
            }
            
            // depth of -1 means infinity
            if(depth == -1 && S_ISDIR(f.stat.st_mode)) {
                char *hrefcp = pool_malloc(pool, childhreflen + 1);
                memcpy(hrefcp, newhref, childhreflen + 1);
                hrefcp[childhreflen] = '\0';
                
                char *pathcp = pool_malloc(pool, childpathlen + 1);
                memcpy(pathcp, newpath, childpathlen + 1);
                pathcp[childpathlen] = '\0';
                
                PathSearchElm *new_elm = pool_malloc(pool,
                                            sizeof(PathSearchElm));
                if(!new_elm) {
                    err = 1;
                    break;
                }
                new_elm->href = hrefcp;
                new_elm->path = pathcp;
                new_elm->hreflen = childhreflen;
                new_elm->pathlen = childpathlen;
                new_elm->next = NULL;
                
                // add the new_elm to the stack
                // stack_end is always not NULL here, because the loop is
                // running as long as we have a stack and we remove
                // the first stack element at the end of the loop
                stack_end->next = new_elm;
                stack_end = new_elm;
            }
        }
        
        vfs_closedir(dir);
        
        stack = stack->next;
        
        pool_free(pool, cur_elm->path);
        pool_free(pool, cur_elm->href);
        pool_free(pool, cur_elm);
    }
    
    // in case of an error, we have to free all remaining stack elements
    for(PathSearchElm *elm=stack;elm;) {
        PathSearchElm *next_elm = elm->next;
        pool_free(pool, elm->path);
        pool_free(pool, elm->href);
        pool_free(pool, elm);
        elm = next_elm;
    }
    
    return err;
}


int webdav_vfs_stat(WebdavVFSOperation *op) {
    if(op->stat) {
        return 0;
    } else if(op->stat_errno != 0) {
        // previous stat failed
        return 1;
    }
    
    // stat file
    struct stat sbuf;
    int ret = vfs_stat(op->vfs, op->path, &sbuf);
    if(!ret) {
        // save result in op->stat and in s
        op->stat = pool_malloc(op->sn->pool, sizeof(struct stat));
        if(op->stat) {
            memcpy(op->stat, &sbuf, sizeof(struct stat));
        } else {
            ret = 1;
            op->stat_errno = ENOMEM;
        }
    } else {
        op->stat_errno = errno;
    }
    
    return ret;
}

int webdav_vfs_op_do(WebdavVFSOperation *op, WebdavVFSOpType type) {
    WSBool exec_vfs = TRUE;
    
    // requests for each backends
    WebdavVFSRequest **requests = pool_calloc(
            op->sn->pool,
            webdav_num_backends(op->dav),
            sizeof(WebdavVFSRequest*));
    if(requests == NULL) {
        return REQ_ABORTED;
    }
    
    int ret = REQ_PROCEED;
    
    // call opt_* func for each backend
    WebdavBackend *dav = op->dav;
    int called_backends = 0;
    while(dav) {    
        WebdavVFSRequest *request = NULL;
        
        // get vfs operation functions
        vfs_op_func        op_func        = NULL;
        vfs_op_finish_func op_finish_func = NULL;
        
        if(type == WEBDAV_VFS_MKDIR) {
            op_func        = dav->opt_mkcol;
            op_finish_func = dav->opt_mkcol_finish;
        } else if(type == WEBDAV_VFS_DELETE) {
            op_func        = dav->opt_delete;
            op_finish_func = dav->opt_delete_finish;
        }
        
        if(op_func || op_finish_func) {
            // we need a request object
            request = pool_malloc(op->sn->pool, sizeof(WebdavVFSRequest));
            if(!request) {
                exec_vfs = FALSE;
                ret = REQ_ABORTED;
                break;
            }
            request->sn = op->sn;
            request->rq = op->rq;
            request->path = op->path;
            request->userdata = NULL;
            
            requests[called_backends] = request;
        }
        
        // exec backend func for this operation
        // this will set 'done' to TRUE, if no further vfs call is required
        WSBool done = FALSE;
        called_backends++;
        if(op_func) {
            if(op_func(request, &done)) {
                exec_vfs = FALSE;
                ret = REQ_ABORTED;
                break;
            }
        }
        if(done) {
            exec_vfs = FALSE;
        }
        
        dav = dav->next;
    }
    
    // if needed, call vfs func for this operation
    if(exec_vfs) {
        int r = 0;
        if(type == WEBDAV_VFS_MKDIR) {
            r = vfs_mkdir(op->vfs, op->path);
            if(r) {
                // mkcol specific status codes
                switch(op->vfs->vfs_errno) {
                    case ENOENT: {
                        op->rq->status_num = 409;
                        break;
                    }
                    case EEXIST: {
                        op->rq->status_num = 405;
                        break;
                    }
                    case EACCES: {
                        op->rq->status_num = 403;
                        break;
                    }
                    default: op->rq->status_num = 500;
                }
            }
        } else if(type == WEBDAV_VFS_DELETE) {
            r = webdav_vfs_unlink(op);
        }
        
        if(r) {
            ret = REQ_ABORTED;
        }
    }
    
    WSBool success = ret == REQ_PROCEED ? TRUE : FALSE;
    
    // finish mkcol (cleanup) by calling opt_*_finish for each backend
    dav = op->dav;
    int i = 0;
    while(dav && i < called_backends) {
        // get vfs operation functions
        vfs_op_finish_func op_finish_func = NULL;
        
        if(type == WEBDAV_VFS_MKDIR) {
            op_finish_func = dav->opt_mkcol_finish;
        } else if(type == WEBDAV_VFS_DELETE) {
            op_finish_func = dav->opt_delete_finish;
        }
        
        if(op_finish_func) {
            if(op_finish_func(requests[i], success)) {
                ret = REQ_ABORTED; // don't exit loop
            }
        }
        
        dav = dav->next;
        i++;
    }
    
    return ret;
}

int webdav_vfs_unlink(WebdavVFSOperation *op) {
    // stat the file first, to check if the file is a directory
    if(webdav_vfs_stat(op)) {
        return 1; // error
    } else {
        if(!S_ISDIR(op->stat->st_mode)) {
            return vfs_unlink(op->vfs, op->path);
        } else {
            return vfs_rmdir(op->vfs, op->path);
        }
    }
}