root/inject-email.cc

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

    Copyright © 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 <boost/assert.hpp>
#include <boost/asio.hpp>
#include <cerrno>
#include <execinfo.h>
#include <iostream>
#include <sysexits.h>

namespace boost
{
        void assertion_failed(char const *expr,
                              char const *function,
                              char const *file,
                              long line)
        {
                std::cerr << "ASSERTION FAILED at "
                          << file << ":"
                          << line
                          << " [" << function << "]: "
                          << expr
                          << "\n";

                static void *array[250];
                size_t size;
                size = backtrace(array, sizeof array / sizeof *array);
                char **bt = backtrace_symbols(array, size);

                std::cerr << "BACKTRACE FOLLOWS:\n";
                for (size_t i = 0; i < size; i++)
                {
                        std::cerr << "\t" << bt[i] << "\n";
                }

                std::free(bt);

                throw std::logic_error("internal error");
        }
}

int main(int argc, char *argv[])
{
        rlimit rlim;
        configure(argc, argv, rlim);

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

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

        char *recip = ::getenv("ORIGINAL_RECIPIENT");
        if (recip == 0) recip = ::getenv("RECIPIENT");
                
        char *sender = ::getenv("SENDER");
        if (recip == 0 || sender == 0)
        {
                std::cerr << "invalid environment\n";
                return EX_CONFIG;
        }

        std::string group = recip;
        int at = group.find('@');
        if (at != std::string::npos) group = group.substr(0, at);

        typedef boost::asio::local::stream_protocol sp;

        boost::asio::io_service ios;
        sp::endpoint ep(config["unix-socket"].as<std::string>());
        try
        {
                sp::socket so(ios);
                so.connect(ep);

                std::ostringstream msg;

                msg << "ACTION: POST\r\n"
                    << "GROUP: " << group << "\r\n"
                    << "SENDER: " << sender << "\r\n"
                    << "\r\n";

                bool cr = false;
                bool sol = true;
                while (true)
                {
                        int c = std::cin.get();
                        if (c == -1) break;
                        switch (c)
                        {
                        case '\r':
                                sol = true;
                                if (cr) msg << "\n"; else cr = true;
                                break;
                        case '\n':
                                sol = true;
                                if (!cr) msg << "\r";
                                cr = false;
                                break;
                        default:
                                cr = false;
                                sol = false;
                        }
                        msg << (unsigned char)c;
                }
                if (!sol)
                {
                        if (cr) msg << "\n"; else msg << "\r\n";
                }

                std::string msgb = msg.str();

                boost::asio::write(so, boost::asio::buffer(msgb.data(),
                                                           msgb.length()));
                so.shutdown(sp::socket::shutdown_send);

                boost::asio::streambuf sb;
                std::istream is(&sb);

                try
                {
                        boost::asio::read(so, sb);
                }
                catch (boost::system::system_error &e)
                {
                        if (e.code() != boost::asio::error::eof) throw;
                }

                int ex;
                is >> ex;
                std::string tmp;
                std::getline(is, tmp);

                std::cerr << &sb;
                
                return ex;

        }
        catch (std::exception &e)
        {
                std::cout << e.what() << "\n";
                return EX_TEMPFAIL;
        }
}