smtp_client.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_SMTP_CLIENT_HPP
#define JOIN_SERVICES_SMTP_CLIENT_HPP
 
// libjoin.
#include <join/socket_stream.hpp>
#include <join/smtp_protocol.hpp>
#include <join/smtp_message.hpp>
#include <join/tls_stream.hpp>
#include <join/resolver.hpp>
#include <join/base64.hpp>
 
namespace join
{
    template <class Protocol>
    class BasicSmtpClient
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
        using Stream = typename Protocol::Stream;
 
        BasicSmtpClient (const char* host, uint16_t port = Protocol::defaultPort)
        : _host (host)
        , _port (port)
        {
        }
 
        BasicSmtpClient (const std::string& host, uint16_t port = Protocol::defaultPort)
        : BasicSmtpClient (host.c_str (), port)
        {
        }
 
        BasicSmtpClient (TlsContext ctx, const char* host, uint16_t port = Protocol::defaultPort)
        : _stream (std::move (ctx))
        , _host (host)
        , _port (port)
        {
        }
 
        BasicSmtpClient (TlsContext ctx, const std::string& host, uint16_t port = Protocol::defaultPort)
        : BasicSmtpClient (std::move (ctx), host.c_str (), port)
        {
        }
 
        BasicSmtpClient (const BasicSmtpClient& other) = delete;
 
        BasicSmtpClient& operator= (const BasicSmtpClient& other) = delete;
 
        BasicSmtpClient (BasicSmtpClient&& other)
        : _stream (std::move (other._stream))
        , _host (std::move (other._host))
        , _port (other._port)
        , _login (std::move (other._login))
        , _password (std::move (other._password))
        {
        }
 
        BasicSmtpClient& operator= (BasicSmtpClient&& other)
        {
            this->_stream = std::move (other._stream);
            this->_host = std::move (other._host);
            this->_port = other._port;
            this->_login = std::move (other._login);
            this->_password = std::move (other._password);
            return *this;
        }
 
        virtual ~BasicSmtpClient () = default;
 
        virtual std::string scheme () const
        {
            return "smtp";
        }
 
        const std::string& host () const
        {
            return this->_host;
        }
 
        uint16_t port () const
        {
            return this->_port;
        }
 
        std::string authority () const
        {
            std::string auth;
 
            if (IpAddress::isIpv6Address (this->host ()))
            {
                auth += "[" + this->host () + "]";
            }
            else
            {
                auth += this->host ();
            }
 
            if (this->port () != Dns::Resolver::resolveService (this->scheme ()))
            {
                auth += ":" + std::to_string (this->port ());
            }
 
            return auth;
        }
 
        std::string url () const
        {
            return this->scheme () + "://" + this->authority ();
        }
 
        void credentials (const std::string& login, const std::string& password)
        {
            this->_login = login;
            this->_password = password;
        }
 
        int send (const SmtpMessage& message)
        {
            Endpoint endpoint{Dns::Resolver::lookupAddress (this->host ()), this->port ()};
            endpoint.hostname (this->host ());
 
            if (this->connect (endpoint) == -1)
            {
                this->close ();
                return -1;
            }
 
            if (this->greeting () == -1)
            {
                this->close ();
                return -1;
            }
 
            std::vector<std::string> replies;
 
            for (;;)
            {
                replies.clear ();
 
                if (this->initialize (replies) == -1)
                {
                    this->close ();
                    return -1;
                }
 
                if (std::find (replies.begin (), replies.end (), "STARTTLS") != replies.end ())
                {
                    if (this->startTls () == -1)
                    {
                        this->close ();
                        return -1;
                    }
                    continue;
                }
 
                break;
            }
 
            auto auth = std::find_if (replies.begin (), replies.end (), [] (auto const& r) {
                return r.find ("AUTH") != std::string::npos;
            });
            if (auth != replies.end ())
            {
                if (auth->find ("LOGIN") != std::string::npos)
                {
                    if (this->loginAuthenticate () == -1)
                    {
                        this->close ();
                        return -1;
                    }
                }
                else if (auth->find ("PLAIN") != std::string::npos)
                {
                    if (this->plainAuthenticate () == -1)
                    {
                        this->close ();
                        return -1;
                    }
                }
            }
 
            if (this->sendFrom (message) == -1)
            {
                this->close ();
                return -1;
            }
 
            if (this->sendTo (message) == -1)
            {
                this->close ();
                return -1;
            }
 
            if (this->sendData (message) == -1)
            {
                this->close ();
                return -1;
            }
 
            if (this->quit () == -1)
            {
                this->close ();
                return -1;
            }
 
            this->close ();
            return 0;
        }
 
    protected:
        virtual int connect (const Endpoint& endpoint)
        {
            this->_stream.connect (endpoint);
            return this->_stream.fail () ? -1 : 0;
        }
 
        void close ()
        {
            this->_stream.disconnect ();
            this->_stream.close ();
            this->_stream.clear ();
        }
 
        int sendMessage (const std::string& message)
        {
#ifdef DEBUG
            std::cout << message << std::endl;
#endif
            this->_stream.write (message.c_str (), message.size ());
            this->_stream.write ("\r\n", 2);
            this->_stream.flush ();
            return this->_stream.fail () ? -1 : 0;
        }
 
