root/http/connection.cc

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue 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 Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "bad_request.hh"
#include "connection.hh"
#include "request.hh"
#include "resource.hh"
#include "resource_exception.hh"
#include "unsupported_version.hh"

#include "../html/util.hh"
#include "../logger/logline.hh"
#include "../tls/session_impl.hh"
#include "../util.hh"

namespace http
{
        connection::connection(std::string port_name,
                               bool https,
                               boost::asio::ip::tcp::acceptor &acc,
                               tls::init tls_init,
                               server::conn_cb srv_cb)
                : port_name(port_name)
                , https(https)
                , srv_cb(srv_cb)
                , ios(acc.get_io_service())
                , peer(ios)
                , speer(peer, tls_init, tls::server)
                , startup_timestamp
                  (boost::posix_time::second_clock::universal_time())
                , request_timestamp(startup_timestamp)
                , num_requests(0)
                , idle(false)
        {
                acc.async_accept(peer, ep,
                                 boost::bind(&connection::accept, 
                                             this, _1));
        }

        connection::~connection() {}

        void connection::abort(ptr self,
                               boost::system::error_code ec)
        {
                logger::logline ll;
                ll << self->loghead
                   << "failure (" 
                   << ec.message()
                   << "), aborting connection";
                ll.close();
                logger::logger.flush();
                kill(self);
        }

        void connection::kill(ptr self)
        {
                self->srv_cb.terminal(self);
        }

        void connection::accept(boost::system::error_code ec)
        {
                /* keep the object alive as long as there is action by
                 passing around a shared pointer instead of using
                 the implicit this pointer */
                ptr self = shared_from_this();

                if (ec) { abort(self, ec); return; }

                self->startup_timestamp =
                        boost::posix_time::second_clock::universal_time();

                std::ostringstream ss;
                ss << "httpd for " << self->ep << " ";
                self->loghead = ss.str();

                logger::logline ll;
                ll << self->loghead << "starts";
                ll.close();
                self->srv_cb.active(self);
                logger::logger.flush();

                if (self->https)
                {
                        ll.open();
                        ll << self->loghead << "starting TLS negotiation";
                        ll.close();

                        self->speer.async_handshake
                                (bind(&connection::get_request, self, _1));
                }
                else
                {
                        get_request(self, ec);
                }
        }

        void connection::get_request(ptr self,
                                     boost::system::error_code ec)
        {
                using boost::asio::async_read_until;
                using boost::bind;

                if (ec) { abort(self, ec); return; }

                self->idle = true;

                async_read_until(self->speer, self->readbuf, "\r\n\r\n",
                                 bind(&connection::got_request,
                                      self, _1, _2));
        }

        void connection::got_request(ptr self,
                                     boost::system::error_code ec,
                                     std::size_t received_bytes)
        {
                using boost::asio::async_read;
                using boost::asio::async_write;
                using boost::asio::transfer_at_least;
                using boost::bind;
                using boost::shared_ptr;

                self->idle = false;
                ++self->num_requests;

                if (ec == boost::asio::error::eof)
                {
                        logger::logline ll;
                        ll << self->loghead
                           << "client closed the connection";
                        ll.close();
                        logger::logger.flush();
                        kill(self);
                        return;
                }
                if (ec) { abort(self, ec); return; }

                shared_ptr<request> req;
                shared_ptr<response> resp;
                response::factory respfac(self);
                size_t clen = 0;

                try
                {
                        std::string recv;
                        recv.reserve(received_bytes);
                        for (size_t i = 0; i < received_bytes; i++)
                                recv += self->readbuf.sbumpc();
                        
                        if (self->srv_cb.do_log_protocol_details())
                        {
                                logger::logline ll;
                                ll << self->loghead 
                                   << "got request (body excluded):\n"
                                   << recv;
                                ll.close();
                        }
                        self->srv_cb.active(self);

                        req.reset(new request(recv, self->srv_cb,
                                              self->ep.address()));
                        respfac.set_v11(req->get_v11());
                        respfac.set_close(req->get_close());
                        respfac.set_no_body(req->get_method() == "HEAD");

                        std::string clens = req->get_header("Content-Length");
                        if (!req->get_header("Transfer-Encoding").empty())
                        {
                                logger::logline ll;
                                ll << self->loghead
                                   << "FIXME: request includes T-E body";
                                ll.close();
                                respfac.set_close(true);
                        }
                        else if (!clens.empty())
                        {
                                util::strip(clens);
                                if (!util::is_number(clens)) 
                                        throw bad_request("bad Content-Length");
                                clen = boost::lexical_cast<size_t>(clens);
                                
                        }
                }
                catch (bad_request &e)
                {
                        respfac.set_close(true);
                        resp = respfac("400 Bad request");
                        std::ostream &os = resp->body("text/html; "
                                                      "charset=utf-8");
                        os << "<html>\n"
                           << "<title>400 Bad request</title>\n"
                           << "<h1>400 Bad request</h1>\n"
                           << "<p>The browser sent a bad request: "
                           << html::quote(e.what(),false)
                           << "<p>\n"
                           << "</html>";
                }
                catch (unsupported_version)
                {
                        respfac.set_close(true);
                        resp = respfac("505 Unsupported HTTP version");
                        std::ostream &os = resp->body("text/html; "
                                                      "charset=utf-8");
                        os << "<html>\n"
                           << "<title>505 Unsupported HTTP version</title>\n"
                           << "<h1>505 Unsupported HTTP version</h1>\n"
                           << "<p>The browser sent a request using an "
                           << "unsupported HTTP version.  This server "
                           << "supports only HTTP/1.x.  NNTP access "
                           << "is also provided on the customary port."
                           << "<p>\n"
                           << "</html>";
                }                

                reqcont(self, req, resp, respfac, clen, ec, 0);
        }

