Mercurial > hg > webserver / file revision

/*
 * 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 <sys/file.h>
#include <sys/stat.h>

#include "service.h"
#include "objecttype.h"
#include "../util/io.h"
#include "../util/pblock.h"
#include "../util/util.h"
#include "../daemon/protocol.h"
#include "../daemon/vfs.h"

#include "../util/strbuf.h"
#include <cx/string.h>
#include <cx/utils.h>
#include <cx/printf.h>

#include <errno.h>

/*
 * prepares servicing a file
 *
 * adds content-length header
 *
 * return the opened file
 */
SYS_FILE prepare_service_file(Session *sn, Request *rq, VFSContext *vfs, struct stat *s, int *ret) {
    char *path = pblock_findkeyval(pb_key_path, rq->vars);

    // open the file
    SYS_FILE fd = vfs_open(vfs, path, O_RDONLY);
    if(!fd) {
        // vfs_open sets http status code
        *ret = REQ_ABORTED;
        return NULL;
    }

    // get stat
    if(vfs_fstat(vfs, fd, s) != 0) {
        //perror("prepare_service_file: stat");
        protocol_status(sn, rq, 500, NULL);
        *ret = REQ_ABORTED;
        return NULL;
    }
    
    // check if the file is a directory
    if(S_ISDIR(s->st_mode)) {
        pblock_removekey(pb_key_content_type, rq->srvhdrs);
        char *uri = pblock_findkeyval(pb_key_uri, rq->reqpb);
        size_t urilen = strlen(uri);
        if(urilen > 0 && uri[urilen-1] != '/') {
            pblock_nvinsert("content-length", "0", rq->srvhdrs);
            char *location = pool_malloc(sn->pool, urilen + 2);
            memcpy(location, uri, urilen);
            location[urilen] = '/';
            location[urilen+1] = '\0';
            pblock_kvinsert(pb_key_location, location, urilen + 1, rq->srvhdrs);
            protocol_status(sn, rq, 302, NULL);
            http_start_response(sn, rq);
            *ret = REQ_PROCEED;
        } else {
            // set content-type to "internal/directory" and ret to REQ_NOACTION
            // maybe a SAF will respond to that
            pblock_kvinsert(
                    pb_key_content_type,
                    OBJTYPE_INTERNAL_DIRECTORY,
                    sizeof(OBJTYPE_INTERNAL_DIRECTORY)-1,
                    rq->srvhdrs);
            *ret = REQ_NOACTION;
        }
        vfs_close(fd);
        return NULL;
    }
    
    // sets last-modified, content-length and checks conditions
    const char *etag = vfs_getetag(fd); // optionally, get etag from file
    if(http_set_finfo_etag(sn, rq, s, etag) != REQ_PROCEED) {
        vfs_close(fd);
        *ret = REQ_ABORTED;
        return NULL;
    }
    
    // TODO: check if vfs can seek
    pblock_kvinsert(pb_key_accept_ranges, "bytes", 5, rq->srvhdrs);

    // start response
    protocol_status(sn, rq, 200, NULL);

    return fd;
}

static void free_range(Session *sn, HttpRange *range) {
    HttpRange *elm = range;
    while(elm) {
        HttpRange *next = elm->next;
        pool_free(sn->pool, elm);
        elm = next;
    }
}

static HttpRange* parse_range(Session *sn, char *header, int *status) {
    *status = PROTOCOL_OK;
    
    cxstring range = cx_strtrim(cx_str(header));
    if(!cx_strprefix(range, (cxstring)CX_STR("bytes="))) {
        // unknown range unit - ignore range header
        return NULL;
    }
    
    // get byte-range-set
    range = cx_strsubs(range, 6);
    if(range.length < 1) {
        return NULL;
    }
    
    HttpRange *range_list = NULL;
    HttpRange *last = NULL;
    off_t begin = -1;
    int start = 0;
    int hasbegin = 0;
    for(int i=0;i<=range.length;i++) {
        char c = range.ptr[i];
        if(c == '-') {
            cxstring num = cx_strsubsl(range, start, i-start);
            if(num.length == 0) {
                // empty string before '-' is legal
                hasbegin = 1;
                begin = -1;
                start = i+1;
                continue;
            }
            char *end;
            long long n = strtoll(num.ptr, &end, 10);
            if(errno == 0 && end == range.ptr + i && n >= 0) {
                begin = n;
                hasbegin = 1;
                start = i+1;
            } else {
                // syntax error
                free_range(sn, range_list);
                return NULL;
            }
        } else if(c == ',' || c == '\0') {
            cxstring num = cx_strsubsl(range, start, i-start);
            if(hasbegin) {
                long long n;
                if(num.length == 0) {
                    // empty string after '-' is legal
                    n = -1;
                } else {
                    char *end;
                    n = strtoll(num.ptr, &end, 10);
                    if(errno != 0 || end != range.ptr + i || n < 0) {
                        // syntax error
                        free_range(sn, range_list);
                        return NULL;
                    }
                }
                
                if(!(begin < 0 && n < 0)) {
                    // range: begin - n
                    HttpRange *rangeelm = pool_malloc(sn->pool, sizeof(HttpRange));
                    if(!rangeelm) {
                        free_range(sn, range_list);
                        *status = PROTOCOL_SERVER_ERROR;
                        return NULL;
                    }
                    rangeelm->begin = begin;
                    rangeelm->end = n;
                    rangeelm->next = NULL;
                    if(!last) {
                        range_list = rangeelm;
                        last = rangeelm;
                    } else {
                        last->next = rangeelm;
                        last = rangeelm;
                    }
                    
                    hasbegin = 0;
                    start = i+1;
                    continue;
                }
            }
            
            // syntax error
            free_range(sn, range_list);
            return NULL;
        }
    }

    return range_list;
}

