diff options
Diffstat (limited to 'src/ui/function')
| -rw-r--r-- | src/ui/function/CtxCheckThread.cpp | 48 | ||||
| -rw-r--r-- | src/ui/function/CtxCheckThread.h | 42 | ||||
| -rw-r--r-- | src/ui/function/FileReadThread.h | 3 | ||||
| -rw-r--r-- | src/ui/function/ProxyConnectionTestThread.cpp | 56 | ||||
| -rw-r--r-- | src/ui/function/ProxyConnectionTestThread.h | 57 | ||||
| -rw-r--r-- | src/ui/function/SMTPSendMailThread.cpp | 202 | ||||
| -rw-r--r-- | src/ui/function/SMTPSendMailThread.h | 106 | ||||
| -rw-r--r-- | src/ui/function/SMTPTestThread.cpp | 46 | ||||
| -rw-r--r-- | src/ui/function/SMTPTestThread.h | 70 | ||||
| -rw-r--r-- | src/ui/function/TestListedKeyServerThread.cpp | 47 | ||||
| -rw-r--r-- | src/ui/function/TestListedKeyServerThread.h | 55 | ||||
| -rw-r--r-- | src/ui/function/VersionCheckThread.cpp | 118 | ||||
| -rw-r--r-- | src/ui/function/VersionCheckThread.h | 8 |
13 files changed, 818 insertions, 40 deletions
diff --git a/src/ui/function/CtxCheckThread.cpp b/src/ui/function/CtxCheckThread.cpp new file mode 100644 index 00000000..b51954e1 --- /dev/null +++ b/src/ui/function/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/function/CtxCheckThread.h b/src/ui/function/CtxCheckThread.h new file mode 100644 index 00000000..74bdb491 --- /dev/null +++ b/src/ui/function/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/function/FileReadThread.h b/src/ui/function/FileReadThread.h index ebfcfb3c..46ed6cbc 100644 --- a/src/ui/function/FileReadThread.h +++ b/src/ui/function/FileReadThread.h @@ -26,6 +26,7 @@ #define GPGFRONTEND_FILEREADTHREAD_H #include "ui/GpgFrontendUI.h" + namespace GpgFrontend::UI { class FileReadThread : public QThread { @@ -35,7 +36,7 @@ class FileReadThread : public QThread { explicit FileReadThread(std::string path); signals: - + void sendReadBlock(const QString& block); void readDone(); diff --git a/src/ui/function/ProxyConnectionTestThread.cpp b/src/ui/function/ProxyConnectionTestThread.cpp new file mode 100644 index 00000000..76cf525e --- /dev/null +++ b/src/ui/function/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/function/ProxyConnectionTestThread.h b/src/ui/function/ProxyConnectionTestThread.h new file mode 100644 index 00000000..4ef75050 --- /dev/null +++ b/src/ui/function/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/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 diff --git a/src/ui/function/SMTPSendMailThread.h b/src/ui/function/SMTPSendMailThread.h new file mode 100644 index 00000000..e5c9e27f --- /dev/null +++ b/src/ui/function/SMTPSendMailThread.h @@ -0,0 +1,106 @@ +/** + * 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> + +#ifdef SMTP_SUPPORT +#include "smtp/SmtpMime" +#endif + +#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/function/SMTPTestThread.cpp b/src/ui/function/SMTPTestThread.cpp new file mode 100644 index 00000000..0eb267f2 --- /dev/null +++ b/src/ui/function/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/function/SMTPTestThread.h b/src/ui/function/SMTPTestThread.h new file mode 100644 index 00000000..db61d97d --- /dev/null +++ b/src/ui/function/SMTPTestThread.h @@ -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. + * + */ + +#ifndef GPGFRONTEND_SMTPTESTTHREAD_H +#define GPGFRONTEND_SMTPTESTTHREAD_H + +#include <utility> + +#ifdef SMTP_SUPPORT +#include "smtp/SmtpMime" +#endif + +#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/function/TestListedKeyServerThread.cpp b/src/ui/function/TestListedKeyServerThread.cpp new file mode 100644 index 00000000..4f816860 --- /dev/null +++ b/src/ui/function/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/function/TestListedKeyServerThread.h b/src/ui/function/TestListedKeyServerThread.h new file mode 100644 index 00000000..99fd6c6d --- /dev/null +++ b/src/ui/function/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/function/VersionCheckThread.cpp b/src/ui/function/VersionCheckThread.cpp index bad60ef4..2a1cf9af 100644 --- a/src/ui/function/VersionCheckThread.cpp +++ b/src/ui/function/VersionCheckThread.cpp @@ -24,8 +24,7 @@ #include "VersionCheckThread.h" -#include <iterator> -#include <regex> +#include <QMetaType> #include "GpgFrontendBuildInfo.h" #include "json/json.hpp" @@ -33,45 +32,94 @@ namespace GpgFrontend::UI { void VersionCheckThread::run() { - using namespace nlohmann; - - LOG(INFO) << "get latest version from Github"; - auto current_version = std::string("v") + std::to_string(VERSION_MAJOR) + "." + std::to_string(VERSION_MINOR) + "." + std::to_string(VERSION_PATCH); - while (mNetworkReply->isRunning()) { - QApplication::processEvents(); - } - - if (mNetworkReply->error() != QNetworkReply::NoError) { - LOG(ERROR) << "network error"; - return; + 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; } - - auto bytes = mNetworkReply->readAll(); - - auto reply_json = nlohmann::json::parse(bytes.toStdString()); - - std::string latest_version = 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"; - } - - emit upgradeVersion(current_version.c_str(), latest_version.c_str()); + emit upgradeVersion(version); } -VersionCheckThread::VersionCheckThread(QNetworkReply* networkReply) - : mNetworkReply(networkReply) {} +VersionCheckThread::VersionCheckThread() : QThread(nullptr) { + qRegisterMetaType<SoftwareVersion>("SoftwareVersion"); +}; } // namespace GpgFrontend::UI diff --git a/src/ui/function/VersionCheckThread.h b/src/ui/function/VersionCheckThread.h index 181ee947..0db9770c 100644 --- a/src/ui/function/VersionCheckThread.h +++ b/src/ui/function/VersionCheckThread.h @@ -26,6 +26,7 @@ #define GPGFRONTEND_VERSIONCHECKTHREAD_H #include "ui/GpgFrontendUI.h" +#include "ui/data_struct/SoftwareVersion.h" namespace GpgFrontend::UI { @@ -33,18 +34,17 @@ class VersionCheckThread : public QThread { Q_OBJECT public: - explicit VersionCheckThread(QNetworkReply* networkReply); + explicit VersionCheckThread(); signals: - void upgradeVersion(const QString& currentVersion, - const QString& latestVersion); + void upgradeVersion(SoftwareVersion version); protected: void run() override; private: - QNetworkReply* mNetworkReply; + QByteArray latest_reply_bytes_, current_reply_bytes_; }; } // namespace GpgFrontend::UI |