diff options
Diffstat (limited to 'src/ui/thread')
| -rw-r--r-- | src/ui/thread/CtxCheckThread.cpp | 48 | ||||
| -rw-r--r-- | src/ui/thread/CtxCheckThread.h | 42 | ||||
| -rw-r--r-- | src/ui/thread/FileReadThread.cpp | 70 | ||||
| -rw-r--r-- | src/ui/thread/FileReadThread.h | 53 | ||||
| -rw-r--r-- | src/ui/thread/ProxyConnectionTestThread.cpp | 56 | ||||
| -rw-r--r-- | src/ui/thread/ProxyConnectionTestThread.h | 57 | ||||
| -rw-r--r-- | src/ui/thread/SMTPSendMailThread.cpp | 261 | ||||
| -rw-r--r-- | src/ui/thread/SMTPSendMailThread.h | 102 | ||||
| -rw-r--r-- | src/ui/thread/SMTPTestThread.cpp | 46 | ||||
| -rw-r--r-- | src/ui/thread/SMTPTestThread.h | 67 | ||||
| -rw-r--r-- | src/ui/thread/TestListedKeyServerThread.cpp | 47 | ||||
| -rw-r--r-- | src/ui/thread/TestListedKeyServerThread.h | 55 | ||||
| -rw-r--r-- | src/ui/thread/VersionCheckThread.cpp | 125 | ||||
| -rw-r--r-- | src/ui/thread/VersionCheckThread.h | 52 |
14 files changed, 1081 insertions, 0 deletions
diff --git a/src/ui/thread/CtxCheckThread.cpp b/src/ui/thread/CtxCheckThread.cpp new file mode 100644 index 00000000..b51954e1 --- /dev/null +++ b/src/ui/thread/CtxCheckThread.cpp @@ -0,0 +1,48 @@ +/** + * 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 "CtxCheckThread.h" + +#include "gpg/GpgContext.h" +#include "gpg/GpgCoreInit.h" +#include "gpg/function/GpgKeyGetter.h" +#include "ui/UserInterfaceUtils.h" + +GpgFrontend::UI::CtxCheckThread::CtxCheckThread() : QThread(nullptr) { + connect(this, &CtxCheckThread::signalGnupgNotInstall, + CommonUtils::GetInstance(), &CommonUtils::signalGnupgNotInstall); +} + +void GpgFrontend::UI::CtxCheckThread::run() { + // Init GpgFrontend Core + init_gpgfrontend_core(); + + // Create & Check Gnupg Context Status + if (!GpgContext::GetInstance().good()) { + emit signalGnupgNotInstall(); + } + // Try fetching key + else + GpgFrontend::GpgKeyGetter::GetInstance().FetchKey(); +} diff --git a/src/ui/thread/CtxCheckThread.h b/src/ui/thread/CtxCheckThread.h new file mode 100644 index 00000000..74bdb491 --- /dev/null +++ b/src/ui/thread/CtxCheckThread.h @@ -0,0 +1,42 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_CTXCHECKTRHEAD_H +#define GPGFRONTEND_CTXCHECKTRHEAD_H +#include "ui/GpgFrontendUI.h" +namespace GpgFrontend::UI { +class CtxCheckThread : public QThread { + Q_OBJECT + public: + CtxCheckThread(); + + signals: + void signalGnupgNotInstall(); + + protected: + void run() override; +}; +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_CTXCHECKTRHEAD_H diff --git a/src/ui/thread/FileReadThread.cpp b/src/ui/thread/FileReadThread.cpp new file mode 100644 index 00000000..04f713bd --- /dev/null +++ b/src/ui/thread/FileReadThread.cpp @@ -0,0 +1,70 @@ +/** + * 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 "FileReadThread.h" + +#include <boost/filesystem.hpp> +#include <utility> + +namespace GpgFrontend::UI { + +FileReadThread::FileReadThread(std::string path) : path(std::move(path)) { + qRegisterMetaType<std::string>("std::string"); +} + +void FileReadThread::run() { + LOG(INFO) << "started"; + boost::filesystem::path read_file_path(this->path); + if (is_regular_file(read_file_path)) { + LOG(INFO) << "read open"; + + auto fp = fopen(read_file_path.string().c_str(), "rb"); + size_t read_size; + LOG(INFO) << "thread start reading"; + + char buffer[4096]; + while ((read_size = fread(buffer, sizeof(char), sizeof buffer, fp)) > 0) { + // Check isInterruptionRequested + if (QThread::currentThread()->isInterruptionRequested()) { + LOG(INFO) << "thread is interruption requested "; + fclose(fp); + return; + } + LOG(INFO) << "block size " << read_size; + std::string buffer_str(buffer, read_size); + + emit sendReadBlock(buffer_str); +#ifdef RELEASE + QThread::msleep(32); +#else + QThread::msleep(128); +#endif + } + fclose(fp); + emit readDone(); + LOG(INFO) << "thread end reading"; + } +} + +} // namespace GpgFrontend::UI diff --git a/src/ui/thread/FileReadThread.h b/src/ui/thread/FileReadThread.h new file mode 100644 index 00000000..65982848 --- /dev/null +++ b/src/ui/thread/FileReadThread.h @@ -0,0 +1,53 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_FILEREADTHREAD_H +#define GPGFRONTEND_FILEREADTHREAD_H + +#include "ui/GpgFrontendUI.h" + +namespace GpgFrontend::UI { + +class FileReadThread : public QThread { + Q_OBJECT + + public: + explicit FileReadThread(std::string path); + + signals: + + void sendReadBlock(const std::string& block); + + void readDone(); + + protected: + void run() override; + + private: + std::string path; +}; + +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_FILEREADTHREAD_H diff --git a/src/ui/thread/ProxyConnectionTestThread.cpp b/src/ui/thread/ProxyConnectionTestThread.cpp new file mode 100644 index 00000000..76cf525e --- /dev/null +++ b/src/ui/thread/ProxyConnectionTestThread.cpp @@ -0,0 +1,56 @@ +/** + * 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 "ProxyConnectionTestThread.h" + +void GpgFrontend::UI::ProxyConnectionTestThread::run() { + QNetworkProxyQuery npq({QUrl(url_)}); + auto proxies_list = QNetworkProxyFactory::systemProxyForQuery(npq); + + if (proxies_list.isEmpty()) { + LOG(INFO) << "no proxy applied"; + } else { + LOG(INFO) << "proxies list hostname" + << proxies_list.front().hostName().toStdString(); + } + + LOG(INFO) << "proxies list size" << proxies_list.size(); + + auto manager = std::make_unique<QNetworkAccessManager>(nullptr); + QNetworkRequest url_request; + url_request.setUrl(QUrl(url_)); + auto _reply = manager->get(url_request); + + while (_reply->isRunning()) QApplication::processEvents(); + auto _buffer = _reply->readAll(); + if (_reply->error() == QNetworkReply::NoError && !_buffer.isEmpty()) { + result_ = "Reachable"; + } else { + result_ = "Not Reachable"; + } + + _reply->deleteLater(); + + emit signalProxyConnectionTestResult(result_); +} diff --git a/src/ui/thread/ProxyConnectionTestThread.h b/src/ui/thread/ProxyConnectionTestThread.h new file mode 100644 index 00000000..4ef75050 --- /dev/null +++ b/src/ui/thread/ProxyConnectionTestThread.h @@ -0,0 +1,57 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_PROXYCONNECTIONTESTTHREAD_H +#define GPGFRONTEND_PROXYCONNECTIONTESTTHREAD_H + +class ProxyConnectionTestThread {}; + +#include <utility> + +#include "GpgFrontendUI.h" + +namespace GpgFrontend::UI { + +class ProxyConnectionTestThread : public QThread { + Q_OBJECT + public: + explicit ProxyConnectionTestThread(QString url, int timeout, + QWidget* parent = nullptr) + : QThread(parent), url_(std::move(url)), timeout_(timeout) {} + + signals: + void signalProxyConnectionTestResult(const QString& result); + + protected: + void run() override; + + private: + QString url_; + QString result_; + int timeout_ = 500; +}; + +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_PROXYCONNECTIONTESTTHREAD_H diff --git a/src/ui/thread/SMTPSendMailThread.cpp b/src/ui/thread/SMTPSendMailThread.cpp new file mode 100644 index 00000000..edfd3156 --- /dev/null +++ b/src/ui/thread/SMTPSendMailThread.cpp @@ -0,0 +1,261 @@ +/** + * 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() && !attach_signature_file_) { + message.getContent().setContentType( + "multipart/encrypted; " + "protocol=\"application/pgp-encrypted\""); + } + + if (attach_signature_file_ && !private_key_id_.empty()) { + message.getContent().setContentType( + "multipart/signed; " + "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()); + + // The multipart/encrypted MIME body MUST consist of exactly two body + // parts, the first with content type "application/pgp-encrypted". This + // body contains the control information. A message complying with this + // standard MUST contain a "Version: 1" field in this body. Since the + // OpenPGP packet format contains all other information necessary for + // decrypting, no other information is required here. + auto control_text = std::make_unique<MimeText>("Version: 1\r\n"); + control_text->setContentType("application/pgp-encrypted"); + send_texts_.push_back(std::move(control_text)); + // The second MIME body part MUST contain the actual encrypted data. It + // MUST be labeled with a content type of "application/octet-stream". + text->setContentType("application/octet-stream"); + } + + 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(); + // In particular, line endings in the encoded data + // MUST use the canonical <CR><LF> sequence where appropriate + auto encoded_text = plain_mime_text->getText(); + // As described in section 3 of this document, any trailing + // whitespace MUST then be removed from the signed material. + encoded_text = encoded_text.trimmed(); + encoded_text = encoded_text.replace('\n', "\r\n"); + // An implementation which elects to adhere to the OpenPGP convention + // has to make sure it inserts a <CR><LF> pair on the last line of the + // data to be signed and transmitted. + encoded_text.append("\r\n"); + plain_mime_text->setText(encoded_text); + + // This presents serious problems + // for multipart/signed, in particular, where the signature is + // invalidated when such an operation occurs. For this reason all data + // signed according to this protocol MUST be constrained to 7 bits (8- + // bit data MUST be encoded using either Quoted-Printable or Base64). + plain_mime_text->setEncoding(MimePart::_7Bit); + + // As described in [2], the digital signature MUST be calculated + // over both the data to be signed and its set of content headers. + auto text_calculated = plain_mime_text->toString().toStdString(); + + auto in_buffer = std::make_unique<ByteArray>(text_calculated); + auto key = GpgKeyGetter::GetInstance().GetKey(private_key_id_); + auto keys = std::make_unique<KeyArgsList>(); + keys->push_back(std::move(key)); + + // The signature MUST be generated detached from the signed data + // so that the process does not alter the signed data in any way. + 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++; + + // Set MIME Options + 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()); + + // set Message Integrity Check (MIC) algorithm + if (result->signatures != nullptr) { + // The "micalg" parameter for the "application/pgp-signature" + // protocol + // MUST contain exactly one hash-symbol of the format "pgp-<hash- + // identifier>", where <hash-identifier> identifies the Message + // Integrity Check (MIC) algorithm used to generate the signature. + // Hash-symbols are constructed from the text names registered in [1] + // or according to the mechanism defined in that document by + // converting the text name to lower case and prefixing it with the + // four characters "pgp-". + auto hash_algo_name = + std::string(gpgme_hash_algo_name(result->signatures->hash_algo)); + boost::algorithm::to_lower(hash_algo_name); + std::stringstream ss; + ss << message.getContent().getContentType().toStdString(); + ss << "; micalg=pgp-" << hash_algo_name; + message.getContent().setContentType(ss.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.trimmed()); + 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 diff --git a/src/ui/thread/SMTPSendMailThread.h b/src/ui/thread/SMTPSendMailThread.h new file mode 100644 index 00000000..3d723670 --- /dev/null +++ b/src/ui/thread/SMTPSendMailThread.h @@ -0,0 +1,102 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_SMTPSENDMAILTHREAD_H +#define GPGFRONTEND_SMTPSENDMAILTHREAD_H + +#include <utility> + +#include "ui/GpgFrontendUI.h" + +namespace GpgFrontend::UI { +class SMTPSendMailThread : public QThread { + Q_OBJECT + public: + explicit SMTPSendMailThread(std::string host, int port, + SmtpClient::ConnectionType connection_type, + bool identify, std::string username, + std::string password, QWidget* parent = nullptr) + : QThread(parent), + host_(std::move(host)), + port_(port), + connection_type_(connection_type), + identify_(identify), + username_(std::move(username)), + password_(std::move(password)) {} + + void setSender(const QString& sender); + + void setRecipient(const QString& recipients); + + void setCC(const QString& ccs); + + void setBCC(const QString& bccs); + + void setSubject(const QString& subject) { message.setSubject(subject); } + + void addTextContent(const QString& content); + + void addFileContent(const QString& file_name, const QByteArray& content); + + void setEncryptContent(bool encrypt_content, + GpgFrontend::KeyIdArgsListPtr public_key_ids); + + void setAttachSignatureFile(bool attach_signature_file, + GpgFrontend::KeyId private_key_id); + + void setAttachPublicKey(bool attach_public_key_file, + GpgFrontend::KeyId attached_public_key_ids); + + signals: + void signalSMTPResult(const QString& result); + + protected: + void run() override; + + private: + // SMTP Options + std::string host_; + int port_; + SmtpClient::ConnectionType connection_type_; + + bool identify_; + std::string username_; + std::string password_; + + MimeMessage message; + std::vector<std::unique_ptr<MimeText>> texts_; + std::vector<std::unique_ptr<MimeText>> send_texts_; + std::vector<std::unique_ptr<MimeFile>> files_; + + // GPG Options + bool encrypt_content_ = false; + GpgFrontend::KeyIdArgsListPtr public_key_ids_; + bool attach_signature_file_ = false; + GpgFrontend::KeyId private_key_id_; + bool attach_public_key_file_ = false; + GpgFrontend::KeyId attached_public_key_ids_; +}; +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_SMTPSENDMAILTHREAD_H diff --git a/src/ui/thread/SMTPTestThread.cpp b/src/ui/thread/SMTPTestThread.cpp new file mode 100644 index 00000000..0eb267f2 --- /dev/null +++ b/src/ui/thread/SMTPTestThread.cpp @@ -0,0 +1,46 @@ +/** + * 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 "SMTPTestThread.h" +namespace GpgFrontend::UI { + +void SMTPTestThread::run() { + SmtpClient smtp(host_.c_str(), port_, connection_type_); + if (identify_) { + smtp.setUser(username_.c_str()); + smtp.setPassword(password_.c_str()); + } + if (!smtp.connectToHost()) { + emit signalSMTPTestResult("Fail to connect SMTP server"); + return; + } + if (!smtp.login()) { + emit signalSMTPTestResult("Fail to login"); + return; + } + smtp.quit(); + emit signalSMTPTestResult("Succeed in testing connection"); +} + +} // namespace GpgFrontend::UI diff --git a/src/ui/thread/SMTPTestThread.h b/src/ui/thread/SMTPTestThread.h new file mode 100644 index 00000000..c51ac3fd --- /dev/null +++ b/src/ui/thread/SMTPTestThread.h @@ -0,0 +1,67 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_SMTPTESTTHREAD_H +#define GPGFRONTEND_SMTPTESTTHREAD_H + +#include <utility> + +#include "ui/GpgFrontendUI.h" + +namespace GpgFrontend::UI { + +class SMTPTestThread : public QThread { + Q_OBJECT + public: + explicit SMTPTestThread(std::string host, int port, + SmtpClient::ConnectionType connection_type, + bool identify, std::string username, + std::string password, QWidget* parent = nullptr) + : QThread(parent), + host_(std::move(host)), + port_(port), + connection_type_(connection_type), + identify_(identify), + username_(std::move(username)), + password_(std::move(password)) {} + + signals: + void signalSMTPTestResult(const QString& result); + + protected: + void run() override; + + private: + std::string host_; + int port_; + SmtpClient::ConnectionType connection_type_; + + bool identify_; + std::string username_; + std::string password_; +}; + +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_SMTPTESTTHREAD_H diff --git a/src/ui/thread/TestListedKeyServerThread.cpp b/src/ui/thread/TestListedKeyServerThread.cpp new file mode 100644 index 00000000..4f816860 --- /dev/null +++ b/src/ui/thread/TestListedKeyServerThread.cpp @@ -0,0 +1,47 @@ +/** + * 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 "TestListedKeyServerThread.h" + +void GpgFrontend::UI::TestListedKeyServerThread::run() { + for (const auto& url : urls_) { + const auto keyserver_url = url; + + auto key_url = QUrl{keyserver_url}; + + LOG(INFO) << "key server domain" << key_url.host().toStdString(); + + QTcpSocket socket(nullptr); + socket.abort(); + socket.connectToHost(key_url.host(), 80); + if (socket.waitForConnected(timeout_)) { + result_.push_back("Reachable"); + } else { + result_.push_back("Not Reachable"); + } + socket.close(); + } + + emit signalKeyServerListTestResult(result_); +} diff --git a/src/ui/thread/TestListedKeyServerThread.h b/src/ui/thread/TestListedKeyServerThread.h new file mode 100644 index 00000000..99fd6c6d --- /dev/null +++ b/src/ui/thread/TestListedKeyServerThread.h @@ -0,0 +1,55 @@ +/** + * 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. + * + */ + +#ifndef GPGFRONTEND_TESTLISTEDKEYSERVERTHREAD_H +#define GPGFRONTEND_TESTLISTEDKEYSERVERTHREAD_H + +#include "GpgFrontendUI.h" + +namespace GpgFrontend::UI { + +class TestListedKeyServerThread : public QThread { + Q_OBJECT + public: + explicit TestListedKeyServerThread(const QStringList& urls, int timeout, + QWidget* parent = nullptr) + : QThread(parent), urls_(urls), timeout_(timeout) {} + + signals: + void signalKeyServerListTestResult(const QStringList& result); + + protected: + void run() override; + + private: + QStringList urls_; + QStringList result_; + int timeout_ = 500; +}; + +} // namespace GpgFrontend::UI + +class TestListedKeyServerThread {}; + +#endif // GPGFRONTEND_TESTLISTEDKEYSERVERTHREAD_H diff --git a/src/ui/thread/VersionCheckThread.cpp b/src/ui/thread/VersionCheckThread.cpp new file mode 100644 index 00000000..8b2487d8 --- /dev/null +++ b/src/ui/thread/VersionCheckThread.cpp @@ -0,0 +1,125 @@ +/** + * 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]> starting on May 12, 2021. + * + */ + +#include "VersionCheckThread.h" + +#include <QMetaType> +#include <nlohmann/json.hpp> + +#include "GpgFrontendBuildInfo.h" + +namespace GpgFrontend::UI { + +void VersionCheckThread::run() { + auto current_version = std::string("v") + std::to_string(VERSION_MAJOR) + + "." + std::to_string(VERSION_MINOR) + "." + + std::to_string(VERSION_PATCH); + + SoftwareVersion version; + version.current_version = current_version; + + auto manager = std::make_unique<QNetworkAccessManager>(nullptr); + + try { + using namespace nlohmann; + LOG(INFO) << "current version" << current_version; + + std::string latest_version_url = + "https://api.github.com/repos/saturneric/gpgfrontend/releases/latest"; + std::string current_version_url = + "https://api.github.com/repos/saturneric/gpgfrontend/releases/tags/" + + current_version; + + QNetworkRequest latest_request, current_request; + latest_request.setUrl(QUrl(latest_version_url.c_str())); + current_request.setUrl(QUrl(current_version_url.c_str())); + auto _reply = manager->get(latest_request); + while (_reply->isRunning()) QApplication::processEvents(); + if (_reply->error() != QNetworkReply::NoError) { + LOG(ERROR) << "current version request error"; + version.latest_version = current_version; + } else { + latest_reply_bytes_ = _reply->readAll(); + auto latest_reply_json = + nlohmann::json::parse(latest_reply_bytes_.toStdString()); + + std::string latest_version = latest_reply_json["tag_name"]; + + LOG(INFO) << "latest version from Github" << latest_version; + + QRegularExpression re(R"(^[vV](\d+\.)?(\d+\.)?(\*|\d+))"); + auto version_match = re.match(latest_version.c_str()); + if (version_match.hasMatch()) { + latest_version = version_match.captured(0).toStdString(); + LOG(INFO) << "latest version matched" << latest_version; + } else { + latest_version = current_version; + LOG(WARNING) << "latest version unknown"; + } + + bool prerelease = latest_reply_json["prerelease"], + draft = latest_reply_json["draft"]; + std::string publish_date = latest_reply_json["published_at"]; + std::string release_note = latest_reply_json["body"]; + version.latest_version = latest_version; + version.latest_prerelease = prerelease; + version.latest_draft = draft; + version.publish_date = publish_date; + version.release_note = release_note; + } + + _reply->deleteLater(); + + _reply = manager->get(current_request); + while (_reply->isRunning()) QApplication::processEvents(); + current_reply_bytes_ = _reply->readAll(); + if (_reply->error() != QNetworkReply::NoError) { + LOG(ERROR) << "current version request network error"; + version.current_version_found = false; + } else { + version.current_version_found = true; + auto current_reply_json = + nlohmann::json::parse(current_reply_bytes_.toStdString()); + bool current_prerelease = current_reply_json["prerelease"], + current_draft = current_reply_json["draft"]; + version.latest_prerelease = current_prerelease; + version.latest_draft = current_draft; + } + _reply->deleteLater(); + + // loading done + version.load_info_done = true; + + } catch (...) { + LOG(INFO) << "error occurred"; + version.load_info_done = false; + } + emit upgradeVersion(version); +} + +VersionCheckThread::VersionCheckThread() : QThread(nullptr) { + qRegisterMetaType<SoftwareVersion>("SoftwareVersion"); +}; + +} // namespace GpgFrontend::UI diff --git a/src/ui/thread/VersionCheckThread.h b/src/ui/thread/VersionCheckThread.h new file mode 100644 index 00000000..0db9770c --- /dev/null +++ b/src/ui/thread/VersionCheckThread.h @@ -0,0 +1,52 @@ +/** + * 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]> starting on May 12, 2021. + * + */ + +#ifndef GPGFRONTEND_VERSIONCHECKTHREAD_H +#define GPGFRONTEND_VERSIONCHECKTHREAD_H + +#include "ui/GpgFrontendUI.h" +#include "ui/data_struct/SoftwareVersion.h" + +namespace GpgFrontend::UI { + +class VersionCheckThread : public QThread { + Q_OBJECT + + public: + explicit VersionCheckThread(); + + signals: + + void upgradeVersion(SoftwareVersion version); + + protected: + void run() override; + + private: + QByteArray latest_reply_bytes_, current_reply_bytes_; +}; + +} // namespace GpgFrontend::UI + +#endif // GPGFRONTEND_VERSIONCHECKTHREAD_H |