root/cherokee/trunk/cherokee/connection.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/* Cherokee
 *
 * Authors:
 *      Alvaro Lopez Ortega <alvaro@alobbs.com>
 *
 * Copyright (C) 2001-2008 Alvaro Lopez Ortega
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#include "common-internal.h"
#include "connection.h"
#include "connection-protected.h"
#include "bogotime.h"

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <sys/types.h>

#ifdef HAVE_PWD_H
# include <pwd.h>
#endif

#ifdef HAVE_SYS_UIO_H
# include <sys/uio.h>
#endif

#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif

#ifdef HAVE_ARPA_INET_H
# include <arpa/inet.h>
#endif

#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif

#ifdef HAVE_NETINET_TCP_H
# include <netinet/tcp.h>
#endif

#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif

#include "util.h"
#include "list.h"
#include "http.h"
#include "handler.h"
#include "thread.h"
#include "handler_error.h"
#include "buffer.h"
#include "config_entry.h"
#include "server-protected.h"
#include "access.h"
#include "virtual_server.h"
#include "socket.h"
#include "header.h"
#include "header-protected.h"
#include "iocache.h"
#include "dtm.h"

#define ENTRIES "core,connection"


ret_t
cherokee_connection_new  (cherokee_connection_t **conn)
{
        CHEROKEE_NEW_STRUCT(n, connection);
           
        INIT_LIST_HEAD (&n->list_node);

        n->error_code           = http_ok;
        n->phase                = phase_reading_header;
        n->auth_type            = http_auth_nothing;
        n->req_auth_type        = http_auth_nothing;
        n->upgrade              = http_upgrade_nothing;
        n->options              = conn_op_log_at_end;
        n->handler              = NULL; 
        n->encoder              = NULL;
        n->logger_ref           = NULL;
        n->keepalive            = 0;
        n->range_start          = 0;
        n->range_end            = 0;
        n->vserver              = NULL;
        n->arguments            = NULL;
        n->realm_ref            = NULL;
        n->mmaped               = NULL;
        n->mmaped_len           = 0;
        n->io_entry_ref         = NULL;
        n->thread               = NULL;
        n->rx                   = 0;    
        n->tx                   = 0;
        n->rx_partial           = 0;
        n->tx_partial           = 0;
        n->traffic_next         = 0;
        n->validator            = NULL;
        n->timeout              = -1;
        n->polling_fd           = -1;
        n->polling_multiple     = false;
        n->polling_mode         = FDPOLL_MODE_NONE;
        n->expiration           = cherokee_expiration_none;
        n->expiration_time      = 0;
        n->respins              = 0;

        cherokee_buffer_init (&n->buffer);
        cherokee_buffer_init (&n->header_buffer);
        cherokee_buffer_init (&n->incoming_header);
        cherokee_buffer_init (&n->encoder_buffer);

        cherokee_buffer_init (&n->local_directory);
        cherokee_buffer_init (&n->web_directory);
        cherokee_buffer_init (&n->effective_directory);
        cherokee_buffer_init (&n->userdir);
        cherokee_buffer_init (&n->request);
        cherokee_buffer_init (&n->pathinfo);
        cherokee_buffer_init (&n->redirect);
        cherokee_buffer_init (&n->host);
        cherokee_buffer_init (&n->self_trace);

        cherokee_buffer_init (&n->query_string);
        cherokee_buffer_init (&n->request_original);

        cherokee_socket_init (&n->socket);
        cherokee_header_init (&n->header, header_type_request);
        cherokee_post_init (&n->post);

        memset (n->regex_ovector, OVECTOR_LEN * sizeof(int), 0);
        n->regex_ovecsize = 0;

        n->chunked_encoding     = false;
        n->chunked_sent         = 0;
        n->chunked_last_package = false;
        cherokee_buffer_init (&n->chunked_len);

        *conn = n;
        return ret_ok;
}


ret_t
cherokee_connection_free (cherokee_connection_t  *conn)
{
        cherokee_header_mrproper (&conn->header);
        cherokee_socket_mrproper (&conn->socket);
        
        if (conn->handler != NULL) {
                cherokee_handler_free (conn->handler);
                conn->handler = NULL;
        }

        if (conn->encoder != NULL) {
                cherokee_encoder_free (conn->encoder);
                conn->encoder = NULL;
        }

        cherokee_post_mrproper (&conn->post);
        
        cherokee_buffer_mrproper (&conn->request);
        cherokee_buffer_mrproper (&conn->request_original);

        cherokee_buffer_mrproper (&conn->pathinfo);
        cherokee_buffer_mrproper (&conn->buffer);
        cherokee_buffer_mrproper (&conn->header_buffer);
        cherokee_buffer_mrproper (&conn->incoming_header);
        cherokee_buffer_mrproper (&conn->query_string);
        cherokee_buffer_mrproper (&conn->encoder_buffer);

        cherokee_buffer_mrproper (&conn->local_directory);
        cherokee_buffer_mrproper (&conn->web_directory);
        cherokee_buffer_mrproper (&conn->effective_directory);
        cherokee_buffer_mrproper (&conn->userdir);
        cherokee_buffer_mrproper (&conn->redirect);
        cherokee_buffer_mrproper (&conn->host);
        cherokee_buffer_mrproper (&conn->self_trace);
        cherokee_buffer_mrproper (&conn->chunked_len);

        if (conn->validator != NULL) {
                cherokee_validator_free (conn->validator);
                conn->validator = NULL;
        }

        if (conn->arguments != NULL) {
                cherokee_avl_free (conn->arguments, free);
                conn->arguments = NULL;
        }

        if (conn->polling_fd != -1) {
                close (conn->polling_fd);
                conn->polling_fd   = -1;
                conn->polling_mode = FDPOLL_MODE_NONE;
        }
        
        free (conn);
        return ret_ok;
}


ret_t
cherokee_connection_clean (cherokee_connection_t *conn)
{          
        uint32_t header_len;
        size_t   crlf_len;

        /* I/O cache entry reference
         */
        if (conn->io_entry_ref != NULL) {
                cherokee_iocache_entry_unref (&conn->io_entry_ref);
                conn->io_entry_ref = NULL;
        }

        /* TCP cork
         */
        if (conn->options & conn_op_tcp_cork) {
                cherokee_connection_set_cork (conn, false);
                BIT_UNSET (conn->options, conn_op_tcp_cork);            
        }

        conn->timeout              = -1;
        conn->phase                = phase_reading_header;
        conn->auth_type            = http_auth_nothing;
        conn->req_auth_type        = http_auth_nothing;
        conn->upgrade              = http_upgrade_nothing;
        conn->options              = conn_op_log_at_end;
        conn->error_code           = http_ok;
        conn->range_start          = 0;
        conn->range_end            = 0;
        conn->logger_ref           = NULL;
        conn->realm_ref            = NULL;
        conn->mmaped               = NULL;
        conn->mmaped_len           = 0;
        conn->rx                   = 0; 
        conn->tx                   = 0;
        conn->rx_partial           = 0; 
        conn->tx_partial           = 0;
        conn->traffic_next         = 0;
        conn->polling_multiple     = false;
        conn->polling_mode         = FDPOLL_MODE_NONE;
        conn->expiration           = cherokee_expiration_none;
        conn->expiration_time      = 0;
        conn->chunked_encoding     = false;
        conn->chunked_sent         = 0;
        conn->chunked_last_package = false;
        conn->respins              = 0;

        memset (conn->regex_ovector, OVECTOR_LEN * sizeof(int), 0);
        conn->regex_ovecsize = 0;

        if (conn->handler != NULL) {
                cherokee_handler_free (conn->handler);
                conn->handler = NULL;
        }
        
        if (conn->encoder != NULL) {
                cherokee_encoder_free (conn->encoder);
                conn->encoder = NULL;
        }

        if (conn->polling_fd != -1) {
                close (conn->polling_fd);
                conn->polling_fd = -1;
        }

        cherokee_post_mrproper (&conn->post);
        cherokee_buffer_mrproper (&conn->encoder_buffer);

        cherokee_buffer_clean (&conn->request);
        cherokee_buffer_clean (&conn->request_original);

        cherokee_buffer_clean (&conn->pathinfo);
        cherokee_buffer_clean (&conn->local_directory);
        cherokee_buffer_clean (&conn->web_directory);
        cherokee_buffer_clean (&conn->effective_directory);
        cherokee_buffer_clean (&conn->userdir);
        cherokee_buffer_clean (&conn->redirect);
        cherokee_buffer_clean (&conn->host);
        cherokee_buffer_clean (&conn->query_string);
        cherokee_buffer_clean (&conn->self_trace);
        cherokee_buffer_clean (&conn->chunked_len);
        
        if (conn->validator != NULL) {
                cherokee_validator_free (conn->validator);
                conn->validator = NULL;
        }

        if (conn->arguments != NULL) {
                cherokee_avl_free (conn->arguments, free);
                conn->arguments = NULL;
        }

        /* Drop out the last incoming header
         */
        cherokee_header_get_length (&conn->header, &header_len);

        cherokee_header_clean (&conn->header);
        cherokee_buffer_clean (&conn->buffer);
        cherokee_buffer_clean (&conn->header_buffer);
        
        /* Skip trailing CRLF (which may be sent by some HTTP clients)
         * only if the number of CRLFs is within the predefine count
         * limit otherwise ignore trailing CRLFs so that they will be
         * handled in next request.  This may avoid a subsequent real
         * move_to_begin of the contents left in the buffer.
         */
        crlf_len = cherokee_buffer_cnt_spn (&conn->incoming_header, header_len, CRLF);
        header_len += (crlf_len <= MAX_HEADER_CRLF) ? crlf_len : 0;

        cherokee_buffer_move_to_begin (&conn->incoming_header, header_len);

        /* If the connection has incoming headers to be processed,
         * then increment the pending counter from the thread
         */      
        if (! cherokee_buffer_is_empty (&conn->incoming_header)) {
                CONN_THREAD(conn)->pending_conns_num++;
        }

        TRACE (ENTRIES, "conn %p, has headers %d\n", conn, 
               !cherokee_buffer_is_empty (&conn->incoming_header));

        return ret_ok;
}


