SmtpMailer.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2019-2022 Tobias Flaig.
 *
 * This file is part of nawa.
 *
 * nawa is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License,
 * version 3, as published by the Free Software Foundation.
 *
 * nawa 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with nawa.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <curl/curl.h>
#include <nawa/Exception.h>
#include <nawa/mail/EmailAddress.h>
#include <nawa/mail/SmtpMailer.h>
#include <nawa/util/crypto.h>
#include <nawa/util/utils.h>
#include <random>
 
using namespace nawa;
using namespace std;
 
namespace {
    void addMissingHeaders(shared_ptr<mail::Email>& email, shared_ptr<mail::EmailAddress> const& from) {
        if (!email->headers().count("Date")) {
            email->headers()["Date"] = utils::makeSmtpTime(time(nullptr));
        }
        if (!email->headers().count("From") && !from->address().empty()) {
            email->headers()["From"] = from->get();
        }
        unsigned long atPos;
        if (!email->headers().count("Message-ID") && !from->address().empty() && (atPos = from->address().find_last_of('@')) != string::npos) {
            stringstream mid;
            stringstream base;
            random_device rd;
            timespec mtime{};
            clock_gettime(CLOCK_REALTIME, &mtime);
            base << mtime.tv_sec << mtime.tv_nsec << from->address() << rd();
            mid << '<' << crypto::md5(base.str(), true) << '@' << from->address().substr(atPos + 1) << '>';
            email->headers()["Message-ID"] = mid.str();
        }
    }
 
    struct QueueElem {
        std::shared_ptr<mail::Email const> email;
        std::shared_ptr<mail::EmailAddress const> from;
        std::vector<mail::EmailAddress> recipients;
        std::shared_ptr<mail::ReplacementRules> replacementRules;
    };
}// namespace
 
struct mail::SmtpMailer::Data {
    std::string serverDomain;
    unsigned int serverPort;
    TlsMode serverTlsMode;
    bool verifyServerTlsCert;
    std::string authUsername;
    std::string authPassword;
    long connectionTimeout;
    std::vector<QueueElem> queue;
 
    Data(string serverDomain, unsigned int serverPort, TlsMode serverTlsMode, bool verifyServerTlsCert,
         string authUsername, string authPassword, long connectionTimeout) : serverDomain(std::move(serverDomain)),
                                                                             serverPort(serverPort),
                                                                             serverTlsMode(serverTlsMode),
                                                                             verifyServerTlsCert(verifyServerTlsCert),
                                                                             authUsername(std::move(authUsername)),
                                                                             authPassword(std::move(authPassword)),
                                                                             connectionTimeout(connectionTimeout) {}
};
 
NAWA_DEFAULT_DESTRUCTOR_IMPL_WITH_NS(mail, SmtpMailer)
 
mail::SmtpMailer::SmtpMailer(string serverDomain, unsigned int serverPort, SmtpMailer::TlsMode serverTlsMode,
                             bool verifyServerTlsCert, string authUsername, string authPassword,
                             long connectionTimeout) {
    data = make_unique<Data>(std::move(serverDomain), serverPort, serverTlsMode, verifyServerTlsCert, std::move(authUsername),
                             std::move(authPassword), connectionTimeout);
}
 
void mail::SmtpMailer::setServer(std::string domain, unsigned int port, SmtpMailer::TlsMode tlsMode, bool verifyTlsCert) {
    data->serverDomain = std::move(domain);
    data->serverPort = port;
    data->serverTlsMode = tlsMode;
    data->verifyServerTlsCert = verifyTlsCert;
}
 
void mail::SmtpMailer::setAuth(std::string username, std::string password) {
    data->authUsername = std::move(username);
    data->authPassword = std::move(password);
}
 
void mail::SmtpMailer::setConnectionTimeout(long timeout) {
    data->connectionTimeout = timeout;
}
 
void mail::SmtpMailer::enqueue(std::shared_ptr<Email> email, EmailAddress to, std::shared_ptr<EmailAddress> from,
                               std::shared_ptr<ReplacementRules> replacementRules) {
    bulkEnqueue(std::move(email), vector<EmailAddress>({std::move(to)}), std::move(from),
                std::move(replacementRules));
}
 
void mail::SmtpMailer::bulkEnqueue(std::shared_ptr<Email> email, std::vector<EmailAddress> recipients,
                                   std::shared_ptr<EmailAddress> from, std::shared_ptr<ReplacementRules> replacementRules) {
    addMissingHeaders(email, from);
    data->queue.push_back(QueueElem{.email = std::move(email), .from = std::move(from), .recipients = std::move(recipients), .replacementRules = std::move(replacementRules)});
}
 
void mail::SmtpMailer::clearQueue() {
    data->queue.clear();
}
 
void mail::SmtpMailer::processQueue() const {
    CURL* curl;
    CURLcode res;
 
    curl = curl_easy_init();
    if (curl) {
 
        // authentication, if requested
        if (!data->authUsername.empty()) {
            curl_easy_setopt(curl, CURLOPT_USERNAME, data->authUsername.c_str());
            if (!data->authPassword.empty())
                curl_easy_setopt(curl, CURLOPT_PASSWORD, data->authPassword.c_str());
        }
 
        // build URL for curl
        {
            stringstream curlUrl;
            if (data->serverTlsMode == TlsMode::SMTPS) {
                curlUrl << "smtps://";
            } else {
                curlUrl << "smtp://";
            }
            curlUrl << data->serverDomain << ":" << data->serverPort;
            curl_easy_setopt(curl, CURLOPT_URL, curlUrl.str().c_str());
        }
 
        // set up TLS
        if (data->serverTlsMode == TlsMode::REQUIRE_STARTTLS) {
            curl_easy_setopt(curl, CURLOPT_USE_SSL, (long) CURLUSESSL_ALL);
        } else if (data->serverTlsMode == TlsMode::TRY_STARTTLS) {
            curl_easy_setopt(curl, CURLOPT_USE_SSL, (long) CURLUSESSL_TRY);
        }
        if (data->serverTlsMode != TlsMode::NONE && !data->verifyServerTlsCert) {
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
        }
 
        //        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
        FILE* devNull = fopen("/dev/null", "wb");
        curl_easy_setopt(curl, CURLOPT_STDERR, devNull);
 
        // connection timeout
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, data->connectionTimeout);
 
        // iterate queue
        for (const auto& mail : data->queue) {
 
            // set sender
            curl_easy_setopt(curl, CURLOPT_MAIL_FROM, mail.from->get(false).c_str());
 
            // set recipients
            curl_slist* recipients = nullptr;
            for (const auto& to : mail.recipients) {
                recipients = curl_slist_append(recipients, to.get(false).c_str());
            }
            curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
 
            // specify how to read the mail data
            string payload = mail.email->getRaw(mail.replacementRules);
            // fmemopen will create a FILE* to read from the string (curl expects that, unfortunately)
            FILE* payloadFile = fmemopen((void*) payload.c_str(), payload.length(), "r");
            curl_easy_setopt(curl, CURLOPT_READDATA, (void*) payloadFile);
            curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
 
            // perform sending
            res = curl_easy_perform(curl);
 
            // free memory
            curl_slist_free_all(recipients);
            fclose(payloadFile);
 
            // check for errors, throw exception if one happens
            if (res != CURLE_OK) {
                curl_easy_cleanup(curl);
                throw Exception(__PRETTY_FUNCTION__, 1,
                                string("CURL error: ") + curl_easy_strerror(res));
            }
        }
 
        curl_easy_cleanup(curl);
        fclose(devNull);
    }
}