root/nntp/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_NNTP_CONNECTION_HH
#define GUARD_NNTP_CONNECTION_HH

#include "../db/article_number_type.hh"
#include "../tls/session.hh"
#include "../server.hh"

#include <boost/asio.hpp>
#include <boost/bind/protect.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <map>

namespace db { class group; }
namespace db { class user; }

namespace nntp 
{
        /** A connection object encapsulates a single NNTP client
            connection from the server's point of view.  It starts in
            the "waiting for a connection" state, and once a
            connection has been enabled, enters the
            respond-receive-dispatch loop.  Eventually, the connection
            enters the terminal state in anticipation of object
            destruction.

            The respond-receive-dispatch loop consists of three steps,
            mentioned in its name: first, the server's response (or,
            initially, the server's greeting) is transmitted.  Then
            the server waits for the client to send something
            (depending on the server state, either a command or a
            dot-stuffed text object).  Finally, the response is parsed
            and the appropriate command handler (a subclass of
            connection::command) is dispatched.  The command handler
            queues a response and then (in the common case) passes
            control back to the loop.

            The object hides all the details of asynchronous
            communication from the command implementations, providing
            an illusion of sequential execution in the common cases.
            The main exception to that illusion is a command (such as
            POST) that requires the client to provide a dot-stuffed
            text object; the command logic needs to be split into the
            initial command and a continuation object that handles the
            eventual text object.
         */
        class connection : public server::connection,
                           public boost::enable_shared_from_this<connection>
        {
        public:
                class factory : public server::connection_factory
                {
                        bool ssl;
                public:
                        factory(bool ssl) : ssl(ssl) {}
                        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, ssl,
                                                        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(initial_ssl));
                        return rv;
                }

                

                class command;
                typedef std::map<std::string, command *>::const_iterator
                command_iterator;

                class continuation : public boost::enable_shared_from_this
                                     <continuation>
                {
                public:
                        typedef boost::shared_ptr<continuation> ptr;
                        
                        virtual ~continuation() {}
                        virtual void sent(ptr lifeline,
                                          boost::system::error_code ec) = 0;
                };

                class read_handler : public boost::enable_shared_from_this
                                     <read_handler>
                {
                public:
                        typedef boost::shared_ptr<read_handler> ptr;
                        virtual ~read_handler() {}
                        virtual continuation::ptr operator()(std::string) = 0;
                };

                // interface to privates of connection presented to
                // command classes
                class cb
                {
                        boost::shared_ptr<connection> cp;
                        cb(boost::shared_ptr<connection> cp) : cp(cp) {}
                        friend class connection;
                public:
                        /* connection state access */
                        server::conn_cb srv_cb() { return cp->srv_cb; }
                        db::db &dbase() { return cp->srv_cb.dbase(); }
                        std::string loghead() { return cp->loghead; }
                        boost::shared_ptr<db::group> &current_group() { 
                                return cp->current_group;
                        }
                        db::article_number_type &current_article() { 
                                return cp->current_article; 
                        }
                        bool &capabilities_used() {
                                return cp->capabilities_used;
                        }
                        command_iterator cmds_begin() {
                                return cp->cmds->begin();
                        }
                        command_iterator cmds_end() { return cp->cmds->end(); }
                        boost::asio::ip::address peer() { 
                                return cp->ep.address(); 
                        }

                        bool tls_active() { return cp->tls_active; }

                        bool &identified() { return cp->identified; }
                        bool &authenticated() { return cp->authenticated; }
                        boost::shared_ptr<db::user> &identity() {
                                return cp->identity;
                        }

                        /* sending messages (these just queue, actual
                         * send happens after the command has returned
                         * a continuation) */

                        void send_line(std::string s) {
                                cp->send_line(s);
                        }

                        template <typename In>
                        void send_raw(In begin, In end) {
                                cp->send_raw(begin, end);
                        }

                        /* continuations */
                        continuation::ptr terminate() {
                                return cp->terminate;
                        }
                        continuation::ptr dispatch() { return cp->dispatch; }
                        continuation::ptr read_data(read_handler::ptr h) {
                                return cp->read_data(h);
                        }
                        continuation::ptr starttls() { return cp->starttls; }
                        continuation::ptr delay_fail(std::string line) {
                                return cp->delay_fail(line);
                        }
                };

                class command
                {
                public:
                        virtual ~command();
                        virtual continuation::ptr 
                        perform(cb, const std::string args[], size_t nargs)
                                const = 0;
                        virtual void write_capability_line(cb) const
                                {}
                };

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