ret_t 
cherokee_connection_clean_close (cherokee_connection_t *conn)
{
        /* Close and clean the socket
         */
        cherokee_socket_close (&conn->socket);
        cherokee_socket_clean (&conn->socket);

        /* Make sure the connection Keep-Alive is disabled
         */
        conn->keepalive = 0;
        cherokee_buffer_clean (&conn->incoming_header);

        /* Clean the connection object
         */
        cherokee_connection_clean (conn);
        return ret_ok;
}


ret_t
cherokee_connection_setup_error_handler (cherokee_connection_t *conn)
{
        ret_t                       ret;
        cherokee_server_t          *srv;
        cherokee_virtual_server_t  *vsrv;
        cherokee_config_entry_t    *entry;      

        srv   = CONN_SRV(conn);
        vsrv  = CONN_VSRV(conn);
        entry = vsrv->error_handler;

        /* It has a common handler. It has to be freed.
         */
        if (conn->handler != NULL) {
                cherokee_handler_free (conn->handler);
                conn->handler = NULL;
        }

        /* Create a new error handler
         */
        if ((entry != NULL) && (entry->handler_new_func != NULL)) {
                ret = entry->handler_new_func ((void **) &conn->handler, conn, entry->handler_properties);
                if (ret == ret_ok) 
                        goto out;
        } 

        /* If something was wrong, try with the default error handler
         */
        ret = cherokee_handler_error_new (&conn->handler, conn, NULL);

out:
#ifdef TRACE_ENABLED
        { 
                const char *name = NULL;

                cherokee_module_get_name (MODULE(conn->handler), &name);
                TRACE(ENTRIES, "New handler %s\n", name);
        }
#endif

        /* Only 3xx errors can keep the connection alive
         */
        if ((! (http_type_300 (conn->error_code))) ||
            (! (conn->handler->support & hsupport_length)))
        {
                conn->keepalive = 0;
        }

        /* Nothing should be mmaped any longer
         */
        if (conn->io_entry_ref != NULL) {
                cherokee_iocache_entry_unref (&conn->io_entry_ref);
        }

        conn->io_entry_ref = NULL;
        conn->mmaped       = NULL;
        conn->mmaped_len   = 0;

        /* It does not matter whether the previous handler wanted to
         * use Chunked encoding.
         */
        conn->chunked_encoding = false;

        return ret_ok;
}


