feat: Add a Message-ID generated header when sending a message.

Author: jeremydumais

CMakeLists.txt

@@ -105,6 +105,7 @@ set(PROJECT_SOURCE_FILES ${SRC_PATH}/attachment.cpp
     ${SRC_PATH}/htmlmessage.cpp
     ${SRC_PATH}/message.cpp
     ${SRC_PATH}/messageaddress.cpp
+    ${SRC_PATH}/messageidutils.cpp
     ${SRC_PATH}/plaintextmessage.cpp
     ${SRC_PATH}/smtpclientbase.cpp
     ${SRC_PATH}/smtpclient.cpp
@@ -271,6 +272,7 @@ if (BUILD_TESTING)
     add_executable(${PROJECT_UNITTEST_NAME} ${INCLUDE_PATH}
         ${TEST_SRC_PATH}/main.cpp
         ${TEST_SRC_PATH}/messageaddress_unittest.cpp
+        ${TEST_SRC_PATH}/messageidutils_unittest.cpp
         ${TEST_SRC_PATH}/message_unittest.cpp
         ${TEST_SRC_PATH}/message_cpp_unittest.cpp
         ${TEST_SRC_PATH}/attachment_unittest.cpp

src/cpp/messageaddress.cpp

@@ -20,6 +20,10 @@ std::string MessageAddress::getDisplayName() const {
     return jed_utils::MessageAddress::getDisplayName();
 }
 
+std::string MessageAddress::getDomainName() const {
+    return jed_utils::MessageAddress::getDomainName();
+}
+
 jed_utils::MessageAddress MessageAddress::toStdMessageAddress() const {
     return jed_utils::MessageAddress(jed_utils::MessageAddress::getEmailAddress(),
                                      jed_utils::MessageAddress::getDisplayName());

src/cpp/messageaddress.hpp

@@ -64,6 +64,9 @@ class CPP_MESSAGEADDRESS_API MessageAddress : private jed_utils::MessageAddress
     /** Return the display name. */
     std::string getDisplayName() const;
 
+    /** Return the domain name. */
+    std::string getDomainName() const;
+
     jed_utils::MessageAddress toStdMessageAddress() const;
 
     friend class Message;

src/messageaddress.cpp

@@ -1,5 +1,6 @@
 #include "messageaddress.h"
 #include <cstddef>
+#include <cstring>
 #include <regex>
 #include <stdexcept>
 #include <string>
@@ -8,7 +9,7 @@
 using namespace jed_utils;
 
 MessageAddress::MessageAddress(const char *pEmailAddress, const char *pDisplayName)
-    : mEmailAddress(nullptr), mDisplayName(nullptr) {
+    : mEmailAddress(nullptr), mDisplayName(nullptr), mDomainName(nullptr) {
     std::string email_address { pEmailAddress };
     // Check if the email address is not empty or white spaces
     if (email_address.length() == 0 || StringUtils::trim(email_address).empty()) {
@@ -28,30 +29,48 @@ MessageAddress::MessageAddress(const char *pEmailAddress, const char *pDisplayNa
     mDisplayName = new char[name_len+1];
     strncpy(mDisplayName, pDisplayName, name_len);
     mDisplayName[name_len] = '\0';
+
+    std::string emailAddress(mEmailAddress);
+    auto atPos = emailAddress.find('@');
+    if (atPos == std::string::npos || atPos == emailAddress.size() - 1) {
+        mDomainName = new char[1];
+        mDomainName[0] = '\0';
+    } else {
+        auto domainNamePart = emailAddress.substr(atPos + 1);
+        mDomainName = new char[domainNamePart.length() +1];
+        strncpy(mDomainName, domainNamePart.c_str(), domainNamePart.length());
+        mDomainName[domainNamePart.length()] = '\0';
+    }
 }
 
 MessageAddress::~MessageAddress() {
     delete[] mEmailAddress;
     delete[] mDisplayName;
+    delete[] mDomainName;
 }
 
 // Copy constructor
 MessageAddress::MessageAddress(const MessageAddress& other)
     : mEmailAddress(new char[strlen(other.mEmailAddress) + 1]),
-      mDisplayName(new char[strlen(other.mDisplayName) + 1]) {
+      mDisplayName(new char[strlen(other.mDisplayName) + 1]),
+      mDomainName(new char[strlen(other.mDomainName) + 1]) {
     size_t email_len = strlen(other.mEmailAddress);
     strncpy(mEmailAddress, other.mEmailAddress, email_len);
     mEmailAddress[email_len] = '\0';
     size_t name_len = strlen(other.mDisplayName);
     strncpy(mDisplayName, other.mDisplayName, name_len);
     mDisplayName[name_len] = '\0';
+    size_t domain_len = strlen(other.mDomainName);
+    strncpy(mDomainName, other.mDomainName, domain_len);
+    mDomainName[domain_len] = '\0';
 }
 
 // Assignment operator
 MessageAddress& MessageAddress::operator=(const MessageAddress& other) {
     if (this != &other) {
         delete[] mEmailAddress;
         delete[] mDisplayName;
+        delete[] mDomainName;
         // mEmailAddress
         size_t email_len = strlen(other.mEmailAddress);
         mEmailAddress = new char[email_len + 1];
@@ -62,32 +81,42 @@ MessageAddress& MessageAddress::operator=(const MessageAddress& other) {
         mDisplayName = new char[name_len + 1];
         strncpy(mDisplayName, other.mDisplayName, name_len);
         mDisplayName[name_len] = '\0';
+        // mDomainName
+        size_t domain_len = strlen(other.mDomainName);
+        mDomainName = new char[domain_len + 1];
+        strncpy(mDomainName, other.mDomainName, domain_len);
+        mDomainName[domain_len] = '\0';
     }
     return *this;
 }
 
 // Move constructor
 MessageAddress::MessageAddress(MessageAddress&& other) noexcept
     : mEmailAddress(other.mEmailAddress),
-      mDisplayName(other.mDisplayName) {
+      mDisplayName(other.mDisplayName),
+      mDomainName(other.mDomainName) {
     // Release the data pointer from the source object so that the destructor
     // does not free the memory multiple times.
     other.mEmailAddress = nullptr;
     other.mDisplayName = nullptr;
+    other.mDomainName = nullptr;
 }
 
 // Move assignement operator
 MessageAddress& MessageAddress::operator=(MessageAddress&& other) noexcept {
     if (this != &other) {
         delete[] mEmailAddress;
         delete[] mDisplayName;
+        delete[] mDomainName;
         // Copy the data pointer and its length from the source object.
         mEmailAddress = other.mEmailAddress;
         mDisplayName = other.mDisplayName;
+        mDomainName = other.mDomainName;
         // Release the data pointer from the source object so that
         // the destructor does not free the memory multiple times.
         other.mEmailAddress = nullptr;
         other.mDisplayName = nullptr;
+        other.mDomainName = nullptr;
     }
     return *this;
 }
@@ -116,6 +145,10 @@ const char *MessageAddress::getDisplayName() const {
     return mDisplayName;
 }
 
+const char *MessageAddress::getDomainName() const {
+    return mDomainName;
+}
+
 bool MessageAddress::isEmailAddressValid(const std::string &pEmailAddress) const {
     std::regex emailPattern("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*$");
     return regex_match(StringUtils::toLower(pEmailAddress), emailPattern);

src/messageaddress.h

@@ -60,11 +60,15 @@ class MESSAGEADDRESS_API MessageAddress {
     /** Return the display name. */
     const char *getDisplayName() const;
 
+    /** Return the domain name. */
+    const char *getDomainName() const;
+
     friend class message;
 
  private:
     char *mEmailAddress = nullptr;
     char *mDisplayName = nullptr;
+    char *mDomainName = nullptr;
     bool isEmailAddressValid(const std::string &pEmailAddress) const;
 };
 }  // namespace jed_utils

src/messageidutils.cpp

@@ -0,0 +1,100 @@
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include "messageidutils.h"
+
+#if defined(_WIN32)
+    #include <windows.h>
+#else
+    #include <unistd.h>
+    #include <sys/types.h>
+#endif
+
+namespace jed_utils {
+
+std::string MessageIDUtils::generate(const std::string& rhs,
+                                bool includeAngleBrackets,
+                                bool strictRhsCheck) {
+    if (strictRhsCheck && !rhsLooksOk(rhs))
+        throw std::invalid_argument("MessageIDUtils::generate: RHS contains invalid characters");
+
+    std::string lhs = generateLhs();
+    std::string core = lhs + "@" + rhs;
+    return includeAngleBrackets ? ("<" + core + ">") : core;
+}
+
+std::string MessageIDUtils::generateLhs() {
+    const auto micros = std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::system_clock::now().time_since_epoch()).count();
+    const uint32_t pid = getPid();
+    const uint64_t ctr = counter().fetch_add(1, std::memory_order_relaxed);
+    const std::string rnd = random128Base36();
+
+    std::string lhs;
+    lhs.reserve(64);
+    lhs.append(toBase36(static_cast<uint64_t>(micros)));
+    lhs.push_back('.');
+    lhs.append(toBase36(static_cast<uint64_t>(pid)));
+    lhs.push_back('.');
+    lhs.append(toBase36(ctr));
+    lhs.push_back('.');
+    lhs.append(rnd);
+    return lhs;
+}
+
+uint32_t MessageIDUtils::getPid() {
+    #if defined(_WIN32)
+        return static_cast<uint32_t>(GetCurrentProcessId());
+    #else
+        return static_cast<uint32_t>(getpid());
+    #endif
+}
+
+std::atomic<uint64_t>& MessageIDUtils::counter() {
+    static std::atomic<uint64_t> c {
+        static_cast<uint64_t>(std::random_device {}()) ^
+            static_cast<uint64_t>(
+                    std::chrono::high_resolution_clock::now().time_since_epoch().count())
+    };
+    return c;
+}
+
+std::string MessageIDUtils::toBase36(uint64_t v) {
+    static const char* digits = "0123456789abcdefghijklmnopqrstuvwxyz";
+    if (v == 0) return "0";
+    std::string out;
+    while (v) {
+        out.push_back(digits[v % 36]);
+        v /= 36;
+    }
+    std::reverse(out.begin(), out.end());
+    return out;
+}
+
+uint64_t MessageIDUtils::rand64() {
+    static thread_local std::mt19937_64 rng(
+            (static_cast<uint64_t>(std::random_device {}()) << 1) ^
+            reinterpret_cast<uintptr_t>(&rng) ^
+            static_cast<uint64_t>(
+                std::chrono::high_resolution_clock::now().time_since_epoch().count()));
+    return rng();
+}
+
+std::string MessageIDUtils::random128Base36() {
+    const uint64_t a = rand64();
+    const uint64_t b = rand64();
+    return toBase36(a) + toBase36(b);
+}
+
+bool MessageIDUtils::rhsLooksOk(const std::string& rhs) {
+    if (rhs.empty()) return false;
+    return std::all_of(rhs.begin(), rhs.end(), [](unsigned char c) {
+        return std::isalnum(c) || c == '.' || c == '-' || c == '[' || c == ']' || c == ':';
+    });
+}
+
+}  // namespace jed_utils

src/messageidutils.h

@@ -0,0 +1,37 @@
+#ifndef MESSAGEIDUTILS_H
+#define MESSAGEIDUTILS_H
+
+#include <atomic>
+#include <cstdint>
+#include <string>
+
+namespace jed_utils {
+
+class MessageIDUtils {
+ public:
+    // Generate a complete Message-ID string, e.g. "<abc.def.ghi.jkl@domain>"
+    static std::string generate(const std::string& rhs,
+                                bool includeAngleBrackets = true,
+                                bool strictRhsCheck = false);
+    // Generate only the LHS portion (dot-atom safe)
+    static std::string generateLhs();
+
+ private:
+    // --- platform-specific PID ---
+    static uint32_t getPid();
+    // --- atomic counter (process-wide) ---
+    static std::atomic<uint64_t>& counter();
+    // --- convert integer to base36 (a-z0-9) ---
+    static std::string toBase36(uint64_t v);
+    // --- thread-local RNG, seeded once per thread ---
+    static uint64_t rand64();
+    // --- 128-bit random number encoded in base36 ---
+    static std::string random128Base36();
+    // --- basic RHS validator (optional strict mode) ---
+    static bool rhsLooksOk(const std::string& rhs);
+};
+
+}  // namespace jed_utils
+
+#endif  // MESSAGEIDUTILS_H
+

src/smtpclientbase.cpp

@@ -23,6 +23,7 @@
 #include "errorresolver.h"
 #include "message.h"
 #include "messageaddress.h"
+#include "messageidutils.h"
 #include "serverauthoptions.h"
 #include "serveroptionsanalyzer.h"
 #include "smtpclienterrors.h"
@@ -947,6 +948,14 @@ int SMTPClientBase::setMailHeaders(const Message &pMsg) {
         return header_date_ret_code;
     }
 
+    // Message-ID
+    try {
+        std::string msg_id = MessageIDUtils::generate(pMsg.getFrom().getDomainName());
+        addMailHeader("Message-ID", msg_id.c_str(), CLIENT_SENDMAIL_HEADERMSGID_ERROR);
+    } catch (const std::invalid_argument &err) {
+        return CLIENT_SENDMAIL_HEADERMSGID_ERROR;
+    }
+
     // From
     std::stringstream from_header_ss;
     const MessageAddress &from_addr = pMsg.getFrom();

src/smtpclienterrors.h

@@ -24,6 +24,7 @@ const int CLIENT_SENDMAIL_END_DATA_ERROR = -97;
 const int CLIENT_SENDMAIL_END_DATA_TIMEOUT = -98;
 const int CLIENT_SENDMAIL_QUIT_ERROR = -99;
 const int CLIENT_SENDMAIL_HEADERDATE_ERROR = -100;
+const int CLIENT_SENDMAIL_HEADERMSGID_ERROR = -101;
 
 // SMTP standard error code
 const int SMTPSERVER_AUTHENTICATIONREQUIRED_ERROR = 530;