root/http/connection.hh

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

 */

#ifndef GUARD_HTTP_CONNECTION_HH
#define GUARD_HTTP_CONNECTION_HH

#include "../tls/session.hh"
#include "../server.hh"
#include "response.hh"

#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>

namespace http
{
        class connection : public server::connection
                         , public boost::enable_shared_from_this<connection>
        {
        public:
                typedef boost::shared_ptr<connection> ptr;
                class factory : public server::connection_factory
                {
                        bool https;
                public:
                        factory(bool https) : https(https) {}
                        boost::shared_ptr<server::connection>
                        operator()(std::string port_name,
                                   boost::asio::ip::tcp::acceptor &acc,
                                   tls::init init,
                                   server::conn_cb srv_cb) {
                                boost::shared_ptr<server::connection> rv
                                        (new connection(port_name, https,
                                                        acc, init, srv_cb));
                                return rv;
                        }
                };
                std::string get_port_name() const { return port_name; }
                boost::shared_ptr<server::connection_factory> 
                get_factory() const {
                        boost::shared_ptr<server::connection_factory> rv
                                (new factory(https));
                        return rv;
                }

                connection(std::string port_name,
                           bool https,
                           boost::asio::ip::tcp::acceptor &acc,
                           tls::init,
                           server::conn_cb srv_cb);

                ~connection();

                server::conn_cb get_srv_cb() { return srv_cb; }
        protected:
                server::conn_cb get_conn_cb() { return srv_cb; }
        private:
                const std::string port_name;
                const bool https;

                server::conn_cb srv_cb;
                boost::asio::io_service &ios;
                boost::asio::ip::tcp::endpoint ep;
                boost::asio::ip::tcp::socket peer;
                tls::session<boost::asio::ip::tcp::socket&> speer;

                std::string loghead;

                boost::posix_time::ptime startup_timestamp;
                boost::posix_time::ptime request_timestamp;
                size_t num_requests;
                bool idle;

                boost::asio::streambuf readbuf;

                void tick(bool);

                void accept(boost::system::error_code ec);

                /* these are static and take a shared pointer to the
                 * object to make sure that the object stays around
                 * (too bad "this" is not reference counted) */
                static void kill(ptr);
                static void abort(ptr, boost::system::error_code ec);
                static void get_request(ptr, boost::system::error_code ec);
                static void got_request(ptr,
                                        boost::system::error_code ec, size_t);
                static void reqcont(ptr self,
                                    boost::shared_ptr<request> req,
                                    boost::shared_ptr<response> resp,
                                    response::factory respfac,
                                    size_t bodylen,
                                    boost::system::error_code ec,
                                    std::size_t);
                static void sent_response(ptr,
                                          boost::shared_ptr<response>,
                                          boost::system::error_code ec, size_t);
        };
}

#endif /* GUARD_HTTP_CONNECTION_HH */