static void
build_response_header_authentication (cherokee_connection_t *conn, cherokee_buffer_t *buffer)
{
        ret_t ret;

        /* Basic Authenticatiom
         * Eg: WWW-Authenticate: Basic realm=""
         */
        if (conn->auth_type & http_auth_basic) {
                cherokee_buffer_add_str (buffer, "WWW-Authenticate: Basic realm=\"");
                cherokee_buffer_add_buffer (buffer, conn->realm_ref);
                cherokee_buffer_add_str (buffer, "\""CRLF);
        }

        /* Digest Authentication, Eg:
         * WWW-Authenticate: Digest realm="", qop="auth,auth-int",
         *                   nonce="", opaque=""
         */
        if (conn->auth_type & http_auth_digest) {
                cherokee_thread_t *thread = CONN_THREAD(conn);
                cherokee_buffer_t *new_nonce = THREAD_TMP_BUF1(thread);

                /* Realm
                 */
                cherokee_buffer_add_str (buffer, "WWW-Authenticate: Digest realm=\"");
                cherokee_buffer_add_buffer (buffer, conn->realm_ref);
                cherokee_buffer_add_str (buffer, "\", ");

                /* Nonce:
                 * "nonce=\"%s\", "
                 */
                ret = ret_not_found;

                if ((conn->validator != NULL) &&
                    (! cherokee_buffer_is_empty (&conn->validator->nonce)))
                {
                        ret = cherokee_nonce_table_check (CONN_SRV(conn)->nonces,
                                                          &conn->validator->nonce);
                }

                cherokee_buffer_add_str (buffer, "nonce=\"");                   
                if (ret != ret_ok) {
                        cherokee_nonce_table_generate (CONN_SRV(conn)->nonces, conn, new_nonce);
                        cherokee_buffer_add_buffer (buffer, new_nonce);
                } else {
                        cherokee_buffer_add_buffer (buffer, &conn->validator->nonce);
                }
                cherokee_buffer_add_str (buffer, "\", ");

                                
                /* Quality of protection: auth, auth-int, auth-conf
                 * Algorithm: MD5
                 */
                cherokee_buffer_add_str (buffer, "qop=\"auth\", algorithm=\"MD5\""CRLF);
        }
}