        void connection::reqcont(ptr self,
                                 boost::shared_ptr<request> req,
                                 boost::shared_ptr<response> resp,
                                 response::factory respfac,
                                 size_t clen,
                                 boost::system::error_code ec,
                                 std::size_t received_bytes)
        {
                using boost::asio::async_write;
                using boost::bind;
                using boost::shared_ptr;

                if (ec) { abort(self, ec); return; }

                if (clen > 0)
                {
                        std::string recv = util::streambuf_to_string
                                (self->readbuf, received_bytes);
                        req->body_append(recv);
                        clen -= recv.length();
                }
                if (clen > 0)
                {
                        self->speer.async_read_some(self->readbuf.prepare(clen),
                                                    bind(&connection::reqcont,
                                                         self, req,
                                                         resp, respfac,
                                                         clen,
                                                         _1, _2));
                        return;
                }

                self->request_timestamp =
                        boost::posix_time::microsec_clock::universal_time();

                if (self->srv_cb.do_log_protocol_details())
                {                
                        logger::logline ll;
                        ll << self->loghead << "request body:\n"
                           << req->get_body();
                        ll.close();
                }

                if (!resp)
                {
                        shared_ptr<resource> res;
                        boost::shared_ptr<session> s;
                        try {
                                 res = self->srv_cb.get_http_resource
                                         (req->get_host(), req->get_path());
                        } catch (http::resource_exception &e) {
                                res = e.r;
                                if (e.s) s = e.s;
                        }
                        try
                        {
                        redo:
                                try
                                {
                                        resp = (*res)(req, respfac);
                                        if (s) resp->set_session(req, s);
                                }
                                catch (http::resource_exception &e)
                                {
                                        res = e.r;
                                        s = e.s;
                                        goto redo;
                                }
                        }
                        catch (std::exception &e)
                        {
                                respfac.set_close(true);
                                resp = respfac("500 Service unavailable");
                                std::ostream &os = resp->body("text/html; "
                                                              "charset=utf-8");
                                os << "<html>\n"
                                   << "<title>500 Service unavailable</title>\n"
                                   << "<h1>500 Service unavailable</h1>\n"
                                   << "<p>There was a problem fulfilling "
                                   << "your request: "
                                   << html::quote(e.what(), false)
                                   << "<p>\n"
                                   << "</html>";
                                logger::logline ll;
                                ll << self->loghead
                                   << "exception caught:"
                                   << e.what()
                                   << " (" << typeid(e).name() << ")";
                                ll.close();
                        }
                }
                
                logger::logline ll;
                ll << self->loghead << (req ? req->logbit() : "") << " " 
                   << resp->logbit()
                   << "; "
                   << boost::posix_time::microsec_clock::universal_time() -
                        self->request_timestamp;
                ll.close();

                resp->complete();

                if (self->srv_cb.do_log_protocol_details())
                {
                        ll.open();
                        ll << "responding:\n" << resp->get_string();
                        ll.close();
                }

                async_write(self->speer, resp->get_buffer(),
                            bind(&connection::sent_response,
                                 self, resp, _1, _2));
        }

        void connection::sent_response(ptr self,
                                       boost::shared_ptr<response> resp,
                                       boost::system::error_code ec,
                                       size_t)
        {
                if (resp->get_close())
                {
                        kill(self);
                }
                else
                {
                        get_request(self, ec);
                }
        }

        void connection::tick(bool stats)
        {
                using namespace boost::posix_time;
                ptime now = microsec_clock::universal_time();
                bool kill = idle && num_requests != 0 &&
                        now - request_timestamp > minutes(10);

                if (stats || kill)
                {
                        logger::logline ll;
                        ll << loghead
                           << " age "
                           << now - startup_timestamp
                           << "; "
                           << (idle ? "idle " : "busy ")
                           << now - request_timestamp
                           << "; served " << num_requests << " requests";
                        if (kill) ll << "; killing";
                }
                if (kill) speer.kill();
        }

}