        std::string readReplies (std::vector<std::string>* replies = nullptr)
        {
            std::string reply, code;
            for (;;)
            {
                if (!join::getline (this->_stream, reply))
                {
                    return {};
                }
#ifdef DEBUG
                std::cout << reply << std::endl;
#endif
                if ((reply.find ("-") != 3) && (reply.find (" ") != 3))
                {
                    join::lastError = make_error_code (Errc::MessageUnknown);
                    return {};
                }
                if (code.empty ())
                {
                    code = reply.substr (0, 3);
                }
                if (replies)
                {
                    replies->push_back (reply.substr (4));
                }
                if (reply[3] == ' ')
                {
                    break;
                }
            }
            return code;
        }
 
        int greeting ()
        {
            if (this->readReplies () != "220")
            {
                return -1;
            }
            return 0;
        }
 
        int initialize (std::vector<std::string>& replies)
        {
            if (this->sendMessage ("EHLO " + this->hostname ()) == -1)
            {
                return -1;
            }
            if (this->readReplies (&replies) != "250")
            {
                return -1;
            }
            return 0;
        }
 
        int startTls ()
        {
            if (this->sendMessage ("STARTTLS") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "220")
            {
                return -1;
            }
            this->_stream.handshake ();
            if (this->_stream.fail ())
            {
                return -1;
            }
            return 0;
        }
 
        int loginAuthenticate ()
        {
            if (this->sendMessage ("AUTH LOGIN") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "334")
            {
                return -1;
            }
            if (this->sendMessage (Base64::encode (this->_login)) == -1)
            {
                return -1;
            }
            if (this->readReplies () != "334")
            {
                return -1;
            }
            if (this->sendMessage (Base64::encode (this->_password)) == -1)
            {
                return -1;
            }
            if (this->readReplies () != "235")
            {
                return -1;
            }
            return 0;
        }
 
        int plainAuthenticate ()
        {
            if (this->sendMessage ("AUTH PLAIN") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "334")
            {
                return -1;
            }
            if (this->sendMessage (Base64::encode ('\0' + this->_login + '\0' + this->_password)) == -1)
            {
                return -1;
            }
            if (this->readReplies () != "235")
            {
                return -1;
            }
            return 0;
        }
 
        int sendFrom (const SmtpMessage& message)
        {
            if (this->sendMessage ("MAIL FROM: <" + message.sender ().address () + ">") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "250")
            {
                return -1;
            }
            return 0;
        }
 
        int sendTo (const SmtpMessage& message)
        {
            for (auto const& recipient : message.recipients ())
            {
                if (this->sendMessage ("RCPT TO: <" + recipient.address () + ">") == -1)
                {
                    return -1;
                }
                if (this->readReplies () != "250")
                {
                    return -1;
                }
            }
            return 0;
        }
 
        int sendData (const SmtpMessage& message)
        {
            if (this->sendMessage ("DATA") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "354")
            {
                return -1;
            }
            if (message.writeHeaders (this->_stream) == -1)
            {
                return -1;
            }
            if (message.writeContent (this->_stream) == -1)
            {
                return -1;
            }
            if (this->readReplies () != "250")
            {
                return -1;
            }
            return 0;
        }
 
        int quit ()
        {
            if (this->sendMessage ("QUIT") == -1)
            {
                return -1;
            }
            if (this->readReplies () != "221")
            {
                return -1;
            }
            return 0;
        }
 
        std::string hostname () const
        {
            char name[255] = {};
            gethostname (name, sizeof (name));
            return name;
        }
 
        Stream _stream;
 
        std::string _host;
 
        uint16_t _port;
 
        std::string _login;
 
        std::string _password;
    };
 
    template <class Protocol>
    class BasicSmtpSecureClient : public BasicSmtpClient<Protocol>
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
 
        BasicSmtpSecureClient (TlsContext ctx, const char* host, uint16_t port = Protocol::defaultPort)
        : BasicSmtpClient<Protocol> (std::move (ctx), host, port)
        {
        }
 
        BasicSmtpSecureClient (TlsContext ctx, const std::string& host, uint16_t port = Protocol::defaultPort)
        : BasicSmtpSecureClient (std::move (ctx), host.c_str (), port)
        {
        }
 
        BasicSmtpSecureClient (const BasicSmtpSecureClient& other) = delete;
 
        BasicSmtpSecureClient& operator= (const BasicSmtpSecureClient& other) = delete;
 
        BasicSmtpSecureClient (BasicSmtpSecureClient&& other)
        : BasicSmtpClient<Protocol> (std::move (other))
        {
        }
 
        BasicSmtpSecureClient& operator= (BasicSmtpSecureClient&& other)
        {
            BasicSmtpClient<Protocol>::operator= (std::move (other));
            return *this;
        }
 
        virtual ~BasicSmtpSecureClient () = default;
 
        std::string scheme () const override
        {
            return "smtps";
        }
 
    protected:
        int connect (const Endpoint& endpoint) override
        {
            this->_stream.connect (endpoint);
            if (this->_stream.fail ())
            {
                return -1;
            }
            this->_stream.handshake ();
            return this->_stream.fail () ? -1 : 0;
        }
    };
}
 
#endif