static void
build_response_header_expiration (cherokee_connection_t *conn, cherokee_buffer_t *buffer)
{
        time_t    exp_time;
        struct tm exp_tm;
        size_t    szlen = 0;
        char      bufstr[DTM_SIZE_GMTTM_STR + 2];

        switch (conn->expiration) {
        case cherokee_expiration_epoch:
                cherokee_buffer_add_str (buffer, "Expires: Tue, 01 Jan 1970 00:00:01 GMT" CRLF);
                cherokee_buffer_add_str (buffer, "Cache-Control: no-cache" CRLF);
                break;
        case cherokee_expiration_max:
                cherokee_buffer_add_str (buffer, "Expires: Thu, 31 Dec 2037 23:55:55 GMT" CRLF);
                cherokee_buffer_add_str (buffer, "Cache-Control: max-age=315360000" CRLF);
                break;
        case cherokee_expiration_time:
                exp_time = (cherokee_bogonow_now + conn->expiration_time);
                cherokee_gmtime (&exp_time, &exp_tm);
                szlen = cherokee_dtm_gmttm2str (bufstr, sizeof(bufstr), &exp_tm);

                cherokee_buffer_add_str (buffer, "Expires: ");
                cherokee_buffer_add (buffer, bufstr, szlen);
                cherokee_buffer_add_str (buffer, CRLF);

                cherokee_buffer_add_str (buffer, "Cache-Contro: max-age=");
                cherokee_buffer_add_long10 (buffer, conn->expiration_time);
                cherokee_buffer_add_str (buffer, CRLF);
                break;
        default:
                SHOULDNT_HAPPEN;
        }
}


