root/alue_posix.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 "config.hh"
#include "http/connection.hh"
#include "logger/logline.hh"
#include "nntp/connection.hh"
#include "server.hh"
#include "tls/init.hh"

#include <boost/asio.hpp>
#include <cerrno>
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include <exception>
#include <execinfo.h>
#include <iostream>
#include <grp.h>
#include <pwd.h>
#include <signal.h>
#include <sys/resource.h>
#include <unistd.h>

namespace {
        server *hup_server;
        void hup_handler(int)
        {
                hup_server->hup();
        }

        void abort_handler(int)
        {
                static void *array[50];
                size_t size;
                size = backtrace(array, sizeof array / sizeof *array);
                backtrace_symbols_fd(array, size, 2);
                _exit(1);
        }
}

int main(int argc, char *argv[])
{

        rlimit rlim;
        configure(argc, argv, rlim);

        if (config.count("operator-email") == 0)
        {
                std::cerr << "operator-email is mandatory" << std::endl;
        }

        passwd *pw = 0;
        if (!config["user"].empty()) {
                pw = getpwnam(config["user"].as<std::string>().c_str());
                if (pw == 0) {
                        std::cerr << "invalid user (" << strerror(errno)
                                  << ")"
                                  << std::endl;
                        return 1;
                }
        }

        if ((getuid() == 0 || geteuid() == 0) && 
            config["user"].empty()) {
                std::cerr << "started as root: --user is mandatory\n";
                return 1;
        }
        
        if (setrlimit(RLIMIT_AS, &rlim) == -1)
        {
                std::cerr << "setrlimit failed: " << strerror(errno) 
                          << std::endl;
                return 1;
        }

        std::string homedir = config["home"].as<std::string>();

        if (chdir(homedir.c_str()) == -1)
        {
                std::cerr << "chdir failed: " << std::strerror(errno)
                          << std::endl;
                return 1;
        }

        logger::logger.open(config["logfile"].as<std::string>());

        if (config["daemon"].as<bool>())
        {
                switch (fork())
                {
                case 0:
                        break;
                default:
                        _exit(0);
                case -1:
                        std::cerr << "fork failed: " 
                                  << std::strerror(errno)
                                  << std::endl;
                        return 1;
                }
                
                if (setsid() == (pid_t) -1)
                {
                        logger::logline ll;
                        ll << "setsid failed: " << std::strerror(errno);
                        return 1;
                }
                
                switch (fork())
                {
                case 0:
                        break;
                default:
                        _exit(0);
                case -1:
                        logger::logline ll;
                        std::cerr << "fork failed: "  << std::strerror(errno);
                        return 1;
                }
         
                umask(0);
        }

        struct sigaction sact;
        sact.sa_handler = abort_handler;
        sigemptyset(&sact.sa_mask);
        sact.sa_flags = 0;
        sigaction(SIGABRT, &sact, 0);

        try {
                               
                std::map<std::string,std::pair
                        <boost::shared_ptr<server::connection_factory>, bool> >
                        ports;

                ports[config["nntp-port"].as<std::string>()].first.reset
                        (new nntp::connection::factory(false));
                ports[config["nntp-port"].as<std::string>()].second = 
                        config["log-nntp"].as<bool>();
                
                ports[config["nntps-port"].as<std::string>()].first.reset
                        (new nntp::connection::factory(true));
                ports[config["nntps-port"].as<std::string>()].second = 
                        config["log-nntp"].as<bool>();
                
                ports[config["https-port"].as<std::string>()].first.reset
                        (new http::connection::factory(true));
                ports[config["https-port"].as<std::string>()].second = 
                        config["log-http"].as<bool>();
                
                tls::init tls_init
                        (config["cert-file"].as<std::string>().c_str(),
                         config["key-file"].as<std::string>().c_str(),
                         tls::init::pem);
                
                boost::asio::io_service ios;
                server srv(ios, tls_init, ports);
                
                hup_server = &srv;
                sact.sa_handler = hup_handler;
                sigaction(SIGHUP, &sact, 0);
                
                if (getuid() == 0 || geteuid() == 0) {
                        if (setgroups(0, 0) == -1) {
                                logger::logline ll;
                                ll << "setgroups failed: " << strerror(errno);
                                return 1;
                        }
                        if (setgid(pw->pw_gid) == -1) {
                                logger::logline ll;
                                ll << "setgid failed: " << strerror(errno);
                                return 1;
                        }
                        if (setuid(pw->pw_uid) == -1) {
                                logger::logline ll;
                                ll << "setuid failed: " << strerror(errno);
                                return 1;
                        }
                }
                
                srv.run();
        }
        catch (std::exception &e)
        {
                logger::logline ll;
                ll << "exiting due to exception "
                   << typeid(e).name()
                   << ": "
                   << e.what();
                ll.close();
                logger::logger.flush();
                return 1;
        }
}