#include <iostream>
#include <istream>
#include <ostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/transform_width.hpp>
#include <boost/archive/iterators/ostream_iterator.hpp>

using boost::asio::ip::tcp;
using namespace boost::archive::iterators;
typedef base64_from_binary<transform_width<const char *, 6, 8> > base64_text;

class SMTPClient
{
public:
    enum AUTH_STATUS { AUTH_NONE, AUTHENTICATING, AUTHENTICATED, AUTHENTICATIONFAILED } mauth_status;
    SMTPClient(std::string pServer, unsigned int pPort, std::string pUser, std::string pPassword) :
        mServer(pServer), mPort(pPort), mUserName(pUser), mPassword(pPassword), mSocket(mIOService), mResolver(mIOService)
    {
        mauth_status = AUTH_NONE;
    }
    void Authenticate()
    {
        mauth_status = AUTHENTICATING;
        tcp::resolver::query qry(mServer, boost::lexical_cast<std::string>(mPort));
        mResolver.async_resolve(qry, boost::bind(&SMTPClient::handleResolve, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
        mIOService.run();
    }
    void Quit()
    {
        writeLine("QUIT");
        mIOService.stop();
    }
    bool Send(std::string pFrom, std::string pTo, std::string pSubject, std::string pMessage)
    {
        if (mauth_status != AUTHENTICATED || mHasError) {
            std::cout << "not authenticated ('" << mErrorMsg << "'). returning...";
            return false; // has error
        }
        std::cout << "SENDING ....";
        writeLine("MAIL FROM: \"ProWeb Alert\"<" + pFrom + ">");
        writeLine("RCPT TO:" + pTo);
        writeLine("DATA");
        writeLine("FROM:<" + pFrom + ">");
        writeLine("SUBJECT:" + pSubject);
        writeLine("");
        writeLine(pMessage);
        writeLine("");
        writeLine(".");
        return true;//TODO: smtp server response must be checked.
    }

private:
    std::string encodeBase64(std::string pData)
    {
        std::stringstream os;
        size_t sz = pData.size();
        std::copy(base64_text(pData.c_str()), base64_text(pData.c_str() + sz), ostream_iterator<char>(os));
        return os.str();
    }
    void handleResolve(const boost::system::error_code& err, tcp::resolver::iterator endpoint_iterator)
    {
        if (!err) {
            std::cout << " resolving done\n";
            tcp::endpoint endpoint = *endpoint_iterator;
            mSocket.async_connect(endpoint, boost::bind(&SMTPClient::handleConnect, this,
                boost::asio::placeholders::error, ++endpoint_iterator));
        }
        else {
            std::cout << " can't resolve\n";
            mHasError = true;
            mErrorMsg = err.message();
        }
    }
    void writeLine(std::string pData)
    {
        std::ostream req_strm(&mRequest);
        req_strm << pData << "\r\n";
        //std::cout << pData << "\r\n";
        boost::asio::write(mSocket, mRequest);
        req_strm.clear();
    }
    void handleConnect(const boost::system::error_code& err, tcp::resolver::iterator endpoint_iterator)
    {
        if (!err) {
            std::cout << " connected \n";
            // The connection was successful. Send the request.
            mHasError = false;
            std::ostream req_strm(&mRequest);
            writeLine("EHLO " + mServer);
            writeLine("AUTH LOGIN");
            writeLine(encodeBase64(mUserName));
            writeLine(encodeBase64(mPassword));
            mauth_status = AUTHENTICATED;
        }
        else {
            std::cout << " can not connect\n";
            mauth_status = AUTHENTICATIONFAILED;
            mHasError = true;
            mErrorMsg = err.message();
        }
    }

    std::string mServer;
    std::string mUserName;
    std::string mPassword;
    unsigned int mPort;
    boost::asio::io_service mIOService;
    tcp::resolver mResolver;
    tcp::socket mSocket;
    boost::asio::streambuf mRequest;
    boost::asio::streambuf mResponse;
    bool mHasError;
    std::string mErrorMsg;
    std::ostringstream mResponseData;
    std::ostringstream mResponseHeader;
};

int main()
{
    SMTPClient mailc("smtp.mail.ru", 25, "LOGIN", "PASSWORD");
    mailc.Authenticate();
    mailc.Send("LOGIN@mail.ru", "LOGIN@mail.ru", "subject", "Hello from C++ SMTP Client!");
}

#include <string>
#include <sstream>
#include <iostream>
#include <ctime>
#include <algorithm>
#include <random>
#include <curl/curl.h>

class EmailAddress 
{
public:
    EmailAddress(const char *email)
        : email_{email}
        {
        }

    EmailAddress(const std::string &email)
        : email_{email}
        {
        }

    EmailAddress(const std::string &email, const std::string &displayName)
        : email_{email.empty() ? "" : "<"+email+">"},
          name_{"\"" + displayName + "\""}
        {
        }

    std::string domain() const
        {
            return email_.substr(email_.find('@') + 1);
        }

    explicit operator const char *() const
        {
            return email_.c_str();
        }

    friend std::ostream &operator<<(std::ostream &out, const EmailAddress &email)
        {
            return out << email.name_ << " " << email.email_;
        }

private:
    std::string email_;
    std::string name_;
};

typedef std::vector<EmailAddress> EmailAddresses;
std::ostream &operator<<(std::ostream &out, const EmailAddresses &emailAddresses);

class Email
{
public:
    Email(const EmailAddress   &from,
          const EmailAddress   &to,
          const std::string    &subject,
          const std::string    &body,
          const EmailAddresses &cc = EmailAddresses())
        : from_{from}
        , to_{to}
        , cc_{cc.empty() ? EmailAddresses(1, to) : cc}
        , subject_{subject}
        , body_{body}
        {
        }

    CURLcode send(const std::string &url,
                  const std::string &userName, 
                  const std::string &password);

private:
    struct StringData {
            std::string msg;
            size_t bytesLeft;
            StringData(std::string &&m) : msg{m}, bytesLeft{msg.size()} {}
            StringData(std::string  &m) = delete;
        };

    static std::string dateTimeNow_();
    static size_t payloadSource_(void *ptr, size_t size, size_t nmemb, void *userp);
    std::string generateMessageId_() const;
    std::string setPayloadText_();

    EmailAddress from_, to_;
    EmailAddresses cc_;
    std::string subject_, body_;
};


CURLcode Email::send(const std::string &url,
                     const std::string &userName,
                     const std::string &password)
{
    CURLcode ret = CURLE_OK;

    struct curl_slist *recipients = NULL;

    CURL *curl = curl_easy_init();

    StringData textData { setPayloadText_() };

    if (curl) {
        std::ostringstream cc;
        cc << cc_;

        curl_easy_setopt(curl, CURLOPT_USERNAME,     userName.c_str());
        curl_easy_setopt(curl, CURLOPT_PASSWORD,     password.c_str());
        curl_easy_setopt(curl, CURLOPT_URL,          url     .c_str());

        curl_easy_setopt(curl, CURLOPT_USE_SSL,      (long)CURLUSESSL_ALL);
        //curl_easy_setopt(curl, CURLOPT_CAINFO,      "/path/to/certificate.pem");

        curl_easy_setopt(curl, CURLOPT_MAIL_FROM,    (const char *)from_);
        recipients = curl_slist_append(recipients,   (const char *)to_);
        recipients = curl_slist_append(recipients,   cc.str().c_str());

        curl_easy_setopt(curl, CURLOPT_MAIL_RCPT,    recipients);
        curl_easy_setopt(curl, CURLOPT_READFUNCTION, payloadSource_);
        curl_easy_setopt(curl, CURLOPT_READDATA,     &textData);
        curl_easy_setopt(curl, CURLOPT_UPLOAD,       1L);
        curl_easy_setopt(curl, CURLOPT_VERBOSE,      1L);

        ret = curl_easy_perform(curl);

        if (ret != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: "
                      << curl_easy_strerror(ret)
                      << std::endl;
        }

        curl_slist_free_all(recipients);
        curl_easy_cleanup(curl);
    }

    return ret;
}

std::string Email::dateTimeNow_()
{
    const int RFC5322_TIME_LEN = 32;

    std::string ret;
    ret.resize(RFC5322_TIME_LEN);

    time_t tt;

#ifdef _MSC_VER
    time(&tt);
    tm *t = localtime(&tt);
#else
    tm tv, *t = &tv;
    tt = time(&tt);
    localtime_r(&tt, t);
#endif

    strftime(&ret[0], RFC5322_TIME_LEN, "%a, %d %b %Y %H:%M:%S %z", t);

    return ret;
}

inline std::string Email::generateMessageId_() const
{
    const size_t MESSAGE_ID_LEN = 37;

    tm t;
    time_t tt;
    time(&tt);

#ifdef _MSC_VER
    gmtime_s(&t, &tt);
#else
    gmtime_r(&tt, &t);
#endif

    std::string ret;
    ret.resize(MESSAGE_ID_LEN);
    size_t dateLen = std::strftime(&ret[0], MESSAGE_ID_LEN, "%Y%m%d%H%M%S", &t);

    static const std::string alphaNum {
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz" };

    std::mt19937 gen;
    std::uniform_int_distribution<> distr(0, alphaNum.length() - 1);

    std::generate_n(ret.begin() + dateLen,
                    MESSAGE_ID_LEN - dateLen,
                    [&]() { return alphaNum[distr(gen)]; });

    return ret;
}

size_t Email::payloadSource_(void *ptr, size_t size, size_t nmemb, void *userp)
{
    StringData *text = reinterpret_cast<StringData *>(userp);

    if ((size == 0) || (nmemb == 0) || ((size * nmemb) < 1) || (text->bytesLeft == 0)) {
        return 0;
    }

    if ((nmemb * size) >= text->msg.size()) {
        text->bytesLeft = 0;
        return text->msg.copy(reinterpret_cast<char *>(ptr), text->msg.size());
    }

    return 0;
}

std::string Email::setPayloadText_()
{
    std::string ret = "Date: " + dateTimeNow_() + "\r\n";

    std::ostringstream oss;
    oss << "To: "   << to_   << "\r\n"
           "From: " << from_ << "\r\n";

    if (cc_.size() > 1) {
        oss <<   "Cc: "   << cc_   << "\r\n";
    }

    ret += oss.str();

    ret +=
        "Message-ID: <" + generateMessageId_() + "@" + from_.domain() + ">\r\n"
        "Subject: " + subject_ + "\r\n"
        "\r\n" +
        body_ + "\r\n"
        "\r\n";

    return ret;
}

std::ostream &operator<<(std::ostream &out, const EmailAddresses &emailAddresses)
{
    if (!emailAddresses.empty()) {
        auto it = emailAddresses.begin();
        out << *it;
        while (++it != emailAddresses.end()) {
            out << "," << *it;
        }
    }

    return out;
}

Email email({ "...@mail.ru", "Name" },
              "...@mail.ru",
              "Subject",
              "Body" );

email.send ( "smtp://smtp.mail.ru:25",
              "...",
              "Password"  );

Email email({ "...@gmail.com", "Name" },
              "...@gmail.com",
              "Subj",
              "Body");

email.send(   "smtp://smtp.gmail.com:465",
              "...@gmail.com",
              "Password");

$sh ./autorun.sh
Linux guest additions installer not found -- try to start them manually.