root/trunk/src/connections.c

#include <sys/stat.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>

#include "settings.h"

#include "server.h"
#include "connections.h"
#include "fdevent.h"
#include "log.h"

#include "request.h"
#include "response.h"
#include "network.h"
#include "stat_cache.h"
#include "joblist.h"

#include "plugin.h"

#include "inet_ntop_cache.h"
#include "configfile.h"
#include "http_req.h"

#ifdef USE_OPENSSL
# include <openssl/ssl.h>
# include <openssl/err.h>
#endif

#ifdef HAVE_SYS_FILIO_H
# include <sys/filio.h>
#endif

#include "sys-socket.h"
#include "sys-files.h"

typedef struct {
        PLUGIN_DATA;
}Â plugin_data;

static connection *connections_get_new_connection(server *srv) {
        connections *conns = srv->conns;
        size_t i;

        if (conns->size == 0) {
                conns->size = 128;
                conns->ptr = NULL;
                conns->ptr = malloc(sizeof(*conns->ptr) * conns->size);
                for (i = 0; i < conns->size; i++) {
                        conns->ptr[i] = connection_init(srv);
                }
        } else if (conns->size == conns->used) {
                conns->size += 128;
                conns->ptr = realloc(conns->ptr, sizeof(*conns->ptr) * conns->size);

                for (i = conns->used; i < conns->size; i++) {
                        conns->ptr[i] = connection_init(srv);
                }
        }

        connection_reset(srv, conns->ptr[conns->used]);

        conns->ptr[conns->used]->ndx = conns->used;
        return conns->ptr[conns->used++];
}

static int connection_del(server *srv, connection *con) {
        size_t i;
        connections *conns = srv->conns;
        connection *temp;

        if (con == NULL) return -1;

        if (-1 == con->ndx) return -1;

        i = con->ndx;

        /* not last element */

        if (i != conns->used - 1) {
                temp = conns->ptr[i];
                conns->ptr[i] = conns->ptr[conns->used - 1];
                conns->ptr[conns->used - 1] = temp;

                conns->ptr[i]->ndx = i;
                conns->ptr[conns->used - 1]->ndx = -1;
        }

        conns->used--;

        con->ndx = -1;

        return 0;
}

int connection_close(server *srv, connection *con) {
#ifdef USE_OPENSSL
        /* should be in iosocket_close() */

        if (con->sock->ssl) {
                int ret, ssl_r;
                unsigned long err;

                ERR_clear_error();
                switch (ret = SSL_shutdown(con->sock->ssl)) {
                case 1:
                        /* done */
                        break;
                case 0:
                        /* wait for fd-event
                         *
                         * FIXME: wait for fdevent and call SSL_shutdown again
                         * (But it is not that important as we close the underlying connection anyway)
                         */

                        break;
                default:
                        switch ((ssl_r = SSL_get_error(con->sock->ssl, ret))) {
                        case SSL_ERROR_WANT_WRITE:
                        case SSL_ERROR_WANT_READ:
                                break;
                        case SSL_ERROR_SYSCALL:
                                /* perhaps we have error waiting in our error-queue */
                                if (0 != (err = ERR_get_error())) {
                                        do {
                                                ERROR("SSL_shutdown failed (%i, %i): %s", ssl_r, ret, ERR_error_string(err, NULL));
                                        } while((err = ERR_get_error()));
                                } else {
                                        ERROR("SSL_shutdown failed (%i, %i, %i): %s", ssl_r, ret, errno, strerror(errno));
                                }

                                break;
                        default:
                                while((err = ERR_get_error())) {
                                        ERROR("SSL_shutdown failed (%i, %i): %s", ssl_r, ret, ERR_error_string(err, NULL));
                                }
                        }
                }

                SSL_free(con->sock->ssl);
                ERR_clear_error();
                con->sock->ssl = NULL;
        }
#endif

        fdevent_event_del(srv->ev, con->sock);
        fdevent_unregister(srv->ev, con->sock);

        if (closesocket(con->sock->fd)) {
                log_error_write(srv, __FILE__, __LINE__, "sds",
                                "(warning) close:", con->sock->fd, strerror(errno));
        }

        connection_del(srv, con);
        connection_set_state(srv, con, CON_STATE_CONNECT);

        return 0;
}

