1 files changed, 202 insertions, 0 deletions
diff --git a/src/ui/function/SMTPSendMailThread.cpp b/src/ui/function/SMTPSendMailThread.cpp
new file mode 100644
index 00000000..3e5ce9bc
--- /dev/null
+++ b/src/ui/function/SMTPSendMailThread.cpp
@@ -0,0 +1,202 @@
+/**
+ * This file is part of GpgFrontend.
+ *
+ * GpgFrontend is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Foobar 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * The initial version of the source code is inherited from gpg4usb-team.
+ * Their source code version also complies with GNU General Public License.
+ *
+ * The source code version of this software was modified and released
+ * by Saturneric<[email protected]><[email protected]> starting on May 12, 2021.
+ *
+ */
+
+#include "SMTPSendMailThread.h"
+
+#include <boost/format.hpp>
+
+#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgKeyGetter.h"
+#include "gpg/function/GpgKeyImportExporter.h"
+
+namespace GpgFrontend::UI {
+
+void SMTPSendMailThread::run() {
+  SmtpClient smtp(host_.c_str(), port_, connection_type_);
+
+  if (identify_) {
+    smtp.setUser(username_.c_str());
+    smtp.setPassword(password_.c_str());
+  }
+
+  if (encrypt_content_ && public_key_ids_ != nullptr &&
+      !public_key_ids_->empty()) {
+    message.getContent().setContentType(
+        "multipart/encrypted; micalg=pgp-md5; "
+        "protocol=\"application/pgp-encrypted\"");
+  }
+
+  if (attach_signature_file_ && !private_key_id_.empty()) {
+    message.getContent().setContentType(
+        "multipart/signed; micalg=pgp-md5; "
+        "protocol=\"application/pgp-signature\"");
+  }
+
+  int index = 0;
+  for (auto& text : texts_) {
+    const auto plain_text = text->getText().toStdString();
+    // encrypt
+    if (encrypt_content_ && public_key_ids_ != nullptr &&
+        !public_key_ids_->empty()) {
+      ByteArrayPtr out_buffer = nullptr;
+      GpgEncrResult result;
+      auto in_buffer = std::make_unique<ByteArray>(plain_text);
+      auto keys = GpgKeyGetter::GetInstance().GetKeys(public_key_ids_);
+      auto err = BasicOperator::GetInstance().Encrypt(
+          std::move(keys), *in_buffer, out_buffer, result);
+
+      if (check_gpg_error_2_err_code(err) != GPG_ERR_NO_ERROR) {
+        emit signalSMTPResult("Fail to encrypt with gpg keys");
+        return;
+      }
+      text->setText(out_buffer->c_str());
+    }
+
+    send_texts_.push_back(std::move(text));
+
+    // sign
+    if (attach_signature_file_ && !private_key_id_.empty()) {
+      ByteArrayPtr out_buffer = nullptr;
+      GpgSignResult result;
+
+      auto& plain_mime_text = send_texts_.back();
+      auto in_buffer =
+          std::make_unique<ByteArray>(plain_mime_text->getText().toStdString());
+      auto key = GpgKeyGetter::GetInstance().GetKey(private_key_id_);
+      auto keys = std::make_unique<KeyArgsList>();
+      keys->push_back(std::move(key));
+
+      auto err = BasicOperator::GetInstance().Sign(
+          std::move(keys), *in_buffer, out_buffer, GPGME_SIG_MODE_DETACH,
+          result);
+
+      if (check_gpg_error_2_err_code(err) != GPG_ERR_NO_ERROR) {
+        emit signalSMTPResult("Fail to sign with gpg keys");
+        return;
+      }
+
+      auto sign_content_name =
+          boost::format("%1%_sign_%2%.asc") % private_key_id_ % index++;
+
+      // Add MIME
+      send_texts_.push_back(std::make_unique<MimeText>(out_buffer->c_str()));
+      auto& sig_text = send_texts_.back();
+      sig_text->setContentType("application/pgp-signature");
+      sig_text->setEncoding(MimePart::_7Bit);
+      sig_text->setContentName(sign_content_name.str().c_str());
+    }
+  }
+
+  if (attach_public_key_file_ && !attached_public_key_ids_.empty()) {
+    auto key = GpgKeyGetter::GetInstance().GetKey(attached_public_key_ids_);
+    ByteArrayPtr out_buffer = nullptr;
+    GpgKeyImportExporter::GetInstance().ExportKey(key, out_buffer);
+
+    auto public_key_file_name =
+        boost::format("%1%_pubkey.asc") % attached_public_key_ids_;
+    addFileContent(public_key_file_name.str().c_str(), out_buffer->c_str());
+    auto& key_file = files_.back();
+    key_file->setEncoding(MimePart::_7Bit);
+    key_file->setContentType("application/pgp-keys");
+  }
+
+  for (const auto& text : send_texts_) {
+    message.addPart(text.get());
+  }
+
+  for (const auto& file : files_) {
+    message.addPart(file.get());
+  }
+
+  // Now we can send the mail
+  if (!smtp.connectToHost()) {
+    emit signalSMTPResult("Fail to connect SMTP server");
+    return;
+  }
+  if (!smtp.login()) {
+    emit signalSMTPResult("Fail to login");
+    return;
+  }
+  if (!smtp.sendMail(message)) {
+    emit signalSMTPResult("Fail to send mail");
+    return;
+  }
+  smtp.quit();
+  emit signalSMTPResult("Succeed in sending a test email");
+}
+
+void SMTPSendMailThread::setBCC(const QString& bccs) {
+  QStringList bcc_string_list = bccs.split(';');
+  for (const auto& bcc : bcc_string_list) {
+    if (!bcc.isEmpty()) message.addBcc(new EmailAddress(bcc.trimmed()));
+  }
+}
+
+void SMTPSendMailThread::setCC(const QString& ccs) {
+  QStringList cc_string_list = ccs.split(';');
+  for (const auto& cc : cc_string_list) {
+    if (!cc.isEmpty()) message.addCc(new EmailAddress(cc.trimmed()));
+  }
+}
+
+void SMTPSendMailThread::setRecipient(const QString& recipients) {
+  QStringList rcpt_string_list = recipients.split(';');
+  for (const auto& rcpt : rcpt_string_list) {
+    if (!rcpt.isEmpty()) message.addRecipient(new EmailAddress(rcpt.trimmed()));
+  }
+}
+
+void SMTPSendMailThread::setSender(const QString& sender) {
+  message.setSender(new EmailAddress(sender));
+}
+
+void SMTPSendMailThread::addTextContent(const QString& content) {
+  auto text = std::make_unique<MimeText>(content);
+  texts_.push_back(std::move(text));
+}
+
+void SMTPSendMailThread::addFileContent(const QString& file_name,
+                                        const QByteArray& content) {
+  auto file = std::make_unique<MimeFile>(content, file_name);
+  files_.push_back(std::move(file));
+}
+
+void SMTPSendMailThread::setEncryptContent(
+    bool encrypt_content, GpgFrontend::KeyIdArgsListPtr public_key_ids) {
+  this->encrypt_content_ = encrypt_content;
+  this->public_key_ids_ = std::move(public_key_ids);
+}
+
+void SMTPSendMailThread::setAttachSignatureFile(
+    bool attach_signature_file, GpgFrontend::KeyId private_key_id) {
+  this->attach_signature_file_ = attach_signature_file;
+  this->private_key_id_ = std::move(private_key_id);
+}
+
+void SMTPSendMailThread::setAttachPublicKey(
+    bool attach_public_key_file, GpgFrontend::KeyId attached_public_key_ids) {
+  this->attach_public_key_file_ = attach_public_key_file;
+  this->attached_public_key_ids_ = std::move(attached_public_key_ids);
+}
+}  // namespace GpgFrontend::UI