react-native-email-imap-smtp 0.1.0

package/windows/SmtpProtocol.cpp

@@ -0,0 +1,334 @@
+// ============================================================
+// SmtpProtocol.cpp — 纯 SMTP 协议实现
+// 从 EmailImapSmtp.cpp 拆分，移除所有 Nitro/JSI 依赖
+// ============================================================
+
+#include "SmtpProtocol.h"
+
+#include <sstream>
+#include <chrono>
+#include <ctime>
+#include <cstdlib>
+
+namespace emailimap {
+
+SmtpClient::SmtpClient()
+  : m_socket(std::make_unique<TlsSocket>())
+{
+}
+
+SmtpClient::~SmtpClient() {
+  disconnect();
+}
+
+bool SmtpClient::sendRaw(const std::string& data) {
+  return m_socket->send(data);
+}
+
+std::string SmtpClient::receiveLine() {
+  return m_socket->receiveLine(30000);
+}
+
+int SmtpClient::parseResponseCode(const std::string& response) {
+  if (response.size() >= 3) {
+    return std::stoi(response.substr(0, 3));
+  }
+  return 0;
+}
+
+bool SmtpClient::sendCommand(const std::string& command, std::string& response, std::string& error) {
+  if (!m_socket->send(command + "\r\n")) {
+    error = "Failed to send command";
+    return false;
+  }
+
+  response = receiveLine();
+  if (response.empty()) {
+    error = "Connection closed";
+    return false;
+  }
+
+  if (response.size() >= 4 && response[3] == '-') {
+    std::string code = response.substr(0, 3);
+    while (true) {
+      std::string line = receiveLine();
+      if (line.empty()) break;
+      response += "\r\n" + line;
+      if (line.size() >= 4 && line[3] == ' ') break;
+      if (line.size() >= 3 && line.substr(0, 3) == code && line[3] == ' ') break;
+    }
+  }
+
+  int code = parseResponseCode(response);
+  if (code >= 200 && code < 400) return true;
+
+  error = response;
+  return false;
+}
+
+bool SmtpClient::connect(const SmtpConnectionConfig& config, std::string& error) {
+  m_config = config;
+
+  if (!m_socket->connect(config.host, static_cast<int>(config.port),
+                          static_cast<int>(config.timeout), config.checkCertificate)) {
+    error = "Failed to connect to " + config.host + ":" + std::to_string(static_cast<int>(config.port));
+    return false;
+  }
+
+  std::string greeting = receiveLine();
+  if (greeting.empty()) { error = "No SMTP greeting"; disconnect(); return false; }
+
+  int code = parseResponseCode(greeting);
+  if (code != 220) { error = greeting; disconnect(); return false; }
+
+  std::string helloName = config.helloName.value_or("localhost");
+  std::string response;
+  if (!sendCommand("EHLO " + helloName, response, error)) {
+    if (!sendCommand("HELO " + helloName, response, error)) {
+      disconnect();
+      return false;
+    }
+  }
+
+  // STARTTLS if needed
+  if (config.tls && config.port != 465) {
+    if (response.find("STARTTLS") != std::string::npos) {
+      if (!sendCommand("STARTTLS", response, error)) { disconnect(); return false; }
+      m_socket->disconnect();
+      if (!m_socket->connect(config.host, static_cast<int>(config.port),
+                              static_cast<int>(config.timeout), config.checkCertificate)) {
+        error = "Failed to establish TLS"; return false;
+      }
+      greeting = receiveLine();
+      if (greeting.empty()) { error = "No greeting after STARTTLS"; disconnect(); return false; }
+      if (!sendCommand("EHLO " + helloName, response, error)) { disconnect(); return false; }
+    }
+  }
+
+  // Authenticate
+  if (toUpper(config.authType) == "OAUTH2" && config.accessToken.has_value()) {
+    if (!sendCommand("AUTH XOAUTH2 " + encodeBase64Text(
+        "user=" + config.username + "\x01auth=Bearer " + config.accessToken.value() + "\x01\x01"),
+        response, error)) {
+      disconnect();
+      return false;
+    }
+  } else {
+    if (response.find("AUTH LOGIN") != std::string::npos ||
+        response.find("AUTH=LOGIN") != std::string::npos) {
+      if (!sendCommand("AUTH LOGIN", response, error)) {
+        std::string authStr = std::string() + '\x00' + config.username + '\x00' + config.password;
+        if (!sendCommand("AUTH PLAIN " + encodeBase64Text(authStr), response, error)) {
+          disconnect();
+          return false;
+        }
+      } else {
+        if (!sendCommand(encodeBase64Text(config.username), response, error) ||
+            !sendCommand(encodeBase64Text(config.password), response, error)) {
+          disconnect();
+          return false;
+        }
+      }
+    } else {
+      std::string authStr = std::string() + '\x00' + config.username + '\x00' + config.password;
+      if (!sendCommand("AUTH PLAIN " + encodeBase64Text(authStr), response, error)) {
+        disconnect();
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+void SmtpClient::disconnect() {
+  std::string response, error;
+  sendCommand("QUIT", response, error);
+  m_socket->disconnect();
+}
+
+bool SmtpClient::isConnected() const {
+  return m_socket->isConnected();
+}
+
+bool SmtpClient::sendMail(const SendMailOptions& options, SendMailResult& result, std::string& error) {
+  std::string response;
+
+  // MAIL FROM
+  if (!sendCommand("MAIL FROM:<" + options.from.email + ">", response, error)) {
+    result.success = false; result.error = error; result.retryable = true; return false;
+  }
+
+  // RCPT TO
+  for (const auto& addr : options.to) {
+    if (!sendCommand("RCPT TO:<" + addr.email + ">", response, error)) {
+      result.success = false; result.error = error; result.retryable = true; return false;
+    }
+  }
+
+  if (options.cc.has_value()) {
+    for (const auto& addr : options.cc.value()) {
+      std::string rcpResp;
+      if (!sendCommand("RCPT TO:<" + addr.email + ">", rcpResp, error)) {
+        result.success = false; result.error = error; result.retryable = true; return false;
+      }
+    }
+  }
+
+  if (options.bcc.has_value()) {
+    for (const auto& addr : options.bcc.value()) {
+      std::string rcpResp;
+      if (!sendCommand("RCPT TO:<" + addr.email + ">", rcpResp, error)) {
+        result.success = false; result.error = error; result.retryable = true; return false;
+      }
+    }
+  }
+
+  // DATA
+  if (!sendCommand("DATA", response, error)) {
+    result.success = false; result.error = error; result.retryable = true; return false;
+  }
+
+  // Build MIME message
+  std::string message;
+  std::string boundary = "=_Part_" + std::to_string(std::time(nullptr)) + "_" +
+                         std::to_string(rand());
+
+  auto encodeHeader = [](const std::string& text) -> std::string {
+    bool needsEncoding = false;
+    for (unsigned char c : text) {
+      if (c > 127) { needsEncoding = true; break; }
+    }
+    if (needsEncoding) {
+      std::vector<char> utf8Bytes(text.begin(), text.end());
+      return "=?UTF-8?B?" + encodeBase64(utf8Bytes) + "?=";
+    }
+    return text;
+  };
+
+  // Headers
+  message += "From: " + encodeHeader(options.from.name) + " <" + options.from.email + ">\r\n";
+  for (const auto& addr : options.to) {
+    message += "To: " + encodeHeader(addr.name) + " <" + addr.email + ">\r\n";
+  }
+  if (options.cc.has_value()) {
+    for (const auto& addr : options.cc.value()) {
+      message += "Cc: " + encodeHeader(addr.name) + " <" + addr.email + ">\r\n";
+    }
+  }
+  message += "Subject: " + encodeHeader(options.subject) + "\r\n";
+  message += "Date: " + formatDate(std::time(nullptr)) + "\r\n";
+  message += "MIME-Version: 1.0\r\n";
+
+  if (options.priority.has_value()) {
+    if (toUpper(options.priority.value()) == "HIGH") {
+      message += "X-Priority: 1\r\nPriority: urgent\r\n";
+    } else if (toUpper(options.priority.value()) == "LOW") {
+      message += "X-Priority: 5\r\nPriority: non-urgent\r\n";
+    }
+  }
+
+  if (options.headers.has_value()) {
+    for (const auto& [key, value] : options.headers.value()) {
+      message += key + ": " + value + "\r\n";
+    }
+  }
+
+  if (options.inReplyTo.has_value())  message += "In-Reply-To: <" + options.inReplyTo.value() + ">\r\n";
+  if (options.references.has_value()) message += "References: " + options.references.value() + "\r\n";
+  if (options.readReceiptTo.has_value()) {
+    message += "Disposition-Notification-To: <" + options.readReceiptTo.value().email + ">\r\n";
+  }
+
+  bool hasText = options.textBody.has_value() && !options.textBody.value().empty();
+  bool hasHtml = options.htmlBody.has_value() && !options.htmlBody.value().empty();
+  bool hasAttachments = options.attachments.has_value() && !options.attachments.value().empty();
+
+  if (hasAttachments) {
+    message += "Content-Type: multipart/mixed; boundary=\"" + boundary + "\"\r\n";
+    message += "\r\n--" + boundary + "\r\n";
+
+    if (hasText || hasHtml) {
+      std::string altBoundary = boundary + "_alt";
+      message += "Content-Type: multipart/alternative; boundary=\"" + altBoundary + "\"\r\n\r\n";
+      if (hasText) {
+        message += "--" + altBoundary + "\r\nContent-Type: text/plain; charset=\"UTF-8\"\r\n"
+                   "Content-Transfer-Encoding: base64\r\n\r\n";
+        message += encodeBase64Text(options.textBody.value()) + "\r\n\r\n";
+      }
+      if (hasHtml) {
+        message += "--" + altBoundary + "\r\nContent-Type: text/html; charset=\"UTF-8\"\r\n"
+                   "Content-Transfer-Encoding: base64\r\n\r\n";
+        message += encodeBase64Text(options.htmlBody.value()) + "\r\n\r\n";
+      }
+      message += "--" + altBoundary + "--\r\n";
+    }
+
+    for (const auto& att : options.attachments.value()) {
+      message += "\r\n--" + boundary + "\r\n";
+      message += "Content-Type: " + att.mimeType + "; name=\"" + att.filename + "\"\r\n";
+      message += "Content-Disposition: " +
+                 (att.isInline ? "inline" : (att.disposition.has_value() ? att.disposition.value() : "attachment")) +
+                 "; filename=\"" + att.filename + "\"\r\n";
+      if (att.contentId.has_value()) message += "Content-ID: <" + att.contentId.value() + ">\r\n";
+      message += "Content-Transfer-Encoding: base64\r\n\r\n";
+
+      if (!att.data.empty()) {
+        std::string rawData(att.data.begin(), att.data.end());
+        message += encodeBase64Text(rawData) + "\r\n";
+      }
+    }
+    message += "\r\n--" + boundary + "--\r\n";
+  } else if (hasText && hasHtml) {
+    std::string altBoundary = boundary + "_alt";
+    message += "Content-Type: multipart/alternative; boundary=\"" + altBoundary + "\"\r\n\r\n";
+    message += "--" + altBoundary + "\r\nContent-Type: text/plain; charset=\"UTF-8\"\r\n"
+               "Content-Transfer-Encoding: base64\r\n\r\n";
+    message += encodeBase64Text(options.textBody.value()) + "\r\n\r\n";
+    message += "--" + altBoundary + "\r\nContent-Type: text/html; charset=\"UTF-8\"\r\n"
+               "Content-Transfer-Encoding: base64\r\n\r\n";
+    message += encodeBase64Text(options.htmlBody.value()) + "\r\n\r\n";
+    message += "--" + altBoundary + "--\r\n";
+  } else if (hasHtml) {
+    message += "Content-Type: text/html; charset=\"UTF-8\"\r\nContent-Transfer-Encoding: base64\r\n\r\n";
+    message += encodeBase64Text(options.htmlBody.value()) + "\r\n";
+  } else {
+    message += "Content-Type: text/plain; charset=\"UTF-8\"\r\nContent-Transfer-Encoding: base64\r\n\r\n";
+    message += encodeBase64Text(options.textBody.value_or("")) + "\r\n";
+  }
+
+  message += "\r\n.";
+
+  if (!m_socket->send(message + "\r\n")) {
+    error = "Failed to send message data";
+    result.success = false; result.error = error; result.retryable = true; return false;
+  }
+
+  response = receiveLine();
+  if (response.empty()) {
+    error = "Connection closed during DATA";
+    result.success = false; result.error = error; result.retryable = false; return false;
+  }
+
+  int code = parseResponseCode(response);
+  if (code >= 200 && code < 400) {
+    result.success = true;
+    result.messageId = "<" + std::to_string(std::time(nullptr)) + "." +
+                       std::to_string(rand()) + "@" + m_config.host + ">";
+    result.date = currentTimestamp();
+    result.serverResponseCode = static_cast<double>(code);
+    result.retryable = false;
+
+    std::string rawMime = message;
+    result.rawMimeData = std::vector<uint8_t>(rawMime.begin(), rawMime.end());
+  } else {
+    result.success = false;
+    result.error = response;
+    result.serverResponseCode = static_cast<double>(code);
+    result.retryable = (code >= 400 && code < 500);
+  }
+
+  return result.success;
+}
+
+} // namespace emailimap

package/windows/SmtpProtocol.h

@@ -0,0 +1,36 @@
+// ============================================================
+// SmtpProtocol.h — 纯 SMTP 协议实现，无 Nitro/JSI 依赖
+// ============================================================
+
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "ProtocolDefs.h"
+#include "TlsSocket.h"
+
+namespace emailimap {
+
+class SmtpClient {
+public:
+  SmtpClient();
+  ~SmtpClient();
+
+  bool connect(const SmtpConnectionConfig& config, std::string& error);
+  void disconnect();
+  bool isConnected() const;
+
+  bool sendMail(const SendMailOptions& options, SendMailResult& result, std::string& error);
+
+private:
+  std::unique_ptr<TlsSocket> m_socket;
+  SmtpConnectionConfig m_config;
+
+  bool sendCommand(const std::string& command, std::string& response, std::string& error);
+  bool sendRaw(const std::string& data);
+  std::string receiveLine();
+  int parseResponseCode(const std::string& response);
+};
+
+} // namespace emailimap