static int validate_range(HttpRange *range, struct stat *finfo, int *status) {
    off_t max_len = finfo->st_size;
    while(range) {
        if(range->begin > 0 && range->end > 0) {
            if(range->end < range->begin) {
                *status = PROTOCOL_REQUESTED_RANGE_NOT_SATISFIABLE;
                return 0;
            }
        }
        if(range->begin >= max_len) {
            *status = PROTOCOL_REQUESTED_RANGE_NOT_SATISFIABLE;
            return 0;
        }
        if(range->end >= max_len) {
            *status = PROTOCOL_REQUESTED_RANGE_NOT_SATISFIABLE;
            return 0;
        }
        
        range = range->next;
    }
    
    // TODO: check for Denial-of-Service Attacks
    
    return 1;
}

/*
 * translates a HttpRange element to a begin offset and a length
 * the HttpRange must be validated
 */
static void range2off(HttpRange *range, off_t filelen, off_t *begin, off_t *length) {
    if(range->begin < 0) {
        // bytes=-a
        *begin = filelen - range->end;
        *length = range->end;
    } else if(range->end < 0) {
        // bytes=a-
        *begin = range->begin;
        *length = filelen - range->begin;
    } else {
        // bytes=a-b
        *begin = range->begin;
        *length = range->end + 1 - range->begin;
    }
}

#define SF_MAX_LEN 0x8000000

static int send_range(Session *sn, SYS_FILE fd, off_t offset, off_t length, char *header, int headerlen) {
    off_t remaining = length;
    
    sendfiledata sfd;
    sfd.fd = fd;
    sfd.header = header;
    sfd.hlen = headerlen;
    sfd.trailer = NULL;
    sfd.tlen = 0;
    
    while(remaining > 0) {
        size_t sflen = remaining < SF_MAX_LEN ? remaining : SF_MAX_LEN;
        sfd.offset = offset;
        sfd.len = sflen;
        
        ssize_t r = net_sendfile(sn->csd, &sfd);
        if(r < 0) {
            return -1;
        }
        
        sfd.header = NULL; // make sure the header is only sent once
        offset += r;
        remaining -= r;
    }
    
    return 0;
}


static void send_range_cleanup(AsyncSendRange *asr) {
    WSBool error = asr->error;
    Session *sn = asr->sn;
    Request *rq = asr->rq;
    
    pool_handle_t *pool = asr->sn->pool;
    vfs_close(asr->in);
    pool_free(pool, asr->aio->buf);
    pool_free(pool, asr->aio);
    pool_free(pool, asr->readev);
    pool_free(pool, asr->writeev);
    pool_free(pool, asr);
    
    int ret = REQ_PROCEED;
    if(error) {
        rq->rq_attr.keep_alive = 0;
        ret = REQ_ABORTED;
    }
    // return to nsapi loop
    nsapi_function_return(sn, rq, ret);
}

static int send_buf(
        SYS_NETFD out,
        char *restrict buf,
        size_t len,
        size_t *restrict pos)
{
    while(*pos < len) {
        ssize_t w = net_write(out, buf + *pos, len - *pos);
        if(w <= 0) {
            return -1;
        }
        *pos += w;
    }
    return 0;
}

