root/http/confirm.cc

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

    Copyright © 2009, 2010, 2011 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 "error_resource.hh"
#include "reauthn_resource.hh"
#include "redir_resource.hh"
#include "request.hh"
#include "templated_resource.hh"
#include "token.hh"

#include "../config.hh"
#include "../db/db.hh"
#include "../db/user.hh"
#include "../html/util.hh"
#include "../msg/lexutils.hh"
#include "../tlate/tlate.hh"
#include "../smtp_client/smtp_client.hh"

#define REQPATH "/confirm"
#define REQPREFIX REQPATH "/"

namespace http
{
        class confirm : public templated_resource
        {
        public:
                confirm(server::conn_cb cb) 
                        : templated_resource(cb, "confirm.html")
                        {}
                void set_attributes(boost::shared_ptr<request>,
                                    tlate::data_model::ptr);
        };

        void confirm::set_attributes(boost::shared_ptr<request> req,
                                     tlate::data_model::ptr am)
        {
                std::string (*const q)(std::string,bool) = html::quote;
                std::string (*const p)(std::string) = uri::percent_encode;
                std::string (*const dep)(std::string) = uri::percent_decode;

                if (req->get_path().length() <= sizeof REQPREFIX - 1)
                {
                        boost::shared_ptr<resource> er
                                (new error_resource(cb, "404 Not found"));
                        throw resource_exception(er);
                }

                if (!req->is_authenticated())
                {
                        boost::shared_ptr<resource> er
                                (new reauthn_resource(cb));
                        throw resource_exception(er);
                }

                boost::shared_ptr<db::user> u = req->get_user();

                std::string tokstr =
                        dep(req->get_path().substr(sizeof REQPREFIX - 1));

                if (req->get_method() == "POST")
                {
                        boost::shared_ptr<resource> er;
                        if (u->verify_delivery_email(tokstr, cb))
                                er.reset(new redir_resource(cb,
                                                            "/confirmed.html",
                                                            "303 See other"));
                        else
                                er.reset(new error_resource
                                         (cb, "410 Invalid or expired link"));
                        throw resource_exception(er);
                }
                am->insert("userid", q(u->get_userid(), false));
                am->insert("username", q(u->get_display_name(), false));
                am->insert("diaddr", q(u->get_delivery_email(), false));
                am->insert("action", q(REQPREFIX + p(tokstr), false));
                am->insert("method", "post");
                am->insert("enctype", "application/x-www-form-urlencoded");
                am->insert("accept_charlist", q("utf8",false));
        }
};

namespace
{
        class factory : public server::http_resource_factory
        {
        public:
                factory() {
                        server::register_http_resource(REQPATH, this);
                }
                boost::shared_ptr<http::resource> operator()
                (server::conn_cb cb, std::string) {
                        boost::shared_ptr<http::resource> rv
                                (new http::confirm(cb));
                        return rv;
                }
        };
        factory f;
}