#if 0
static void dump_packet(const unsigned char *data, size_t len) {
        size_t i, j;

        if (len == 0) return;

        for (i = 0; i < len; i++) {
                if (i % 16 == 0) fprintf(stderr, "  ");

                fprintf(stderr, "%02x ", data[i]);

                if ((i + 1) % 16 == 0) {
                        fprintf(stderr, "  ");
                        for (j = 0; j <= i % 16; j++) {
                                unsigned char c;

                                if (i-15+j >= len) break;

                                c = data[i-15+j];

                                fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
                        }

                        fprintf(stderr, "\n");
                }
        }

        if (len % 16 != 0) {
                for (j = i % 16; j < 16; j++) {
                        fprintf(stderr, "   ");
                }

                fprintf(stderr, "  ");
                for (j = i & ~0xf; j < len; j++) {
                        unsigned char c;

                        c = data[j];
                        fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
                }
                fprintf(stderr, "\n");
        }
}
#endif

static int connection_handle_response_header(server *srv, connection *con) {
        int no_response_body = 0;

        if (con->mode == DIRECT) {
                /* static files */
                switch(con->request.http_method) {
                case HTTP_METHOD_GET:
                case HTTP_METHOD_POST:
                case HTTP_METHOD_HEAD:
                        /* webdav */
                case HTTP_METHOD_PUT:
                case HTTP_METHOD_MKCOL:
                case HTTP_METHOD_DELETE:
                case HTTP_METHOD_COPY:
                case HTTP_METHOD_MOVE:
                case HTTP_METHOD_PROPFIND:
                case HTTP_METHOD_PROPPATCH:
                case HTTP_METHOD_LOCK:
                case HTTP_METHOD_UNLOCK:
                        break;
                case HTTP_METHOD_OPTIONS:
                        /*
                         * 400 is coming from the request-parser BEFORE uri.path is set
                         * 403 is from the response handler when noone else catched it
                         *
                         * */
                        if ((!con->http_status || con->http_status == 200) &&
                            con->uri.path->used && con->uri.path->ptr[0] != '*') {
                                response_header_insert(srv, con, CONST_STR_LEN("Allow"), CONST_STR_LEN("OPTIONS, GET, HEAD, POST"));

                                /* trash the content */
                                no_response_body = 1;

                                con->http_status = 200;
                        }
                        break;
                default:
                        switch(con->http_status) {
                        case 400: /* bad request */
                        case 414: /* overload request header */
                        case 505: /* unknown protocol */
                        case 207: /* this was webdav */
                                break;
                        default:
                                con->http_status = 501;
                                break;
                        }
                        break;
                }
        }

        if (con->http_status == 0) {
                TRACE("%s", "no status, setting 403");
                con->http_status = 403;
        }

        switch(con->http_status) {
        case 400: /* class: header + custom body */
        case 401:
        case 403:
        case 404:
        case 408:
        case 409:
        case 410:
        case 411:
        case 416:
        case 423:
        case 500:
        case 501:
        case 502:
        case 503:
        case 504:
        case 505:
        case 509:
                if (con->mode != DIRECT) break;

                con->send->is_closed = 0;

                buffer_reset(con->physical.path);

                /* try to send static errorfile */
                if (!buffer_is_empty(con->conf.errorfile_prefix)) {
                        stat_cache_entry *sce = NULL;

                        buffer_copy_string_buffer(con->physical.path, con->conf.errorfile_prefix);
                        buffer_append_string(con->physical.path, get_http_status_body_name(con->http_status));

                        if (HANDLER_ERROR != stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
                                chunkqueue_append_file(con->send, con->physical.path, 0, sce->st.st_size);
                                con->send->bytes_in += sce->st.st_size;
                                con->send->is_closed = 1;
                                response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(sce->content_type));
                        }
                }

                if (!con->send->is_closed) {
                        buffer *b;

                        buffer_reset(con->physical.path);

                        con->send->is_closed = 1;
                        b = chunkqueue_get_append_buffer(con->send);

                        /* build default error-page */
                        buffer_copy_string_len(b, CONST_STR_LEN(
                                           "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"
                                           "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
                                           "         \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
                                           "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n"
                                           " <head>\n"
                                           "  <title>"));
                        buffer_append_long(b, con->http_status);
                        buffer_append_string_len(b, CONST_STR_LEN(" - "));
                        buffer_append_string(b, get_http_status_name(con->http_status));

                        buffer_append_string(b,
                                             "</title>\n"
                                             " </head>\n"
                                             " <body>\n"
                                             "  <h1>");
                        buffer_append_long(b, con->http_status);
                        buffer_append_string_len(b, CONST_STR_LEN(" - "));
                        buffer_append_string(b, get_http_status_name(con->http_status));

                        buffer_append_string(b,"</h1>\n"
                                             " </body>\n"
                                             "</html>\n"
                                             );

                        con->send->bytes_in += b->used - 1;

                        response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));
                }
                /* fall through */
        case 207:
        case 200: /* class: header + body */
        case 201:
        case 301:
        case 302:
        case 303:
                break;

        case 206: /* write_queue is already prepared */
                break;
        case 205: /* class: header only */
        case 304:
        default:
                if (con->mode == DIRECT) {
                        /* only if we have handled the request internally
                         * we will see no response-content
                         *
                         * if it was a fastcgi request we will see a END_REQUEST packet
                         * after the header was parsed. 
                         *
                         *  */
                        no_response_body = 1;
                }
                break;
        }

        if (no_response_body) {
                /* disable chunked encoding again as we have no body */
                con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
                chunkqueue_reset(con->send);

                con->send->is_closed = 1;
        }

        return 0;
}