static int send_bytes(AsyncSendRange *asr, WSBool *completed) {
    *completed = FALSE;
    if(asr->header) {
        if(send_buf(asr->out, asr->header, asr->headerlen, &asr->headerpos)) {
            if(net_errno(asr->out) == EAGAIN) {
                return 0;
            } else {
                asr->error = TRUE;
                return 1;
            }
        }
        if(asr->headerpos >= asr->headerlen) {
            asr->header = NULL;
        }
    }
    
    if(send_buf(asr->out, asr->aio->buf, asr->aio->result, &asr->wpos)) {
        if(net_errno(asr->out) == EAGAIN) {
            return 0;
        } else {
            asr->error = TRUE;
            return 1;
        }
    }
    
    if(!asr->read_complete) {
        // write completed => new asynchronous read
        asr->aio->offset += asr->aio->result;
        size_t length = asr->end - asr->offset;
        asr->aio->nbytes = AIO_BUF_SIZE < length ? AIO_BUF_SIZE : length;
        asr->read_inprogress = TRUE;
        if(system_aio_read(asr->aio)) {
            asr->error = TRUE;
            return 1;
        }
    }
    *completed = TRUE;
    return 0;
}

static int send_range_readevent(EventHandler *ev, Event *event) {
    AsyncSendRange *asr = event->cookie;
    asr->read_inprogress = FALSE;
    asr->wpos = 0;
    asr->offset += asr->aio->result;
    if(asr->error || asr->aio->result < 0) {
        return 0;
    }
    
    int ret = 1;
    if(asr->aio->result == 0 || asr->offset >= asr->end) {
        asr->read_complete = TRUE;
        ret = 0;
    }
    
    WSBool completed;
    if(send_bytes(asr, &completed)) {
        return 0;
    }
    if(!completed && !asr->write_inprogress) {
        asr->write_inprogress = TRUE;
        if(event_pollout(ev, asr->out, asr->writeev)) {
            asr->error = TRUE;
            return 0;
        }
    }
    
    return ret;
}

static int send_range_writeevent(EventHandler *ev, Event *event) {
    AsyncSendRange *asr = event->cookie;
    if(asr->error) {
        return 1;
    }
    
    WSBool completed;
    if(send_bytes(asr, &completed)) {
        return 1;
    }
    
    if(completed) {
        return 0;
    }
    
    return 1;
}

static int send_range_aio_finish(EventHandler *ev, Event *event) {
    AsyncSendRange *asr = event->cookie;
    if(!asr->write_inprogress) {
        send_range_cleanup(asr);
    }
    asr->read_inprogress = FALSE;
    return 0;
}

static int send_range_poll_finish(EventHandler *ev, Event *event) {
    AsyncSendRange *asr = event->cookie;
    if(!asr->read_inprogress) {
        send_range_cleanup(asr);
    }
    asr->write_inprogress = FALSE;
    return 0;
}

static int send_range_aio(Session *sn, Request *rq, SYS_FILE fd, off_t offset, off_t length, char *header, int headerlen) {
    net_setnonblock(sn->csd, TRUE);
    
    // try to send the header
    ssize_t hw = net_write(sn->csd, header, headerlen);
    if(hw < 0) {
        if(net_errno(sn->csd) == EAGAIN) {
            hw = 0;
        } else {
            return REQ_ABORTED;
        }
    }
    
    AsyncSendRange *asr = pool_malloc(sn->pool, sizeof(AsyncSendRange));
    asr->sn = sn;
    asr->rq = rq;
    asr->in = fd;
    asr->out = sn->csd;
    asr->offset = offset;
    asr->end = offset + length;
    //asr->length = length;
    asr->pos = offset;
    asr->read_complete = FALSE;
    asr->read_inprogress = FALSE;
    asr->write_inprogress = FALSE;
    asr->error = FALSE;
    if(hw == headerlen) {
        asr->header = NULL;
        asr->headerlen = 0;
        asr->headerpos = 0;
    } else {
        asr->header = header;
        asr->headerlen = headerlen;
        asr->headerpos = hw;
    }
    
    Event *readev = pool_malloc(sn->pool, sizeof(Event));
    ZERO(readev, sizeof(Event));
    readev->cookie = asr;
    readev->fn = send_range_readevent;
    readev->finish = send_range_aio_finish;
    
    Event *writeev = pool_malloc(sn->pool, sizeof(Event));
    ZERO(writeev, sizeof(Event));
    writeev->cookie = asr;
    writeev->fn = send_range_writeevent;
    writeev->finish = send_range_poll_finish;
    
    asr->readev = readev;
    asr->writeev = writeev;
    
    aiocb_s *aio = pool_malloc(sn->pool, sizeof(aiocb_s));
    aio->buf = pool_malloc(sn->pool, AIO_BUF_SIZE);
    aio->nbytes = AIO_BUF_SIZE < length ? AIO_BUF_SIZE : length;
    aio->filedes = fd;
    aio->offset = offset;
    aio->evhandler = sn->ev;
    aio->event = readev;
    
    asr->aio = aio;
    asr->wpos = 0;
    
    asr->read_inprogress = TRUE;
    if(system_aio_read(aio)) {
        send_range_cleanup(asr);
        return REQ_ABORTED;
    }
    asr->read_inprogress = TRUE;
    
    return REQ_PROCESSING;
}