static void
build_response_header (cherokee_connection_t *conn, cherokee_buffer_t *buffer)
{       
        /* Build the response header.
         */
        cherokee_buffer_clean (buffer);

        /* Add protocol string + error_code
         */
        switch (conn->header.version) {
        case http_version_10:
                cherokee_buffer_add_str (buffer, "HTTP/1.0 "); 
                break;
        case http_version_11:
        default:
                cherokee_buffer_add_str (buffer, "HTTP/1.1 "); 
                break;
        }
        
        cherokee_http_code_copy (conn->error_code, buffer);
        cherokee_buffer_add_str (buffer, CRLF);

        /* Add the "Connection:" header
         */
        if (conn->upgrade != http_upgrade_nothing) {
                cherokee_buffer_add_str (buffer, "Connection: Upgrade"CRLF);

        } else if (conn->handler && (conn->keepalive > 0)) {
                cherokee_buffer_add_str (buffer, "Connection: Keep-Alive"CRLF);
                cherokee_buffer_add_buffer (buffer, &CONN_SRV(conn)->timeout_header);
        } else {
                cherokee_buffer_add_str (buffer, "Connection: close"CRLF);
        }

        /* Chunked transfer
         */
        if (conn->chunked_encoding) {
                cherokee_buffer_add_str (buffer, "Transfer-Encoding: chunked" CRLF);
        }

        /* Exit now if the handler already added all the headers
         */
        if (HANDLER_SUPPORTS (conn->handler, hsupport_full_headers)) 
                return;

        /* Date
         */
        cherokee_buffer_add_str (buffer, "Date: ");
        cherokee_buffer_add_buffer (buffer, &cherokee_bogonow_strgmt);
        cherokee_buffer_add_str (buffer, CRLF);

        /* Add the Server header
         */
        cherokee_buffer_add_str (buffer, "Server: ");
        cherokee_buffer_add_buffer (buffer, &CONN_SRV(conn)->server_string);
        cherokee_buffer_add_str (buffer, CRLF);

        /* Authentication
         */
        if ((conn->realm_ref != NULL) && (conn->error_code == http_unauthorized)) {
                build_response_header_authentication (conn, buffer);
        }

        /* Expiration
         */
        if (conn->expiration != cherokee_expiration_none) {
                build_response_header_expiration (conn, buffer);
        }

        /* Redirected connections
         */
        if (conn->redirect.len >= 1) {
                cherokee_buffer_add_str (buffer, "Location: ");
                cherokee_buffer_add_buffer (buffer, &conn->redirect);
                cherokee_buffer_add_str (buffer, CRLF);
        }

        /* Encoder headers
         */
        if (conn->encoder) {
                cherokee_encoder_add_headers (conn->encoder, buffer);
        }

        /* Unusual methods
         */
        if (conn->header.method == http_options) {
                cherokee_buffer_add_str (buffer, "Allow: GET, HEAD, POST, OPTIONS"CRLF);
        }
}