connection *connection_init(server *srv)Â {
        connection *con;

        UNUSED(srv);

        con = calloc(1, sizeof(*con));

        con->sock = iosocket_init();
        con->ndx = -1;
        con->bytes_written = 0;
        con->bytes_read = 0;
        con->bytes_header = 0;
        con->loops_per_request = 0;

#define CLEAN(x) \
        con->x = buffer_init();

        CLEAN(request.uri);
        CLEAN(request.request);
        CLEAN(request.pathinfo);
        CLEAN(request.http_host);

        CLEAN(request.orig_uri);

        CLEAN(uri.scheme);
        CLEAN(uri.authority);
        CLEAN(uri.path);
        CLEAN(uri.path_raw);
        CLEAN(uri.query);

        CLEAN(physical.doc_root);
        CLEAN(physical.path);
        CLEAN(physical.basedir);
        CLEAN(physical.rel_path);
        CLEAN(physical.etag);
        CLEAN(parse_request);

        CLEAN(authed_user);
        CLEAN(server_name);
        CLEAN(error_handler);
        CLEAN(dst_addr_buf);

#undef CLEAN
        con->send_filters = filter_chain_init();
        /* send is the chunkqueue of the first send filter */
        con->send = con->send_filters->first->cq;
        con->recv = chunkqueue_init();
        chunkqueue_set_tempdirs(con->recv, srv->srvconf.upload_tempdirs);

        con->send_raw = chunkqueue_init();
        con->recv_raw = chunkqueue_init();

        con->request.headers      = array_init();
        con->response.headers     = array_init();
        con->environment     = array_init();

        con->http_req = http_request_init();

        /* init plugin specific connection structures */

        con->plugin_ctx = calloc(1, (srv->plugins.used + 1) * sizeof(void *));

        con->cond_cache = calloc(srv->config_context->used, sizeof(cond_cache_t));
        config_setup_connection(srv, con);

        return con;
}

void connections_free(server *srv) {
        connections *conns = srv->conns;
        size_t i;

        for (i = 0; i < conns->size; i++) {
                connection *con = conns->ptr[i];

                connection_reset(srv, con);
                iosocket_free(con->sock);

                filter_chain_free(con->send_filters);
                con->send = NULL;
                chunkqueue_free(con->recv);
                chunkqueue_free(con->send_raw);
                chunkqueue_free(con->recv_raw);
                array_free(con->request.headers);
                array_free(con->response.headers);
                array_free(con->environment);

#define CLEAN(x) \
        buffer_free(con->x);

                CLEAN(request.uri);
                CLEAN(request.request);
                CLEAN(request.pathinfo);
                CLEAN(request.http_host);

                CLEAN(request.orig_uri);

                CLEAN(uri.scheme);
                CLEAN(uri.authority);
                CLEAN(uri.path);
                CLEAN(uri.path_raw);
                CLEAN(uri.query);

                CLEAN(physical.doc_root);
                CLEAN(physical.path);
                CLEAN(physical.basedir);
                CLEAN(physical.etag);
                CLEAN(physical.rel_path);
                CLEAN(parse_request);

                CLEAN(authed_user);
                CLEAN(server_name);
                CLEAN(error_handler);
                CLEAN(dst_addr_buf);
#undef CLEAN
                free(con->plugin_ctx);
                free(con->cond_cache);

                http_request_free(con->http_req);

                free(con);
        }

        free(conns->ptr);
}