struct multi_range_elm {
    cxmutstr header;
    off_t  offset;
    off_t  length;
};

static int send_multi_range(Session *sn, Request *rq, SYS_FILE fd, off_t filelen, HttpRange *range) {
    CxAllocator *a = pool_allocator(sn->pool);
    
    pb_param *content_type = pblock_remove("content-type", rq->srvhdrs);
    
    char sep[64];
    int seplen = util_mime_separator(sep);
    
    cxmutstr newct = cx_asprintf_a(a, "multipart/byteranges; boundary=%s", sep+4);
    pblock_kvinsert(
            pb_key_content_type,
            newct.ptr,
            newct.length,
            rq->srvhdrs);
    cxFree(a, newct.ptr);
    
    // calculate content-length
    off_t response_len = 0;
    
    int nrange = 0;
    HttpRange *rangeelm = range;
    while(rangeelm) {
        nrange++;
        rangeelm = rangeelm->next;
    }
    
    struct multi_range_elm *r = pool_calloc(sn->pool, nrange, sizeof(struct multi_range_elm));
    rangeelm = range;
    int i=0;
    while(rangeelm) {
        range2off(rangeelm, filelen, &(r[i].offset), &(r[i].length));
        r[i].header = cx_asprintf_a(
                a,
                "%s\r\nContent-Type: %s\r\nContent-Range: bytes %lld-%lld/%lld\r\n\r\n",
                sep,
                content_type->value,
                (long long)r[i].offset,
                (long long)r[i].offset+r[i].length - 1,
                (long long)filelen);
        
        response_len += r[i].header.length + r[i].length;
        
        rangeelm = rangeelm->next;
        i++;
    }
    
    response_len += seplen + 4; // trailer: sep + '--' + CRLF
    
    // finally, set the content-length header
    pblock_kllinsert(
            pb_key_content_length,
            (long long)response_len,
            rq->srvhdrs);
    
    // and start the response
    http_start_response(sn, rq);
    
    rangeelm = range;
    i = 0;
    while(rangeelm) {
        if(send_range(sn, fd, r[i].offset, r[i].length, r[i].header.ptr, r[i].header.length)) {
            // TODO: error
        }
        rangeelm = rangeelm->next;
        i++;
    }
    net_printf(sn->csd, "%s--\r\n", sep);
    
    pool_free(sn->pool, r);
    return 0;
}

int send_file(pblock *pb, Session *sn, Request *rq) {
    int ret = REQ_NOACTION;
    struct stat s;
    VFSContext *vfs = vfs_request_context(sn, rq);
    SYS_FILE fd = prepare_service_file(sn, rq, vfs, &s, &ret);
    if(!fd) {
        // if an error occurs, prepare_service_file sets the http status code
        // in case fd is a directory and the uri already ends with an trailing
        // '/', ret is set to REQ_NOACTION
        return ret;
    }
    
    // get and validate range header
    char *range_header = pblock_findkeyval(pb_key_range, rq->headers);
    HttpRange *range = NULL;
    if(range_header) {
        log_ereport(LOG_DEBUG, "send_file: range: %s", range_header);
        
        int status;
        range = parse_range(sn, range_header, &status);
        if(status != PROTOCOL_OK) {
            protocol_status(sn, rq, status, NULL);
            vfs_close(fd);
            return REQ_ABORTED;
        }
        
        if(!validate_range(range, &s, &status)) {
            protocol_status(sn, rq, status, NULL);
            free_range(sn, range);
            vfs_close(fd);
            return REQ_ABORTED;
        }
    }
    
    int single_range = 1;
    off_t offset;
    off_t length;
    if(range) {  
        protocol_status(sn, rq, 206, NULL);
        pblock_removekey(pb_key_content_length, rq->srvhdrs);
        
        if(range->next) {
            single_range = 0;
        } else {
            range2off(range, s.st_size, &offset, &length);
            
            pblock_kllinsert(
                    pb_key_content_length,
                    (long long)length,
                    rq->srvhdrs);
            
            cxmutstr content_range = cx_asprintf(
                    "%lld-%lld/%lld",
                    (long long)offset,
                    (long long)offset+length - 1,
                    (long long)s.st_size);
            pblock_kvinsert(
                    pb_key_content_range,
                    content_range.ptr,
                    content_range.length,
                    rq->srvhdrs);
            free(content_range.ptr);
        }
    } else {
        offset = 0;
        length = s.st_size;
    }
    
    if(single_range) {
        // send response header
        http_start_response(sn, rq);
        // send content
        // TODO: fix: send_range_aio is unstable #96
        //ret = send_range_aio(sn, rq, fd, offset, length, NULL, 0);
        //if(ret == REQ_PROCESSING) {
        //    return ret;
        //}
        
        if(send_range(sn, fd, offset, length, NULL, 0)) {
            // TODO: error
        }
    } else {
        ret = send_multi_range(sn, rq, fd, s.st_size, range);
        // TODO: error
    }
    
    // cleanup
    vfs_close(fd);
    free_range(sn, range);

    return ret;
}