ret_t 
cherokee_connection_build_header (cherokee_connection_t *conn)
{
        ret_t              ret;
        cherokee_boolean_t try_chunked = false;
        
        /* If the handler requires not to add headers, exit.
         */
        if (HANDLER_SUPPORTS (conn->handler, hsupport_skip_headers)) 
                return ret_ok;

        /* Try to get the headers from the handler
         */
        ret = cherokee_handler_add_headers (conn->handler, &conn->header_buffer);
        if (unlikely (ret != ret_ok)) {
                switch (ret) {
                case ret_eof:
                case ret_error:
                case ret_eagain:
                        return ret;
                default:
                        RET_UNKNOWN(ret);
                        return ret_error;
                }
        }

        /* If the connection is using Kee-Alive, it must either know
         * the length or use chunked encoding. Otherwise, Keep-Alive
         * has to be turned off.
         */
        if ((conn->keepalive != 0) &&
            (http_method_with_body (conn->error_code))) 
        {               
                if (HANDLER_SUPPORTS (conn->handler, hsupport_maybe_length)) {
                        if (! strcasestr (conn->header_buffer.buf, "Content-Length: ")) {
                                try_chunked = true;
                        }
                } else if (! HANDLER_SUPPORTS (conn->handler, hsupport_length)) {
                        try_chunked = true;
                }               

                if (try_chunked) {
                        /* Turn chunked encoding on, if possible
                         */
                        conn->chunked_encoding = ((CONN_SRV(conn)->chunked_encoding) &&
                                                  (conn->header.version == http_version_11));

                        if (! conn->chunked_encoding)
                                conn->keepalive = 0;
                }
        }

        /* Add the server headers       
         */
        build_response_header (conn, &conn->buffer);

        /* Add handler headers end EOH
         */
        cherokee_buffer_add_buffer (&conn->buffer, &conn->header_buffer);
        cherokee_buffer_add_str (&conn->buffer, CRLF);

        return ret_ok;
}


ret_t 
cherokee_connection_send_header_and_mmaped (cherokee_connection_t *conn)
{
        size_t  re = 0;
        ret_t   ret;
        int16_t nvec = 1;
        struct iovec bufs[2];

        /* 1.- Special case: There is not header to send
         * because it has been sent by writev() (see below)
         */
        if (cherokee_buffer_is_empty (&conn->buffer)) {
                ret = cherokee_socket_write (&conn->socket, conn->mmaped, conn->mmaped_len, &re);
                if (unlikely (ret != ret_ok) ) {
                        switch (ret) {
                        case ret_eof:
                        case ret_eagain:
                                return ret;

                        case ret_error:
                                conn->keepalive = 0;
                                return ret;

                        default:
                                conn->keepalive = 0;
                                RET_UNKNOWN(ret);
                                return ret_error;
                        }
                }               
                cherokee_connection_tx_add (conn, re);

                /* NOTE: conn->mmaped is a ptr. to void
                 * so we have to apply ptr. math carefully.
                 */
                conn->mmaped      = (void *) ( ((char *)conn->mmaped) + re );
                conn->mmaped_len -= (off_t) re;

                return (conn->mmaped_len > 0) ? ret_eagain : ret_ok;
        }

        /* 2.- There are header and mmaped content to send
         */
        bufs[0].iov_base = conn->buffer.buf;
        bufs[0].iov_len  = conn->buffer.len;
        if (likely (conn->mmaped_len > 0)) {
                bufs[1].iov_base = conn->mmaped;
                bufs[1].iov_len  = conn->mmaped_len;
                nvec = 2;
        }
        ret = cherokee_socket_writev (&conn->socket, bufs, nvec, &re);
        if (unlikely (ret != ret_ok)) {
                switch (ret) {

                case ret_eof:
                case ret_eagain: 
                        return ret;

                case ret_error:
                        conn->keepalive = 0;
                        return ret_error;

                default:
                        RET_UNKNOWN(ret);
                        return ret_error;
                }
        }
        /* Add to the connection traffic counter
         */
        cherokee_connection_tx_add (conn, re);

        /* writev() may not have sent all headers data.
         */
        if (unlikely (re < (size_t) conn->buffer.len)) {
                /* Partial header data sent.
                 */
                cherokee_buffer_move_to_begin (&conn->buffer, re);
                return ret_eagain;
        }

        /* OK, all headers have been sent,
         * subtract from amount sent and clean header buffer.
         */
        re -= (size_t) conn->buffer.len;
        cherokee_buffer_clean (&conn->buffer);

        /* NOTE: conn->mmaped is a ptr. to void
         * so we have to apply ptr. math carefully.
         */
        conn->mmaped      = (void *) ( ((char *)conn->mmaped) + re );
        conn->mmaped_len -= (off_t) re;

        return (conn->mmaped_len > 0) ? ret_eagain : ret_ok;
}