int connection_reset(server *srv, connection *con) {
        size_t i;

        plugins_call_connection_reset(srv, con);

        con->is_readable = 1;
        con->is_writable = 1;
        con->http_status = 0;
        con->file_started = 0;
        con->got_response = 0;

        con->bytes_written = 0;
        con->bytes_written_cur_second = 0;
        con->bytes_read = 0;
        con->bytes_header = 0;
        con->loops_per_request = 0;

        con->request.http_method = HTTP_METHOD_UNSET;
        con->request.http_version = HTTP_VERSION_UNSET;
        con->request.content_length = -1;

        con->response.keep_alive = 0;
        con->response.content_length = -1;
        con->response.transfer_encoding = 0;

        con->mode = DIRECT;

#define CLEAN(x) \
        if (con->x) buffer_reset(con->x);

        CLEAN(request.uri);
        CLEAN(request.pathinfo);
        CLEAN(request.request);
        CLEAN(request.http_host);

        CLEAN(request.orig_uri);

        CLEAN(uri.scheme);
        CLEAN(uri.authority);
        CLEAN(uri.path);
        CLEAN(uri.path_raw);
        CLEAN(uri.query);

        CLEAN(physical.doc_root);
        CLEAN(physical.path);
        CLEAN(physical.basedir);
        CLEAN(physical.rel_path);
        CLEAN(physical.etag);

        CLEAN(parse_request);

        CLEAN(authed_user);
        CLEAN(server_name);
        CLEAN(error_handler);
#undef CLEAN

#define CLEAN(x) \
        if (con->x) con->x->used = 0;

#undef CLEAN

        array_reset(con->request.headers);
        array_reset(con->response.headers);
        array_reset(con->environment);

        filter_chain_reset(con->send_filters);
        con->send = con->send_filters->first->cq;
        chunkqueue_reset(con->recv);
        chunkqueue_reset(con->send_raw);

        http_request_reset(con->http_req);

        /* the plugins should cleanup themself */
        for (i = 0; i < srv->plugins.used; i++) {
                plugin *p = ((plugin **)(srv->plugins.ptr))[i];
                plugin_data *pd = p->data;

                if (!pd) continue;

                if (con->plugin_ctx[pd->id] != NULL) {
                        log_error_write(srv, __FILE__, __LINE__, "sb", "missing cleanup in", p->name);
                }

                con->plugin_ctx[pd->id] = NULL;
        }

        config_cond_cache_reset(srv, con);

        con->header_len = 0;
        con->in_error_handler = 0;

        config_setup_connection(srv, con);

        return 0;
}

/**
 * handle all header and content read
 *
 * we get called by the state-engine and by the fdevent-handler
 */
handler_t connection_handle_read_request_header(server *srv, connection *con)  {
        /* let's see if we need more data later */
        fdevent_event_del(srv->ev, con->sock);

        con->read_idle_ts = srv->cur_ts;  /* start a read-call() */

        /* read from the network */
        switch (network_read(srv, con, con->sock, con->recv_raw)) {
        case NETWORK_STATUS_SUCCESS:
                /* we read everything from the socket, do we have a full header ? */
                break;
        case NETWORK_STATUS_WAIT_FOR_EVENT:
                fdevent_event_add(srv->ev, con->sock, FDEVENT_IN);
                return HANDLER_WAIT_FOR_EVENT;
        case NETWORK_STATUS_CONNECTION_CLOSE:
                /* the connection went away before we got something back */
                connection_set_state(srv, con, CON_STATE_CLOSE);

                return HANDLER_GO_ON;
        default:
                ERROR("++ %s", "oops, something went wrong while reading");
                return HANDLER_ERROR;
        }

        switch (http_request_parse_cq(con->recv_raw, con->http_req)) {
        case PARSE_ERROR:
                con->http_status = 400; /* the header is broken */
                con->send->is_closed = 1; /* we have nothing to send */

                chunkqueue_remove_finished_chunks(con->recv_raw);

                return HANDLER_FINISHED;
        case PARSE_NEED_MORE:
                /* we need more */
                fdevent_event_add(srv->ev, con->sock, FDEVENT_IN);

                return HANDLER_WAIT_FOR_EVENT;
        case PARSE_SUCCESS:
                chunkqueue_remove_finished_chunks(con->recv_raw);
                break;
        default:
                chunkqueue_remove_finished_chunks(con->recv_raw);
                TRACE("%s", "(error)");
                return HANDLER_ERROR;
        }

        return HANDLER_GO_ON;
}

