root/http/request.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_REQUEST_HH
#define GUARD_HTTP_REQUEST_HH

#include "../server.hh"
#include "../uri.hh"

#include <boost/noncopyable.hpp>
#include <map>

namespace db { class user; }

namespace http
{
        class request : private boost::noncopyable
        {
        public:
                typedef std::multimap<std::string,std::string>::const_iterator
                form_data_iterator;

                request(std::string, server::conn_cb cb,
                        boost::asio::ip::address);
                bool get_v11() const { return v11; }
                bool get_close() const { return close; }

                void body_append(std::string b) {
                        form_data_ready = false;
                        body += b;
                }
                std::string get_body() const { return body; }

                bool has_body() const {
                        return  header.find("transfer-encoding") != header.end()
                                ||
                                header.find("content-length") != header.end();
                }

                ::uri get_uri() const { return uri; }

                std::string get_method() const { return method; }
                std::string get_host() const { return host; }
                int get_port() const { return port; }
                std::string get_path() const { return uri.get_path(); }

                std::string get_form_field(std::string name) const;
                bool has_form_field(std::string name) const;
                std::pair<form_data_iterator,form_data_iterator>
                get_form_fields(std::string name) const {
                        if (!form_data_ready) parse_form();
                        return form_data.equal_range(name);
                }

                std::string get_form_as_query() const;
                
                std::string get_header(std::string s) const;

                std::string logbit() const {
                        return get_method() + " " + get_path() + 
                                " (" + get_header("referer") + ")" +
                                " [" + get_header("user-agent") + "]"; 
                }

                std::string get_sessid() const;
                boost::shared_ptr<session> &get_session() const;

                bool is_authenticated() const;
                boost::shared_ptr<db::user> get_user() const;

                boost::asio::ip::address get_peer() const { return peer; }

        private:
                server::conn_cb cb;
                boost::asio::ip::address peer;
                std::string method;
                std::map<std::string, std::string> header;
                bool v11;
                bool close;
                ::uri uri;
                std::string host;
                int port;
                std::string body;
                mutable bool form_data_ready;
                mutable std::multimap<std::string,std::string> form_data;

                void parse_header(std::string);
                void parse_form() const;
        };

        inline
        std::string request::get_form_field(std::string k) const
        {
                if (!form_data_ready) parse_form();
                std::multimap<std::string, std::string>::const_iterator it 
                        = form_data.find(k);
                if (it == form_data.end())
                {
                        return "";
                }
                return it->second;
        }
        inline
        bool request::has_form_field(std::string k) const
        {
                if (!form_data_ready) parse_form();
                std::multimap<std::string, std::string>::const_iterator it 
                        = form_data.find(k);
                return it != form_data.end();
        }
}

#endif /* GUARD_HTTP_REQUEST_HH */