void
cherokee_connection_rx_add (cherokee_connection_t *conn, ssize_t rx)
{
        conn->rx += rx;
        conn->rx_partial += rx;
}


void
cherokee_connection_tx_add (cherokee_connection_t *conn, ssize_t tx)
{
        conn->tx += tx;
        conn->tx_partial += tx;
}


ret_t
cherokee_connection_recv (cherokee_connection_t *conn, cherokee_buffer_t *buffer, off_t *len)
{
        ret_t  ret;
        size_t cnt_read = 0;
        
        ret = cherokee_socket_bufread (&conn->socket, buffer, DEFAULT_RECV_SIZE, &cnt_read);
        switch (ret) {
        case ret_ok:
                cherokee_connection_rx_add (conn, cnt_read);
                *len = cnt_read;
                return ret_ok;

        case ret_eof:
        case ret_error:
                return ret;

        case ret_eagain:
                if (cherokee_socket_pending_read (&conn->socket)) {
                        CONN_THREAD(conn)->pending_read_num += 1;
                }
                return ret_eagain;

        default:
                RET_UNKNOWN(ret);               
                return ret_error;
        }
        /* NOTREACHED */
}


ret_t 
cherokee_connection_reading_check (cherokee_connection_t *conn)
{
        /* Check for too long headers
         */
        if (conn->incoming_header.len > MAX_HEADER_LEN) {
                conn->error_code = http_request_entity_too_large;
                return ret_error;
        }

        return ret_ok;
}


ret_t 
cherokee_connection_set_cork (cherokee_connection_t *conn, 
                              cherokee_boolean_t     enable)
{
        ret_t ret;

        ret = cherokee_socket_set_cork (&conn->socket, enable);
        if (unlikely (ret != ret_ok)) {
                return ret;
        }

        if (enable)
                BIT_SET (conn->options, conn_op_tcp_cork);
        else
                BIT_UNSET (conn->options, conn_op_tcp_cork);

        return ret_ok;
}


ret_t
cherokee_connection_send_header (cherokee_connection_t *conn)
{
        ret_t  ret;
        size_t sent = 0;

        if (cherokee_buffer_is_empty (&conn->buffer))
                return ret_ok;

        /* Send the buffer content
         */
        ret = cherokee_socket_bufwrite (&conn->socket, &conn->buffer, &sent);
        if (unlikely(ret != ret_ok)) return ret;
        
        /* Add to the connection traffic counter
         */
        cherokee_connection_tx_add (conn, sent);

        /* Drop out the sent data
         */
        if (sent == conn->buffer.len) {
                cherokee_buffer_clean (&conn->buffer);
                return ret_ok;
        }

        /* There is still some data waiting to be sent
         */
        cherokee_buffer_move_to_begin (&conn->buffer, sent);
        return ret_eagain;
}