                ~connection();
                          
                static void register_command(std::string name,
                                             command *cmd);

                struct overview_fmt_type {
                        std::string s;
                        bool full;
                };
                static const overview_fmt_type overview_fmt[];
                static const size_t overview_fmt_count;
        protected:
                server::conn_cb get_conn_cb() { return srv_cb; }
        private:
                const std::string port_name;
                const bool initial_ssl;

                /* connection state */
                boost::shared_ptr<db::group> current_group;
                db::article_number_type current_article;

                boost::shared_ptr<db::user> identity;
                bool identified;
                bool authenticated;

                /* connection statistics */
                boost::posix_time::ptime startup_timestamp;
                boost::posix_time::ptime client_activity_timestamp;
                size_t num_commands_served;
                size_t num_500_responses;
                bool capabilities_used;

                /* connection administration */
                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;

                bool tls_active;

                std::vector<unsigned char> writebuf;
                boost::asio::streambuf readbuf;

                void abort(boost::system::error_code ec);
                void accept(boost::system::error_code ec);
                void greet(boost::system::error_code ec);
                void flush_writebuf(continuation::ptr cont);

                void stats();
                void tick(bool);
                void kill();

                std::string loghead;

                /* command handlers */
                typedef std::map<std::string, command *> cmds_type;
                static cmds_type *cmds; /* must be a pointer, since we
                                         * cannot know for sure that
                                         * the map would be created
                                         * before the command objects,
                                         * otherwise */

                /* messaging */
                void send_line(std::string s) {
                        writebuf.reserve(writebuf.size()+s.length()+2);
                        for (size_t i = 0; i < s.length(); i++)
                                writebuf.push_back(s[i]);
                        writebuf.push_back('\r');
                        writebuf.push_back('\n');
                }
                template <typename In> void send_raw(In begin, In end) {
                        for (In it = begin; it != end; it++)
                                writebuf.push_back(*it);
                }

                class terminator : public continuation
                {
                        boost::shared_ptr<connection> cp;

                        void done(ptr, boost::system::error_code ec);
                public:
                        terminator(boost::shared_ptr<connection> cp)
                                : cp(cp) {}
                        void sent(ptr, boost::system::error_code ec);
                };
                continuation::ptr terminate;

                class dispatcher : public continuation
                {
                        boost::shared_ptr<connection> cp;

                        void received(ptr,
                                      boost::system::error_code e,
                                      std::size_t size);
                public:
                        dispatcher(boost::shared_ptr<connection> cp)
                                : cp(cp) {}
                        void sent(ptr, boost::system::error_code ec);
                };
                continuation::ptr dispatch;

                class reader : public continuation
                {
                        boost::shared_ptr<connection> cp;
                        read_handler::ptr h;

                        void received(ptr, size_t scanned,
                                      boost::system::error_code e,
                                      std::size_t size);
                public:
                        reader(boost::shared_ptr<connection> cp,
                               read_handler::ptr h)
                                : cp(cp), h(h) {}
                        void sent(ptr, boost::system::error_code ec);
                };
                
                continuation::ptr read_data(read_handler::ptr h) {
                        continuation::ptr rv(new reader(shared_from_this(), h));
                        return rv;
                }

                class tls_starter : public continuation
                {
                        boost::shared_ptr<connection> cp;
                public:
                        tls_starter(boost::shared_ptr<connection> cp)
                                : cp(cp) {}
                        void sent(ptr, boost::system::error_code ec);
                };
                continuation::ptr starttls;

                class failure_delayer : public continuation
                {
                        boost::shared_ptr<connection> cp;
                        boost::asio::deadline_timer timer;
                        std::string line;

                        void waited(ptr, boost::system::error_code ec);
                public:
                        failure_delayer(boost::shared_ptr<connection> cp,
                                        std::string line)
                                : cp(cp), timer(cp->ios), line(line)
                                {}
                        void sent(ptr, boost::system::error_code ec);
                };
                continuation::ptr delay_fail(std::string line) {
                        continuation::ptr rv
                                (new failure_delayer(shared_from_this(), line));
                        return rv;
                }
        };

        inline void connection::register_command(std::string name,
                                                 command *cmd)
        {
                if (cmds == 0) cmds = new cmds_type();
                (*cmds)[name] = cmd;
        }



};

#endif /* GUARD_NNTP_CONNECTION_HH */