int service_hello(pblock *pb, Session *sn, Request *rq) {
    pblock_removekey(pb_key_content_type, rq->srvhdrs);
    pblock_nvinsert("content-type", "text/plain", rq->srvhdrs);
    pblock_nninsert("content-length", 13, rq->srvhdrs);
    protocol_status(sn, rq, 200, NULL);
    http_start_response(sn, rq);
    net_write(sn->csd, "Hello World!\n", 13);
    return REQ_PROCEED;
}

static int ws_msghandler(WebSocket *ws, WSMessage *msg) {
    if(msg->type == 1) {
        printf("Message(text): %.*s\n", (int)msg->length, msg->data);
        websocket_send_text(ws->userdata, "hello", 5);
    } else {
        printf("Message: opcode: %d | length: %d\n", msg->type, (int)msg->length);
    }
    return 0;
}

int service_ws_hello(pblock *pb, Session *sn, Request *rq) {
    WebSocket ws;
    ZERO(&ws, sizeof(WebSocket));
    ws.userdata = sn->csd;
    
    ws.on_message = ws_msghandler;
    return http_handle_websocket(sn, rq, &ws);
}

int service_index(pblock *pb, Session *sn, Request *rq) {
    //printf("service_index\n");

    char *path = pblock_findkeyval(pb_key_path, rq->vars);
    char *uri = pblock_findkeyval(pb_key_uri, rq->reqpb);

    cxstring r_uri = cx_str(uri);

    // open the file
    VFSContext *vfs = vfs_request_context(sn, rq);
    VFS_DIR dir = vfs_opendir(vfs, path);
    if(!dir) {
        return REQ_ABORTED;
    }

    sbuf_t *out = sbuf_new(1024); // output buffer

    // write html header
    sbuf_puts(out, "<html>\n<head>\n<title>Index of ");
    sbuf_puts(out, uri);
    sbuf_puts(out, "</title>\n</head><body>\n<h1>Index of ");
    sbuf_puts(out, uri);
    sbuf_puts(out, "</h1><hr>\n\n");

    // list directory
    VFS_ENTRY f;
    while(vfs_readdir(dir, &f)) {
        cxstring filename = cx_str(f.name);

        sbuf_puts(out, "<a href=\"");
        sbuf_append(out, r_uri);
        sbuf_append(out, filename);
        sbuf_puts(out, "\">");
        sbuf_append(out, filename);
        sbuf_puts(out, "</a><br>\n");
    }

    sbuf_puts(out, "\n</body>\n</html>\n");

    // send stuff to client
    pblock_removekey(pb_key_content_type, rq->srvhdrs);
    pblock_kvinsert(pb_key_content_type, "text/html", 9, rq->srvhdrs);
    pblock_nninsert("content-length", out->length, rq->srvhdrs);
    protocol_status(sn, rq, 200, NULL);
    http_start_response(sn, rq);

    net_write(sn->csd, out->ptr, out->length);

    // close
    vfs_closedir(dir);
    sbuf_free(out);

    return REQ_PROCEED;
}

int send_options(pblock *pb, Session *sn, Request *rq) {
    char *allow = "HEAD, GET, PUT, DELETE, TRACE, OPTIONS, MOVE, COPY, "
            "PROPFIND, PROPPATCH, MKCOL, LOCK, UNLOCK, ACL, REPORT";
    char *dav = "1,2,access-control";

    pblock_removekey(pb_key_content_type, rq->srvhdrs);
    pblock_nvinsert("allow", allow, rq->srvhdrs);
    pblock_nvinsert("dav", dav, rq->srvhdrs);
    pblock_nninsert("content-length", 0, rq->srvhdrs);
    protocol_status(sn, rq, 204, NULL);
    http_start_response(sn, rq);

    return REQ_PROCEED;
}