/* decode the HTTP/1.1 chunk encoding */

handler_t connection_handle_read_request_content(server *srv, connection *con)  {
        /* read data from the socket and push it to the backend */

        chunkqueue *in = con->recv_raw;
        chunkqueue *out = con->recv; /* the pure content */
        chunk *c;

        /* let's see if we need more data later */
        fdevent_event_del(srv->ev, con->sock);

        con->read_idle_ts = srv->cur_ts;  /* start a read-call() */

        if (con->request.content_length == -1) return HANDLER_GO_ON;

        /* if the content was short enough, it might be read already */
        if (in->first &&
            chunkqueue_length(in) - in->first->offset > 0) {

                /*
                 * looks like the request-header also had some content for us
                 */

        } else {
                /* read from the network */
                switch (network_read(srv, con, con->sock, in)) {
                case NETWORK_STATUS_SUCCESS:
                        /* we have data */
                        break;
                case NETWORK_STATUS_WAIT_FOR_EVENT:
                        fdevent_event_add(srv->ev, con->sock, FDEVENT_IN);
                        return HANDLER_WAIT_FOR_EVENT;
                case NETWORK_STATUS_CONNECTION_CLOSE:
                        /* the connection went away before we got something back */
                        connection_set_state(srv, con, CON_STATE_CLOSE);

                        return HANDLER_GO_ON;
                default:
                        ERROR("++ %s", "oops, something went wrong while reading");
                        return HANDLER_ERROR;
                }
        }

        /* how much data do we want to extract ? */
        for (c = in->first; c && (out->bytes_in != con->request.content_length); c = c->next) {
                off_t weWant, weHave, toRead;

                weWant = con->request.content_length - out->bytes_in;

                if (c->mem->used == 0) continue;

                weHave = c->mem->used - c->offset - 1;

                toRead = weHave > weWant ? weWant : weHave;

                /* the new way, copy everything into a chunkqueue whcih might use tempfiles */
                if (con->request.content_length > 64 * 1024) {
                        chunk *dst_c = NULL;
                        /* copy everything to max 1Mb sized tempfiles */

                        /*
                         * if the last chunk is
                         * - smaller than 1Mb (size < 1Mb)
                         * - not read yet (offset == 0)
                         * -> append to it
                         * otherwise
                         * -> create a new chunk
                         *
                         * */

                        if (out->last &&
                            out->last->type == FILE_CHUNK &&
                            out->last->file.is_temp &&
                            out->last->offset == 0) {
                                /* ok, take the last chunk for our job */

                                if (out->last->file.length < 1 * 1024 * 1024) {
                                        dst_c = out->last;

                                        if (dst_c->file.fd == -1) {
                                                /* this should not happen as we cache the fd, but you never know */
                                                dst_c->file.fd = open(dst_c->file.name->ptr, O_WRONLY | O_APPEND);
                                        }
                                } else {
                                        /* the chunk is too large now, close it */
                                        dst_c = out->last;

                                        if (dst_c->file.fd != -1) {
                                                close(dst_c->file.fd);
                                                dst_c->file.fd = -1;
                                        }
                                        dst_c = chunkqueue_get_append_tempfile(out);
                                }
                        } else {
                                dst_c = chunkqueue_get_append_tempfile(out);
                        }

                        /* we have a chunk, let's write to it */

                        if (dst_c->file.fd == -1) {
                                /* we don't have file to write to,
                                 * EACCES might be one reason.
                                 *
                                 * Instead of sending 500 we send 413 and say the request is too large
                                 *  */

                                log_error_write(srv, __FILE__, __LINE__, "sbs",
                                                "denying upload as opening to temp-file for upload failed:",
                                                dst_c->file.name, strerror(errno));

                  Â