ret_t
cherokee_connection_send (cherokee_connection_t *conn)
{
        ret_t  ret;
        size_t sent = 0;

        /* Use writev to send the chunk-begin mark
         */
        if (conn->chunked_encoding) 
        {
                struct iovec tmp[3];

                tmp[0].iov_base = conn->chunked_len.buf;
                tmp[0].iov_len  = conn->chunked_len.len;
                tmp[1].iov_base = conn->buffer.buf;
                tmp[1].iov_len  = conn->buffer.len;

                if (conn->chunked_last_package) {
                        tmp[2].iov_base = CRLF "0" CRLF CRLF;
                        tmp[2].iov_len  = 7;
                } else {
                        tmp[2].iov_base = CRLF;
                        tmp[2].iov_len  = 2;
                }

                cherokee_iovec_skip_sent (tmp, 3, 
                                          conn->chunks, &conn->chunksn,
                                          conn->chunked_sent);

                ret = cherokee_socket_writev (&conn->socket, conn->chunks, conn->chunksn, &sent);
                if (unlikely (ret != ret_ok)) {
                        switch (ret) {
                        case ret_eof:
                        case ret_eagain: 
                                return ret;
                                
                        case ret_error:
                                conn->keepalive = 0;
                                return ret_error;
                                
                        default:
                                RET_UNKNOWN(ret);
                                return ret_error;
                        }
                }

                conn->chunked_sent += sent;

                /* Clean the information buffer only when everything
                 * has been sent.
                 */
                ret = cherokee_iovec_was_sent (tmp, 3, conn->chunked_sent);
                if (ret == ret_ok) {
                        cherokee_buffer_clean (&conn->chunked_len);
                        cherokee_buffer_clean (&conn->buffer);
                        ret = ret_ok;
                } else {
                        ret = ret_eagain;
                }

                goto out;
        }

        /* Send the buffer content
         */
        ret = cherokee_socket_bufwrite (&conn->socket, &conn->buffer, &sent);
        if (unlikely(ret != ret_ok)) return ret;

        /* Drop out the sent info
         */
        if (sent == conn->buffer.len) {
                cherokee_buffer_clean (&conn->buffer);
                ret = ret_ok;
        } else if (sent != 0) {
                cherokee_buffer_move_to_begin (&conn->buffer, sent);
                ret = ret_eagain;
        }

out:
        /* Add to the connection traffic counter
         */
        cherokee_connection_tx_add (conn, sent);

        /* If this connection has a handler without Content-Length support
         * it has to count the bytes sent
         */
        if (!HANDLER_SUPPORTS (conn->handler, hsupport_length)) {
                conn->range_end += sent;
        }

        return ret;
}


ret_t 
cherokee_connection_shutdown_wr (cherokee_connection_t *conn)
{
        /* At this point, we don't want to follow the TLS protocol
         * any longer.
         */
        conn->socket.is_tls = non_TLS;

        /* Set the timeout for future linger read(s) leaving the
         * non-blocking mode.
         */
        conn->timeout = CONN_THREAD(conn)->bogo_now + (MSECONDS_TO_LINGER / 1000) + 1;

        /* Shut down the socket for write, which will send a FIN to
         * the peer. If shutdown fails then the socket is unusable.
         */
        return cherokee_socket_shutdown (&conn->socket, SHUT_WR);
}


ret_t 
cherokee_connection_linger_read (cherokee_connection_t *conn)
{
        ret_t              ret;
        size_t             cnt_read = 0;
        int                retries  = 2;
        cherokee_thread_t *thread   = CONN_THREAD(conn);
        cherokee_buffer_t *tmp1     = THREAD_TMP_BUF1(thread);

        while (true) {
                /* Read from the socket to nowhere
                 */
                ret = cherokee_socket_read (&conn->socket, tmp1->buf, tmp1->size, &cnt_read);
                switch (ret) {
                case ret_eof:
                        TRACE(ENTRIES, "%s\n", "eof");
                        return ret;
                case ret_error:
                        TRACE(ENTRIES, "%s\n", "error");
                        return ret;
                case ret_eagain:
                        TRACE(ENTRIES, "read %u, eagain\n", cnt_read);
                        return ret;
                case ret_ok:
                        TRACE(ENTRIES, "read %u, ok\n", cnt_read);
                        retries--;
                        if (cnt_read == tmp1->size && retries > 0)
                                continue;
                        return ret;
                default:
                        RET_UNKNOWN(ret);               
                        return ret_error;
                }
                /* NOTREACHED */
        }
}


ret_t
cherokee_connection_step (cherokee_connection_t *conn)
{
        ret_t ret;
        ret_t step_ret = ret_ok;

        return_if_fail (conn->handler != NULL, ret_error);

        /* Need to 'read' from handler ?
      &