From 5f9ce33562c0ae58c8dc36ed422f09922b1fb4d2 Mon Sep 17 00:00:00 2001 From: jonnius Date: Fri, 8 May 2020 22:00:56 +0200 Subject: [PATCH 01/13] Update Ubuntu install and build instructions --- README.md | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 761318a3..94c37253 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ can be found in the [Github releases](https://github.com/Nheko-Reborn/nheko/rele pacaur -S nheko # nheko-git ``` -#### Debian (10 and above) +#### Debian (10 and above) / Ubuntu (18.04 and above) ```bash sudo apt install nheko @@ -179,22 +179,14 @@ sudo pacman -S qt5-base \ sudo emerge -a ">=dev-qt/qtgui-5.9.0" media-libs/fontconfig ``` -##### Ubuntu 16.04 - -```bash -sudo add-apt-repository ppa:beineri/opt-qt592-xenial -sudo add-apt-repository ppa:george-edison55/cmake-3.x -sudo add-apt-repository ppa:ubuntu-toolchain-r-test -sudo apt-get update -sudo apt-get install -y g++-7 qt59base qt59svg qt59tools qt59multimedia cmake liblmdb-dev libsodium-dev -``` - -##### Ubuntu 19.10 +##### Ubuntu 20.04 ```bash # Build requirements + qml modules needed at runtime (you may not need all of them, but the following seem to work according to reports): -sudo apt install g++-7 cmake liblmdb-dev libsodium-dev libssl-dev qt{base,declarative,tools,multimedia,script,quickcontrols2-}5-dev qml-module-qt{gstreamer,multimedia,quick-extras,-labs-settings,graphicaleffects,quick-controls2} libqt5svg5-dev +sudo apt install g++ cmake zlib1g-dev libssl-dev qt{base,declarative,tools,multimedia,quickcontrols2-}5-dev libqt5svg5-dev libboost-system-dev libboost-thread-dev libboost-iostreams-dev libolm-dev libsodium-dev liblmdb++-dev libcmark-dev nlohmann-json3-dev libspdlog-dev libgtest-dev qml-module-qt{gstreamer,multimedia,quick-extras,-labs-settings,graphicaleffects,quick-controls2} ``` +This will install all dependencies, except for tweeny (use bundled tweeny) +and mtxclient (needs to be build separately). ##### Debian Buster (or higher probably) @@ -283,7 +275,7 @@ Examples for the paths are: You should also enable hunter by setting `HUNTER_ENABLED` to `ON` and `BUILD_SHARED_LIBS` to `OFF`. Now right click into the root nheko source directory and choose `Open in Visual Studio`. -You can choose the build type Release and Debug in the top toolbar. +You can choose the build type Release and Debug in the top toolbar. After a successful CMake generation you can select the `nheko.exe` as the run target. Now choose `Build all` in the CMake menu or press `F7` to compile the executable. From 813790e6031d0fef07be73c489ebaf59d3d1af4b Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sat, 9 May 2020 13:06:47 +0200 Subject: [PATCH 02/13] Improve Login and Register page hinting --- src/LoginPage.cpp | 14 ++++++++++++++ src/RegisterPage.cpp | 11 ++++++++++- src/ui/TextField.cpp | 5 ++++- 3 files changed, 28 insertions(+), 2 deletions(-) diff --git a/src/LoginPage.cpp b/src/LoginPage.cpp index 20fb3888..6d96419a 100644 --- a/src/LoginPage.cpp +++ b/src/LoginPage.cpp @@ -81,6 +81,14 @@ LoginPage::LoginPage(QWidget *parent) matrixid_input_ = new TextField(this); matrixid_input_->setLabel(tr("Matrix ID")); matrixid_input_->setPlaceholderText(tr("e.g @joe:matrix.org")); + matrixid_input_->setToolTip( + tr("Your login name. A mxid should start with @ followed by the user id. After the user " + "id you need to include your server name after a :.\nYou can also put your homeserver " + "address there, if your server doesn't support .well-known lookup.\nExample: " + "@user:server.my\nIf Nheko fails to discover your homeserver, it will show you a " + "field to enter the server manually.")); + matrixid_input_->setValidator( + new QRegularExpressionValidator(QRegularExpression("@.+?:.{3,}"), this)); spinner_ = new LoadingIndicator(this); spinner_->setFixedHeight(40); @@ -97,13 +105,19 @@ LoginPage::LoginPage(QWidget *parent) password_input_ = new TextField(this); password_input_->setLabel(tr("Password")); password_input_->setEchoMode(QLineEdit::Password); + password_input_->setToolTip("Your password."); deviceName_ = new TextField(this); deviceName_->setLabel(tr("Device name")); + deviceName_->setToolTip( + tr("A name for this device, which will be shown to others, when verifying your devices. " + "If none is provided, a random string is used for privacy purposes.")); serverInput_ = new TextField(this); serverInput_->setLabel("Homeserver address"); serverInput_->setPlaceholderText("matrix.org"); + serverInput_->setToolTip(tr("The address that can be used to contact you homeservers " + "client API.\nExample: https://server.my:8787")); serverInput_->hide(); serverLayout_ = new QHBoxLayout(); diff --git a/src/RegisterPage.cpp b/src/RegisterPage.cpp index 2833381d..a01f2140 100644 --- a/src/RegisterPage.cpp +++ b/src/RegisterPage.cpp @@ -85,17 +85,26 @@ RegisterPage::RegisterPage(QWidget *parent) username_input_ = new TextField(); username_input_->setLabel(tr("Username")); + username_input_->setValidator( + new QRegularExpressionValidator(QRegularExpression("[a-z0-9._=/-]+"), this)); + username_input_->setToolTip(tr("The username must not be empty, and must contain only the " + "characters a-z, 0-9, ., _, =, -, and /.")); password_input_ = new TextField(); password_input_->setLabel(tr("Password")); password_input_->setEchoMode(QLineEdit::Password); + password_input_->setToolTip(tr("Please choose a secure password. The exact requirements " + "for password strength may depend on your server")); password_confirmation_ = new TextField(); password_confirmation_->setLabel(tr("Password confirmation")); password_confirmation_->setEchoMode(QLineEdit::Password); server_input_ = new TextField(); - server_input_->setLabel(tr("Home Server")); + server_input_->setLabel(tr("Homeserver")); + server_input_->setToolTip( + tr("A server that allows registration. Since matrix is decentralized, you need to first " + "find a server you can register on or host your own.")); form_layout_->addWidget(username_input_, Qt::AlignHCenter, nullptr); form_layout_->addWidget(password_input_, Qt::AlignHCenter, nullptr); diff --git a/src/ui/TextField.cpp b/src/ui/TextField.cpp index 4bb7596a..27584693 100644 --- a/src/ui/TextField.cpp +++ b/src/ui/TextField.cpp @@ -147,7 +147,10 @@ QColor TextField::underlineColor() const { if (!underline_color_.isValid()) { - return QPalette().color(QPalette::Highlight); + if (hasAcceptableInput() || !isModified()) + return QPalette().color(QPalette::Highlight); + else + return Qt::red; } return underline_color_; From 7b1fa60cc6c74a53de0af636fa8f4f06caf87fa0 Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sat, 9 May 2020 23:31:00 +0200 Subject: [PATCH 03/13] Add SSO closes #94 --- CMakeLists.txt | 4 +- src/ChatPage.cpp | 8 +- src/LoginPage.cpp | 113 +- src/LoginPage.h | 11 +- src/SSOHandler.cpp | 54 + src/SSOHandler.h | 24 + third_party/cpp-httplib-0.5.12/httplib.h | 5125 ++++++++++++++++++++++ 7 files changed, 5311 insertions(+), 28 deletions(-) create mode 100644 src/SSOHandler.cpp create mode 100644 src/SSOHandler.h create mode 100644 third_party/cpp-httplib-0.5.12/httplib.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 10a49dce..97cb8ea2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -294,6 +294,7 @@ set(SRC_FILES src/RegisterPage.cpp src/RoomInfoListItem.cpp src/RoomList.cpp + src/SSOHandler.cpp src/SideBarActions.cpp src/Splitter.cpp src/TextInputWidget.cpp @@ -493,6 +494,7 @@ qt5_wrap_cpp(MOC_HEADERS src/RegisterPage.h src/RoomInfoListItem.h src/RoomList.h + src/SSOHandler.h src/SideBarActions.h src/Splitter.h src/TextInputWidget.h @@ -556,7 +558,7 @@ elseif(WIN32) else() target_link_libraries (nheko PRIVATE Qt5::DBus) endif() -target_include_directories(nheko PRIVATE src includes third_party/blurhash) +target_include_directories(nheko PRIVATE src includes third_party/blurhash third_party/cpp-httplib-0.5.12) target_link_libraries(nheko PRIVATE MatrixClient::MatrixClient diff --git a/src/ChatPage.cpp b/src/ChatPage.cpp index ae3c7a11..7c4aac77 100644 --- a/src/ChatPage.cpp +++ b/src/ChatPage.cpp @@ -988,8 +988,12 @@ ChatPage::trySync() const auto err_code = mtx::errors::to_string(err->matrix_error.errcode); const int status_code = static_cast(err->status_code); - if (http::is_logged_in() && err->matrix_error.errcode == - mtx::errors::ErrorCode::M_UNKNOWN_TOKEN) { + if ((http::is_logged_in() && + (err->matrix_error.errcode == + mtx::errors::ErrorCode::M_UNKNOWN_TOKEN || + err->matrix_error.errcode == + mtx::errors::ErrorCode::M_MISSING_TOKEN)) || + !http::is_logged_in()) { emit dropToLoginPageCb(msg); return; } diff --git a/src/LoginPage.cpp b/src/LoginPage.cpp index 6d96419a..4c3999ec 100644 --- a/src/LoginPage.cpp +++ b/src/LoginPage.cpp @@ -15,28 +15,35 @@ * along with this program. If not, see . */ +#include #include #include #include +#include #include #include "Config.h" #include "Logging.h" #include "LoginPage.h" #include "MatrixClient.h" +#include "SSOHandler.h" #include "ui/FlatButton.h" #include "ui/LoadingIndicator.h" #include "ui/OverlayModal.h" #include "ui/RaisedButton.h" #include "ui/TextField.h" +Q_DECLARE_METATYPE(LoginPage::LoginMethod) + using namespace mtx::identifiers; LoginPage::LoginPage(QWidget *parent) : QWidget(parent) , inferredServerAddress_() { + qRegisterMetaType("LoginPage::LoginMethod"); + top_layout_ = new QVBoxLayout(); top_bar_layout_ = new QHBoxLayout(); @@ -226,7 +233,8 @@ LoginPage::onMatrixIdEntered() emit versionErrorCb(tr("Autodiscovery failed. Unknown error when " "requesting .well-known.")); nhlog::net()->error("Autodiscovery failed. Unknown error when " - "requesting .well-known."); + "requesting .well-known. {}", + err->status_code); return; } @@ -263,7 +271,16 @@ LoginPage::checkHomeserverVersion() return; } - emit versionOkCb(); + http::client()->get_login( + [this](mtx::responses::LoginFlows flows, mtx::http::RequestErr err) { + if (err || flows.flows.empty()) + emit versionOkCb(LoginMethod::Password); + + if (flows.flows[0].type == mtx::user_interactive::auth_types::sso) + emit versionOkCb(LoginMethod::SSO); + else + emit versionOkCb(LoginMethod::Password); + }); }); } @@ -294,12 +311,22 @@ LoginPage::versionError(const QString &error) } void -LoginPage::versionOk() +LoginPage::versionOk(LoginMethod loginMethod) { + this->loginMethod = loginMethod; + serverLayout_->removeWidget(spinner_); matrixidLayout_->removeWidget(spinner_); spinner_->stop(); + if (loginMethod == LoginMethod::SSO) { + password_input_->hide(); + login_button_->setText(tr("SSO LOGIN")); + } else { + password_input_->show(); + login_button_->setText(tr("LOGIN")); + } + if (serverInput_->isVisible()) serverInput_->hide(); } @@ -317,29 +344,68 @@ LoginPage::onLoginButtonClicked() return loginError("You have entered an invalid Matrix ID e.g @joe:matrix.org"); } - if (password_input_->text().isEmpty()) - return loginError(tr("Empty password")); + if (loginMethod == LoginMethod::Password) { + if (password_input_->text().isEmpty()) + return loginError(tr("Empty password")); - http::client()->login( - user.localpart(), - password_input_->text().toStdString(), - deviceName_->text().trimmed().isEmpty() ? initialDeviceName() - : deviceName_->text().toStdString(), - [this](const mtx::responses::Login &res, mtx::http::RequestErr err) { - if (err) { - emit loginError(QString::fromStdString(err->matrix_error.error)); - emit errorOccurred(); - return; - } + http::client()->login( + user.localpart(), + password_input_->text().toStdString(), + deviceName_->text().trimmed().isEmpty() ? initialDeviceName() + : deviceName_->text().toStdString(), + [this](const mtx::responses::Login &res, mtx::http::RequestErr err) { + if (err) { + emit loginError(QString::fromStdString(err->matrix_error.error)); + emit errorOccurred(); + return; + } - if (res.well_known) { - http::client()->set_server(res.well_known->homeserver.base_url); - nhlog::net()->info("Login requested to user server: " + - res.well_known->homeserver.base_url); - } + if (res.well_known) { + http::client()->set_server(res.well_known->homeserver.base_url); + nhlog::net()->info("Login requested to user server: " + + res.well_known->homeserver.base_url); + } - emit loginOk(res); - }); + emit loginOk(res); + }); + } else { + auto sso = new SSOHandler(); + connect(sso, &SSOHandler::ssoSuccess, this, [this, sso](std::string token) { + mtx::requests::Login req{}; + req.token = token; + req.type = mtx::user_interactive::auth_types::token; + req.device_id = deviceName_->text().trimmed().isEmpty() + ? initialDeviceName() + : deviceName_->text().toStdString(); + http::client()->login( + req, [this](const mtx::responses::Login &res, mtx::http::RequestErr err) { + if (err) { + emit loginError( + QString::fromStdString(err->matrix_error.error)); + emit errorOccurred(); + return; + } + + if (res.well_known) { + http::client()->set_server( + res.well_known->homeserver.base_url); + nhlog::net()->info("Login requested to user server: " + + res.well_known->homeserver.base_url); + } + + emit loginOk(res); + }); + sso->deleteLater(); + }); + connect(sso, &SSOHandler::ssoFailed, this, [this, sso]() { + emit loginError(tr("SSO login failed")); + emit errorOccurred(); + sso->deleteLater(); + }); + + QDesktopServices::openUrl( + QString::fromStdString(http::client()->login_sso_redirect(sso->url()))); + } emit loggingIn(); } @@ -349,6 +415,7 @@ LoginPage::reset() { matrixid_input_->clear(); password_input_->clear(); + password_input_->show(); serverInput_->clear(); spinner_->stop(); diff --git a/src/LoginPage.h b/src/LoginPage.h index 4b84abfc..8a402aea 100644 --- a/src/LoginPage.h +++ b/src/LoginPage.h @@ -38,6 +38,12 @@ class LoginPage : public QWidget Q_OBJECT public: + enum class LoginMethod + { + Password, + SSO, + }; + LoginPage(QWidget *parent = nullptr); void reset(); @@ -50,7 +56,7 @@ signals: //! Used to trigger the corresponding slot outside of the main thread. void versionErrorCb(const QString &err); void loginErrorCb(const QString &err); - void versionOkCb(); + void versionOkCb(LoginPage::LoginMethod method); void loginOk(const mtx::responses::Login &res); @@ -77,7 +83,7 @@ private slots: // Callback for errors produced during server probing void versionError(const QString &error_message); // Callback for successful server probing - void versionOk(); + void versionOk(LoginPage::LoginMethod method); private: bool isMatrixIdValid(); @@ -123,4 +129,5 @@ private: TextField *password_input_; TextField *deviceName_; TextField *serverInput_; + LoginMethod loginMethod = LoginMethod::Password; }; diff --git a/src/SSOHandler.cpp b/src/SSOHandler.cpp new file mode 100644 index 00000000..0ee2fc17 --- /dev/null +++ b/src/SSOHandler.cpp @@ -0,0 +1,54 @@ +#include "SSOHandler.h" + +#include + +#include + +#include "Logging.h" + +SSOHandler::SSOHandler(QObject *) +{ + QTimer::singleShot(120000, this, &SSOHandler::ssoFailed); + + using namespace httplib; + + svr.set_logger([](const Request &req, const Response &res) { + nhlog::net()->info("req: {}, res: {}", req.path, res.status); + }); + + svr.Get("/sso", [this](const Request &req, Response &res) { + if (req.has_param("loginToken")) { + auto val = req.get_param_value("loginToken"); + res.set_content("SSO success", "text/plain"); + emit ssoSuccess(val); + } else { + res.set_content("Missing loginToken for SSO login!", "text/plain"); + emit ssoFailed(); + } + }); + + std::thread t([this]() { + this->port = svr.bind_to_any_port("localhost"); + svr.listen_after_bind(); + + }); + t.detach(); + + while (!svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } +} + +SSOHandler::~SSOHandler() +{ + svr.stop(); + while (svr.is_running()) { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } +} + +std::string +SSOHandler::url() const +{ + return "http://localhost:" + std::to_string(port) + "/sso"; +} diff --git a/src/SSOHandler.h b/src/SSOHandler.h new file mode 100644 index 00000000..325b7a58 --- /dev/null +++ b/src/SSOHandler.h @@ -0,0 +1,24 @@ +#include "httplib.h" + +#include +#include + +class SSOHandler : public QObject +{ + Q_OBJECT + +public: + SSOHandler(QObject *parent = nullptr); + + ~SSOHandler(); + + std::string url() const; + +signals: + void ssoSuccess(std::string token); + void ssoFailed(); + +private: + httplib::Server svr; + int port = 0; +}; diff --git a/third_party/cpp-httplib-0.5.12/httplib.h b/third_party/cpp-httplib-0.5.12/httplib.h new file mode 100644 index 00000000..7816df8b --- /dev/null +++ b/third_party/cpp-httplib-0.5.12/httplib.h @@ -0,0 +1,5125 @@ +// +// httplib.h +// +// Copyright (c) 2020 Yuji Hirose. All rights reserved. +// MIT License +// + +#ifndef CPPHTTPLIB_HTTPLIB_H +#define CPPHTTPLIB_HTTPLIB_H + +/* + * Configuration + */ + +#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND +#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5 +#endif + +#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND +#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND 0 +#endif + +#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT +#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5 +#endif + +#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND +#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5 +#endif + +#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND +#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0 +#endif + +#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH +#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192 +#endif + +#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT +#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20 +#endif + +#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH +#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits::max)()) +#endif + +#ifndef CPPHTTPLIB_RECV_BUFSIZ +#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u) +#endif + +#ifndef CPPHTTPLIB_THREAD_POOL_COUNT +#define CPPHTTPLIB_THREAD_POOL_COUNT \ + ((std::max)(8u, std::thread::hardware_concurrency() - 1)) +#endif + +/* + * Headers + */ + +#ifdef _WIN32 +#ifndef _CRT_SECURE_NO_WARNINGS +#define _CRT_SECURE_NO_WARNINGS +#endif //_CRT_SECURE_NO_WARNINGS + +#ifndef _CRT_NONSTDC_NO_DEPRECATE +#define _CRT_NONSTDC_NO_DEPRECATE +#endif //_CRT_NONSTDC_NO_DEPRECATE + +#if defined(_MSC_VER) +#ifdef _WIN64 +using ssize_t = __int64; +#else +using ssize_t = int; +#endif + +#if _MSC_VER < 1900 +#define snprintf _snprintf_s +#endif +#endif // _MSC_VER + +#ifndef S_ISREG +#define S_ISREG(m) (((m)&S_IFREG) == S_IFREG) +#endif // S_ISREG + +#ifndef S_ISDIR +#define S_ISDIR(m) (((m)&S_IFDIR) == S_IFDIR) +#endif // S_ISDIR + +#ifndef NOMINMAX +#define NOMINMAX +#endif // NOMINMAX + +#include +#include +#include + +#ifndef WSA_FLAG_NO_HANDLE_INHERIT +#define WSA_FLAG_NO_HANDLE_INHERIT 0x80 +#endif + +#ifdef _MSC_VER +#pragma comment(lib, "ws2_32.lib") +#endif + +#ifndef strcasecmp +#define strcasecmp _stricmp +#endif // strcasecmp + +using socket_t = SOCKET; +#ifdef CPPHTTPLIB_USE_POLL +#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout) +#endif + +#else // not _WIN32 + +#include +#include +#include +#include +#include +#ifdef CPPHTTPLIB_USE_POLL +#include +#endif +#include +#include +#include +#include +#include + +using socket_t = int; +#define INVALID_SOCKET (-1) +#endif //_WIN32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +#include +#include +#include +#include + +#include +#include +#include + +// #if OPENSSL_VERSION_NUMBER < 0x1010100fL +// #error Sorry, OpenSSL versions prior to 1.1.1 are not supported +// #endif + +#if OPENSSL_VERSION_NUMBER < 0x10100000L +#include +inline const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *asn1) { + return M_ASN1_STRING_data(asn1); +} +#endif +#endif + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +#include +#endif +/* + * Declaration + */ +namespace httplib { + +namespace detail { + +struct ci { + bool operator()(const std::string &s1, const std::string &s2) const { + return std::lexicographical_compare( + s1.begin(), s1.end(), s2.begin(), s2.end(), + [](char c1, char c2) { return ::tolower(c1) < ::tolower(c2); }); + } +}; + +} // namespace detail + +using Headers = std::multimap; + +using Params = std::multimap; +using Match = std::smatch; + +using Progress = std::function; + +struct Response; +using ResponseHandler = std::function; + +struct MultipartFormData { + std::string name; + std::string content; + std::string filename; + std::string content_type; +}; +using MultipartFormDataItems = std::vector; +using MultipartFormDataMap = std::multimap; + +class DataSink { +public: + DataSink() = default; + DataSink(const DataSink &) = delete; + DataSink &operator=(const DataSink &) = delete; + DataSink(DataSink &&) = delete; + DataSink &operator=(DataSink &&) = delete; + + std::function write; + std::function done; + std::function is_writable; +}; + +using ContentProvider = + std::function; + +using ContentReceiver = + std::function; + +using MultipartContentHeader = + std::function; + +class ContentReader { +public: + using Reader = std::function; + using MultipartReader = std::function; + + ContentReader(Reader reader, MultipartReader muitlpart_reader) + : reader_(reader), muitlpart_reader_(muitlpart_reader) {} + + bool operator()(MultipartContentHeader header, + ContentReceiver receiver) const { + return muitlpart_reader_(header, receiver); + } + + bool operator()(ContentReceiver receiver) const { return reader_(receiver); } + + Reader reader_; + MultipartReader muitlpart_reader_; +}; + +using Range = std::pair; +using Ranges = std::vector; + +struct Request { + std::string method; + std::string path; + Headers headers; + std::string body; + + std::string remote_addr; + int remote_port = -1; + + // for server + std::string version; + std::string target; + Params params; + MultipartFormDataMap files; + Ranges ranges; + Match matches; + + // for client + size_t redirect_count = CPPHTTPLIB_REDIRECT_MAX_COUNT; + ResponseHandler response_handler; + ContentReceiver content_receiver; + Progress progress; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + const SSL *ssl; +#endif + + bool has_header(const char *key) const; + std::string get_header_value(const char *key, size_t id = 0) const; + size_t get_header_value_count(const char *key) const; + void set_header(const char *key, const char *val); + void set_header(const char *key, const std::string &val); + + bool has_param(const char *key) const; + std::string get_param_value(const char *key, size_t id = 0) const; + size_t get_param_value_count(const char *key) const; + + bool is_multipart_form_data() const; + + bool has_file(const char *key) const; + MultipartFormData get_file_value(const char *key) const; + + // private members... + size_t content_length; + ContentProvider content_provider; +}; + +struct Response { + std::string version; + int status = -1; + Headers headers; + std::string body; + + bool has_header(const char *key) const; + std::string get_header_value(const char *key, size_t id = 0) const; + size_t get_header_value_count(const char *key) const; + void set_header(const char *key, const char *val); + void set_header(const char *key, const std::string &val); + + void set_redirect(const char *url, int status = 302); + void set_content(const char *s, size_t n, const char *content_type); + void set_content(std::string s, const char *content_type); + + void set_content_provider( + size_t length, + std::function + provider, + std::function resource_releaser = [] {}); + + void set_chunked_content_provider( + std::function provider, + std::function resource_releaser = [] {}); + + Response() = default; + Response(const Response &) = default; + Response &operator=(const Response &) = default; + Response(Response &&) = default; + Response &operator=(Response &&) = default; + ~Response() { + if (content_provider_resource_releaser) { + content_provider_resource_releaser(); + } + } + + // private members... + size_t content_length = 0; + ContentProvider content_provider; + std::function content_provider_resource_releaser; +}; + +class Stream { +public: + virtual ~Stream() = default; + + virtual bool is_readable() const = 0; + virtual bool is_writable() const = 0; + + virtual ssize_t read(char *ptr, size_t size) = 0; + virtual ssize_t write(const char *ptr, size_t size) = 0; + virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0; + + template + ssize_t write_format(const char *fmt, const Args &... args); + ssize_t write(const char *ptr); + ssize_t write(const std::string &s); +}; + +class TaskQueue { +public: + TaskQueue() = default; + virtual ~TaskQueue() = default; + + virtual void enqueue(std::function fn) = 0; + virtual void shutdown() = 0; + + virtual void on_idle(){}; +}; + +class ThreadPool : public TaskQueue { +public: + explicit ThreadPool(size_t n) : shutdown_(false) { + while (n) { + threads_.emplace_back(worker(*this)); + n--; + } + } + + ThreadPool(const ThreadPool &) = delete; + ~ThreadPool() override = default; + + void enqueue(std::function fn) override { + std::unique_lock lock(mutex_); + jobs_.push_back(fn); + cond_.notify_one(); + } + + void shutdown() override { + // Stop all worker threads... + { + std::unique_lock lock(mutex_); + shutdown_ = true; + } + + cond_.notify_all(); + + // Join... + for (auto &t : threads_) { + t.join(); + } + } + +private: + struct worker { + explicit worker(ThreadPool &pool) : pool_(pool) {} + + void operator()() { + for (;;) { + std::function fn; + { + std::unique_lock lock(pool_.mutex_); + + pool_.cond_.wait( + lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; }); + + if (pool_.shutdown_ && pool_.jobs_.empty()) { break; } + + fn = pool_.jobs_.front(); + pool_.jobs_.pop_front(); + } + + assert(true == static_cast(fn)); + fn(); + } + } + + ThreadPool &pool_; + }; + friend struct worker; + + std::vector threads_; + std::list> jobs_; + + bool shutdown_; + + std::condition_variable cond_; + std::mutex mutex_; +}; + +using Logger = std::function; + +class Server { +public: + using Handler = std::function; + using HandlerWithContentReader = std::function; + using Expect100ContinueHandler = + std::function; + + Server(); + + virtual ~Server(); + + virtual bool is_valid() const; + + Server &Get(const char *pattern, Handler handler); + Server &Post(const char *pattern, Handler handler); + Server &Post(const char *pattern, HandlerWithContentReader handler); + Server &Put(const char *pattern, Handler handler); + Server &Put(const char *pattern, HandlerWithContentReader handler); + Server &Patch(const char *pattern, Handler handler); + Server &Patch(const char *pattern, HandlerWithContentReader handler); + Server &Delete(const char *pattern, Handler handler); + Server &Delete(const char *pattern, HandlerWithContentReader handler); + Server &Options(const char *pattern, Handler handler); + + [[deprecated]] bool set_base_dir(const char *dir, + const char *mount_point = nullptr); + bool set_mount_point(const char *mount_point, const char *dir); + bool remove_mount_point(const char *mount_point); + void set_file_extension_and_mimetype_mapping(const char *ext, + const char *mime); + void set_file_request_handler(Handler handler); + + void set_error_handler(Handler handler); + void set_logger(Logger logger); + + void set_expect_100_continue_handler(Expect100ContinueHandler handler); + + void set_keep_alive_max_count(size_t count); + void set_read_timeout(time_t sec, time_t usec); + void set_payload_max_length(size_t length); + + bool bind_to_port(const char *host, int port, int socket_flags = 0); + int bind_to_any_port(const char *host, int socket_flags = 0); + bool listen_after_bind(); + + bool listen(const char *host, int port, int socket_flags = 0); + + bool is_running() const; + void stop(); + + std::function new_task_queue; + +protected: + bool process_request(Stream &strm, bool last_connection, + bool &connection_close, + const std::function &setup_request); + + size_t keep_alive_max_count_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; + size_t payload_max_length_; + +private: + using Handlers = std::vector>; + using HandlersForContentReader = + std::vector>; + + socket_t create_server_socket(const char *host, int port, + int socket_flags) const; + int bind_internal(const char *host, int port, int socket_flags); + bool listen_internal(); + + bool routing(Request &req, Response &res, Stream &strm); + bool handle_file_request(Request &req, Response &res, bool head = false); + bool dispatch_request(Request &req, Response &res, Handlers &handlers); + bool dispatch_request_for_content_reader(Request &req, Response &res, + ContentReader content_reader, + HandlersForContentReader &handlers); + + bool parse_request_line(const char *s, Request &req); + bool write_response(Stream &strm, bool last_connection, const Request &req, + Response &res); + bool write_content_with_provider(Stream &strm, const Request &req, + Response &res, const std::string &boundary, + const std::string &content_type); + bool read_content(Stream &strm, Request &req, Response &res); + bool + read_content_with_content_receiver(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver); + bool read_content_core(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader mulitpart_header, + ContentReceiver multipart_receiver); + + virtual bool process_and_close_socket(socket_t sock); + + std::atomic is_running_; + std::atomic svr_sock_; + std::vector> base_dirs_; + std::map file_extension_and_mimetype_map_; + Handler file_request_handler_; + Handlers get_handlers_; + Handlers post_handlers_; + HandlersForContentReader post_handlers_for_content_reader_; + Handlers put_handlers_; + HandlersForContentReader put_handlers_for_content_reader_; + Handlers patch_handlers_; + HandlersForContentReader patch_handlers_for_content_reader_; + Handlers delete_handlers_; + HandlersForContentReader delete_handlers_for_content_reader_; + Handlers options_handlers_; + Handler error_handler_; + Logger logger_; + Expect100ContinueHandler expect_100_continue_handler_; +}; + +class Client { +public: + explicit Client(const std::string &host, int port = 80, + const std::string &client_cert_path = std::string(), + const std::string &client_key_path = std::string()); + + virtual ~Client(); + + virtual bool is_valid() const; + + std::shared_ptr Get(const char *path); + + std::shared_ptr Get(const char *path, const Headers &headers); + + std::shared_ptr Get(const char *path, Progress progress); + + std::shared_ptr Get(const char *path, const Headers &headers, + Progress progress); + + std::shared_ptr Get(const char *path, + ContentReceiver content_receiver); + + std::shared_ptr Get(const char *path, const Headers &headers, + ContentReceiver content_receiver); + + std::shared_ptr + Get(const char *path, ContentReceiver content_receiver, Progress progress); + + std::shared_ptr Get(const char *path, const Headers &headers, + ContentReceiver content_receiver, + Progress progress); + + std::shared_ptr Get(const char *path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver); + + std::shared_ptr Get(const char *path, const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress); + + std::shared_ptr Head(const char *path); + + std::shared_ptr Head(const char *path, const Headers &headers); + + std::shared_ptr Post(const char *path); + + std::shared_ptr Post(const char *path, const std::string &body, + const char *content_type); + + std::shared_ptr Post(const char *path, const Headers &headers, + const std::string &body, + const char *content_type); + + std::shared_ptr Post(const char *path, size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Post(const char *path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Post(const char *path, const Params ¶ms); + + std::shared_ptr Post(const char *path, const Headers &headers, + const Params ¶ms); + + std::shared_ptr Post(const char *path, + const MultipartFormDataItems &items); + + std::shared_ptr Post(const char *path, const Headers &headers, + const MultipartFormDataItems &items); + + std::shared_ptr Put(const char *path); + + std::shared_ptr Put(const char *path, const std::string &body, + const char *content_type); + + std::shared_ptr Put(const char *path, const Headers &headers, + const std::string &body, + const char *content_type); + + std::shared_ptr Put(const char *path, size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Put(const char *path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Put(const char *path, const Params ¶ms); + + std::shared_ptr Put(const char *path, const Headers &headers, + const Params ¶ms); + + std::shared_ptr Patch(const char *path, const std::string &body, + const char *content_type); + + std::shared_ptr Patch(const char *path, const Headers &headers, + const std::string &body, + const char *content_type); + + std::shared_ptr Patch(const char *path, size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Patch(const char *path, const Headers &headers, + size_t content_length, + ContentProvider content_provider, + const char *content_type); + + std::shared_ptr Delete(const char *path); + + std::shared_ptr Delete(const char *path, const std::string &body, + const char *content_type); + + std::shared_ptr Delete(const char *path, const Headers &headers); + + std::shared_ptr Delete(const char *path, const Headers &headers, + const std::string &body, + const char *content_type); + + std::shared_ptr Options(const char *path); + + std::shared_ptr Options(const char *path, const Headers &headers); + + bool send(const Request &req, Response &res); + + bool send(const std::vector &requests, + std::vector &responses); + + void stop(); + + void set_timeout_sec(time_t timeout_sec); + + void set_read_timeout(time_t sec, time_t usec); + + void set_keep_alive_max_count(size_t count); + + void set_basic_auth(const char *username, const char *password); + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_digest_auth(const char *username, const char *password); +#endif + + void set_follow_location(bool on); + + void set_compress(bool on); + + void set_interface(const char *intf); + + void set_proxy(const char *host, int port); + + void set_proxy_basic_auth(const char *username, const char *password); + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + void set_proxy_digest_auth(const char *username, const char *password); +#endif + + void set_logger(Logger logger); + +protected: + bool process_request(Stream &strm, const Request &req, Response &res, + bool last_connection, bool &connection_close); + + std::atomic sock_; + + const std::string host_; + const int port_; + const std::string host_and_port_; + + // Settings + std::string client_cert_path_; + std::string client_key_path_; + + time_t timeout_sec_ = 300; + time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND; + time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND; + + size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT; + + std::string basic_auth_username_; + std::string basic_auth_password_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string digest_auth_username_; + std::string digest_auth_password_; +#endif + + bool follow_location_ = false; + + bool compress_ = false; + + std::string interface_; + + std::string proxy_host_; + int proxy_port_; + + std::string proxy_basic_auth_username_; + std::string proxy_basic_auth_password_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + std::string proxy_digest_auth_username_; + std::string proxy_digest_auth_password_; +#endif + + Logger logger_; + + void copy_settings(const Client &rhs) { + client_cert_path_ = rhs.client_cert_path_; + client_key_path_ = rhs.client_key_path_; + timeout_sec_ = rhs.timeout_sec_; + read_timeout_sec_ = rhs.read_timeout_sec_; + read_timeout_usec_ = rhs.read_timeout_usec_; + keep_alive_max_count_ = rhs.keep_alive_max_count_; + basic_auth_username_ = rhs.basic_auth_username_; + basic_auth_password_ = rhs.basic_auth_password_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + digest_auth_username_ = rhs.digest_auth_username_; + digest_auth_password_ = rhs.digest_auth_password_; +#endif + follow_location_ = rhs.follow_location_; + compress_ = rhs.compress_; + interface_ = rhs.interface_; + proxy_host_ = rhs.proxy_host_; + proxy_port_ = rhs.proxy_port_; + proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_; + proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_; +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_; + proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_; +#endif + logger_ = rhs.logger_; + } + +private: + socket_t create_client_socket() const; + bool read_response_line(Stream &strm, Response &res); + bool write_request(Stream &strm, const Request &req, bool last_connection); + bool redirect(const Request &req, Response &res); + bool handle_request(Stream &strm, const Request &req, Response &res, + bool last_connection, bool &connection_close); +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + bool connect(socket_t sock, Response &res, bool &error); +#endif + + std::shared_ptr send_with_content_provider( + const char *method, const char *path, const Headers &headers, + const std::string &body, size_t content_length, + ContentProvider content_provider, const char *content_type); + + virtual bool process_and_close_socket( + socket_t sock, size_t request_count, + std::function + callback); + + virtual bool is_ssl() const; +}; + +inline void Get(std::vector &requests, const char *path, + const Headers &headers) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + requests.emplace_back(std::move(req)); +} + +inline void Get(std::vector &requests, const char *path) { + Get(requests, path, Headers()); +} + +inline void Post(std::vector &requests, const char *path, + const Headers &headers, const std::string &body, + const char *content_type) { + Request req; + req.method = "POST"; + req.path = path; + req.headers = headers; + if (content_type) { req.headers.emplace("Content-Type", content_type); } + req.body = body; + requests.emplace_back(std::move(req)); +} + +inline void Post(std::vector &requests, const char *path, + const std::string &body, const char *content_type) { + Post(requests, path, Headers(), body, content_type); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +class SSLServer : public Server { +public: + SSLServer(const char *cert_path, const char *private_key_path, + const char *client_ca_cert_file_path = nullptr, + const char *client_ca_cert_dir_path = nullptr); + + SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store = nullptr); + + ~SSLServer() override; + + bool is_valid() const override; + +private: + bool process_and_close_socket(socket_t sock) override; + + SSL_CTX *ctx_; + std::mutex ctx_mutex_; +}; + +class SSLClient : public Client { +public: + explicit SSLClient(const std::string &host, int port = 443, + const std::string &client_cert_path = std::string(), + const std::string &client_key_path = std::string()); + + SSLClient(const std::string &host, int port, X509 *client_cert, + EVP_PKEY *client_key); + + ~SSLClient() override; + + bool is_valid() const override; + + void set_ca_cert_path(const char *ca_ceert_file_path, + const char *ca_cert_dir_path = nullptr); + + void set_ca_cert_store(X509_STORE *ca_cert_store); + + void enable_server_certificate_verification(bool enabled); + + long get_openssl_verify_result() const; + + SSL_CTX *ssl_context() const; + +private: + bool process_and_close_socket( + socket_t sock, size_t request_count, + std::function + callback) override; + bool is_ssl() const override; + + bool verify_host(X509 *server_cert) const; + bool verify_host_with_subject_alt_name(X509 *server_cert) const; + bool verify_host_with_common_name(X509 *server_cert) const; + bool check_host_name(const char *pattern, size_t pattern_len) const; + + SSL_CTX *ctx_; + std::mutex ctx_mutex_; + std::vector host_components_; + + std::string ca_cert_file_path_; + std::string ca_cert_dir_path_; + X509_STORE *ca_cert_store_ = nullptr; + bool server_certificate_verification_ = false; + long verify_result_ = 0; +}; +#endif + +// ---------------------------------------------------------------------------- + +/* + * Implementation + */ + +namespace detail { + +inline bool is_hex(char c, int &v) { + if (0x20 <= c && isdigit(c)) { + v = c - '0'; + return true; + } else if ('A' <= c && c <= 'F') { + v = c - 'A' + 10; + return true; + } else if ('a' <= c && c <= 'f') { + v = c - 'a' + 10; + return true; + } + return false; +} + +inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt, + int &val) { + if (i >= s.size()) { return false; } + + val = 0; + for (; cnt; i++, cnt--) { + if (!s[i]) { return false; } + int v = 0; + if (is_hex(s[i], v)) { + val = val * 16 + v; + } else { + return false; + } + } + return true; +} + +inline std::string from_i_to_hex(size_t n) { + const char *charset = "0123456789abcdef"; + std::string ret; + do { + ret = charset[n & 15] + ret; + n >>= 4; + } while (n > 0); + return ret; +} + +inline size_t to_utf8(int code, char *buff) { + if (code < 0x0080) { + buff[0] = (code & 0x7F); + return 1; + } else if (code < 0x0800) { + buff[0] = static_cast(0xC0 | ((code >> 6) & 0x1F)); + buff[1] = static_cast(0x80 | (code & 0x3F)); + return 2; + } else if (code < 0xD800) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0xE000) { // D800 - DFFF is invalid... + return 0; + } else if (code < 0x10000) { + buff[0] = static_cast(0xE0 | ((code >> 12) & 0xF)); + buff[1] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[2] = static_cast(0x80 | (code & 0x3F)); + return 3; + } else if (code < 0x110000) { + buff[0] = static_cast(0xF0 | ((code >> 18) & 0x7)); + buff[1] = static_cast(0x80 | ((code >> 12) & 0x3F)); + buff[2] = static_cast(0x80 | ((code >> 6) & 0x3F)); + buff[3] = static_cast(0x80 | (code & 0x3F)); + return 4; + } + + // NOTREACHED + return 0; +} + +// NOTE: This code came up with the following stackoverflow post: +// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c +inline std::string base64_encode(const std::string &in) { + static const auto lookup = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + std::string out; + out.reserve(in.size()); + + int val = 0; + int valb = -6; + + for (auto c : in) { + val = (val << 8) + static_cast(c); + valb += 8; + while (valb >= 0) { + out.push_back(lookup[(val >> valb) & 0x3F]); + valb -= 6; + } + } + + if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); } + + while (out.size() % 4) { + out.push_back('='); + } + + return out; +} + +inline bool is_file(const std::string &path) { + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode); +} + +inline bool is_dir(const std::string &path) { + struct stat st; + return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode); +} + +inline bool is_valid_path(const std::string &path) { + size_t level = 0; + size_t i = 0; + + // Skip slash + while (i < path.size() && path[i] == '/') { + i++; + } + + while (i < path.size()) { + // Read component + auto beg = i; + while (i < path.size() && path[i] != '/') { + i++; + } + + auto len = i - beg; + assert(len > 0); + + if (!path.compare(beg, len, ".")) { + ; + } else if (!path.compare(beg, len, "..")) { + if (level == 0) { return false; } + level--; + } else { + level++; + } + + // Skip slash + while (i < path.size() && path[i] == '/') { + i++; + } + } + + return true; +} + +inline void read_file(const std::string &path, std::string &out) { + std::ifstream fs(path, std::ios_base::binary); + fs.seekg(0, std::ios_base::end); + auto size = fs.tellg(); + fs.seekg(0); + out.resize(static_cast(size)); + fs.read(&out[0], size); +} + +inline std::string file_extension(const std::string &path) { + std::smatch m; + static auto re = std::regex("\\.([a-zA-Z0-9]+)$"); + if (std::regex_search(path, m, re)) { return m[1].str(); } + return std::string(); +} + +template void split(const char *b, const char *e, char d, Fn fn) { + int i = 0; + int beg = 0; + + while (e ? (b + i != e) : (b[i] != '\0')) { + if (b[i] == d) { + fn(&b[beg], &b[i]); + beg = i + 1; + } + i++; + } + + if (i) { fn(&b[beg], &b[i]); } +} + +// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer` +// to store data. The call can set memory on stack for performance. +class stream_line_reader { +public: + stream_line_reader(Stream &strm, char *fixed_buffer, size_t fixed_buffer_size) + : strm_(strm), fixed_buffer_(fixed_buffer), + fixed_buffer_size_(fixed_buffer_size) {} + + const char *ptr() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_; + } else { + return glowable_buffer_.data(); + } + } + + size_t size() const { + if (glowable_buffer_.empty()) { + return fixed_buffer_used_size_; + } else { + return glowable_buffer_.size(); + } + } + + bool end_with_crlf() const { + auto end = ptr() + size(); + return size() >= 2 && end[-2] == '\r' && end[-1] == '\n'; + } + + bool getline() { + fixed_buffer_used_size_ = 0; + glowable_buffer_.clear(); + + for (size_t i = 0;; i++) { + char byte; + auto n = strm_.read(&byte, 1); + + if (n < 0) { + return false; + } else if (n == 0) { + if (i == 0) { + return false; + } else { + break; + } + } + + append(byte); + + if (byte == '\n') { break; } + } + + return true; + } + +private: + void append(char c) { + if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) { + fixed_buffer_[fixed_buffer_used_size_++] = c; + fixed_buffer_[fixed_buffer_used_size_] = '\0'; + } else { + if (glowable_buffer_.empty()) { + assert(fixed_buffer_[fixed_buffer_used_size_] == '\0'); + glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_); + } + glowable_buffer_ += c; + } + } + + Stream &strm_; + char *fixed_buffer_; + const size_t fixed_buffer_size_; + size_t fixed_buffer_used_size_ = 0; + std::string glowable_buffer_; +}; + +inline int close_socket(socket_t sock) { +#ifdef _WIN32 + return closesocket(sock); +#else + return close(sock); +#endif +} + +template +inline ssize_t handle_EINTR(T fn) { + ssize_t res = false; + while (true) { + res = fn(); + if (res < 0 && errno == EINTR) { + continue; + } + break; + } + return res; +} + +#define HANDLE_EINTR(method, ...) (handle_EINTR([&]() { return method(__VA_ARGS__); })) + +inline ssize_t select_read(socket_t sock, time_t sec, time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLIN; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + return HANDLE_EINTR(poll, &pfd_read, 1, timeout); +#else + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return HANDLE_EINTR(select, static_cast(sock + 1), &fds, nullptr, nullptr, &tv); +#endif +} + +inline ssize_t select_write(socket_t sock, time_t sec, time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLOUT; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + return HANDLE_EINTR(poll, &pfd_read, 1, timeout); +#else + fd_set fds; + FD_ZERO(&fds); + FD_SET(sock, &fds); + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + return HANDLE_EINTR(select, static_cast(sock + 1), nullptr, &fds, nullptr, &tv); +#endif +} + +inline bool wait_until_socket_is_ready(socket_t sock, time_t sec, time_t usec) { +#ifdef CPPHTTPLIB_USE_POLL + struct pollfd pfd_read; + pfd_read.fd = sock; + pfd_read.events = POLLIN | POLLOUT; + + auto timeout = static_cast(sec * 1000 + usec / 1000); + + auto poll_res = HANDLE_EINTR(poll, &pfd_read, 1, timeout); + if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) { + int error = 0; + socklen_t len = sizeof(error); + auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len); + return res >= 0 && !error; + } + return false; +#else + fd_set fdsr; + FD_ZERO(&fdsr); + FD_SET(sock, &fdsr); + + auto fdsw = fdsr; + auto fdse = fdsr; + + timeval tv; + tv.tv_sec = static_cast(sec); + tv.tv_usec = static_cast(usec); + + if (HANDLE_EINTR(select, static_cast(sock + 1), &fdsr, &fdsw, &fdse, &tv) > 0 && + (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) { + int error = 0; + socklen_t len = sizeof(error); + return getsockopt(sock, SOL_SOCKET, SO_ERROR, + reinterpret_cast(&error), &len) >= 0 && + !error; + } + return false; +#endif +} + +class SocketStream : public Stream { +public: + SocketStream(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec); + ~SocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + +private: + socket_t sock_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; +}; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +class SSLSocketStream : public Stream { +public: + SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec, + time_t read_timeout_usec); + ~SSLSocketStream() override; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + +private: + socket_t sock_; + SSL *ssl_; + time_t read_timeout_sec_; + time_t read_timeout_usec_; +}; +#endif + +class BufferStream : public Stream { +public: + BufferStream() = default; + ~BufferStream() override = default; + + bool is_readable() const override; + bool is_writable() const override; + ssize_t read(char *ptr, size_t size) override; + ssize_t write(const char *ptr, size_t size) override; + void get_remote_ip_and_port(std::string &ip, int &port) const override; + + const std::string &get_buffer() const; + +private: + std::string buffer; + size_t position = 0; +}; + +template +inline bool process_socket(bool is_client_request, socket_t sock, + size_t keep_alive_max_count, time_t read_timeout_sec, + time_t read_timeout_usec, T callback) { + assert(keep_alive_max_count > 0); + + auto ret = false; + + if (keep_alive_max_count > 1) { + auto count = keep_alive_max_count; + while (count > 0 && + (is_client_request || + select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND, + CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0)) { + SocketStream strm(sock, read_timeout_sec, read_timeout_usec); + auto last_connection = count == 1; + auto connection_close = false; + + ret = callback(strm, last_connection, connection_close); + if (!ret || connection_close) { break; } + + count--; + } + } else { // keep_alive_max_count is 0 or 1 + SocketStream strm(sock, read_timeout_sec, read_timeout_usec); + auto dummy_connection_close = false; + ret = callback(strm, true, dummy_connection_close); + } + + return ret; +} + +template +inline bool process_and_close_socket(bool is_client_request, socket_t sock, + size_t keep_alive_max_count, + time_t read_timeout_sec, + time_t read_timeout_usec, T callback) { + auto ret = process_socket(is_client_request, sock, keep_alive_max_count, + read_timeout_sec, read_timeout_usec, callback); + close_socket(sock); + return ret; +} + +inline int shutdown_socket(socket_t sock) { +#ifdef _WIN32 + return shutdown(sock, SD_BOTH); +#else + return shutdown(sock, SHUT_RDWR); +#endif +} + +template +socket_t create_socket(const char *host, int port, Fn fn, + int socket_flags = 0) { +#ifdef _WIN32 +#define SO_SYNCHRONOUS_NONALERT 0x20 +#define SO_OPENTYPE 0x7008 + + int opt = SO_SYNCHRONOUS_NONALERT; + setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&opt, + sizeof(opt)); +#endif + + // Get address info + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = socket_flags; + hints.ai_protocol = 0; + + auto service = std::to_string(port); + + if (getaddrinfo(host, service.c_str(), &hints, &result)) { + return INVALID_SOCKET; + } + + for (auto rp = result; rp; rp = rp->ai_next) { + // Create a socket +#ifdef _WIN32 + auto sock = WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, + nullptr, 0, WSA_FLAG_NO_HANDLE_INHERIT); + /** + * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1 + * and above the socket creation fails on older Windows Systems. + * + * Let's try to create a socket the old way in this case. + * + * Reference: + * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa + * + * WSA_FLAG_NO_HANDLE_INHERIT: + * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with + * SP1, and later + * + */ + if (sock == INVALID_SOCKET) { + sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + } +#else + auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); +#endif + if (sock == INVALID_SOCKET) { continue; } + +#ifndef _WIN32 + if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) { continue; } +#endif + + // Make 'reuse address' option available + int yes = 1; + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast(&yes), + sizeof(yes)); +#ifdef SO_REUSEPORT + setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, reinterpret_cast(&yes), + sizeof(yes)); +#endif + + // bind or connect + if (fn(sock, *rp)) { + freeaddrinfo(result); + return sock; + } + + close_socket(sock); + } + + freeaddrinfo(result); + return INVALID_SOCKET; +} + +inline void set_nonblocking(socket_t sock, bool nonblocking) { +#ifdef _WIN32 + auto flags = nonblocking ? 1UL : 0UL; + ioctlsocket(sock, FIONBIO, &flags); +#else + auto flags = fcntl(sock, F_GETFL, 0); + fcntl(sock, F_SETFL, + nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK))); +#endif +} + +inline bool is_connection_error() { +#ifdef _WIN32 + return WSAGetLastError() != WSAEWOULDBLOCK; +#else + return errno != EINPROGRESS; +#endif +} + +inline bool bind_ip_address(socket_t sock, const char *host) { + struct addrinfo hints; + struct addrinfo *result; + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = 0; + + if (getaddrinfo(host, "0", &hints, &result)) { return false; } + + auto ret = false; + for (auto rp = result; rp; rp = rp->ai_next) { + const auto &ai = *rp; + if (!::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen))) { + ret = true; + break; + } + } + + freeaddrinfo(result); + return ret; +} + +#ifndef _WIN32 +inline std::string if2ip(const std::string &ifn) { + struct ifaddrs *ifap; + getifaddrs(&ifap); + for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) { + if (ifa->ifa_addr && ifn == ifa->ifa_name) { + if (ifa->ifa_addr->sa_family == AF_INET) { + auto sa = reinterpret_cast(ifa->ifa_addr); + char buf[INET_ADDRSTRLEN]; + if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) { + freeifaddrs(ifap); + return std::string(buf, INET_ADDRSTRLEN); + } + } + } + } + freeifaddrs(ifap); + return std::string(); +} +#endif + +inline socket_t create_client_socket(const char *host, int port, + time_t timeout_sec, + const std::string &intf) { + return create_socket( + host, port, [&](socket_t sock, struct addrinfo &ai) -> bool { + if (!intf.empty()) { +#ifndef _WIN32 + auto ip = if2ip(intf); + if (ip.empty()) { ip = intf; } + if (!bind_ip_address(sock, ip.c_str())) { return false; } +#endif + } + + set_nonblocking(sock, true); + + auto ret = + ::connect(sock, ai.ai_addr, static_cast(ai.ai_addrlen)); + if (ret < 0) { + if (is_connection_error() || + !wait_until_socket_is_ready(sock, timeout_sec, 0)) { + close_socket(sock); + return false; + } + } + + set_nonblocking(sock, false); + return true; + }); +} + +inline void get_remote_ip_and_port(const struct sockaddr_storage &addr, + socklen_t addr_len, std::string &ip, + int &port) { + if (addr.ss_family == AF_INET) { + port = ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + port = + ntohs(reinterpret_cast(&addr)->sin6_port); + } + + std::array ipstr{}; + if (!getnameinfo(reinterpret_cast(&addr), addr_len, + ipstr.data(), static_cast(ipstr.size()), nullptr, + 0, NI_NUMERICHOST)) { + ip = ipstr.data(); + } +} + +inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + + if (!getpeername(sock, reinterpret_cast(&addr), + &addr_len)) { + get_remote_ip_and_port(addr, addr_len, ip, port); + } +} + +inline const char * +find_content_type(const std::string &path, + const std::map &user_data) { + auto ext = file_extension(path); + + auto it = user_data.find(ext); + if (it != user_data.end()) { return it->second.c_str(); } + + if (ext == "txt") { + return "text/plain"; + } else if (ext == "html" || ext == "htm") { + return "text/html"; + } else if (ext == "css") { + return "text/css"; + } else if (ext == "jpeg" || ext == "jpg") { + return "image/jpg"; + } else if (ext == "png") { + return "image/png"; + } else if (ext == "gif") { + return "image/gif"; + } else if (ext == "svg") { + return "image/svg+xml"; + } else if (ext == "ico") { + return "image/x-icon"; + } else if (ext == "json") { + return "application/json"; + } else if (ext == "pdf") { + return "application/pdf"; + } else if (ext == "js") { + return "application/javascript"; + } else if (ext == "wasm") { + return "application/wasm"; + } else if (ext == "xml") { + return "application/xml"; + } else if (ext == "xhtml") { + return "application/xhtml+xml"; + } + return nullptr; +} + +inline const char *status_message(int status) { + switch (status) { + case 100: return "Continue"; + case 101: return "Switching Protocol"; + case 102: return "Processing"; + case 103: return "Early Hints"; + case 200: return "OK"; + case 201: return "Created"; + case 202: return "Accepted"; + case 203: return "Non-Authoritative Information"; + case 204: return "No Content"; + case 205: return "Reset Content"; + case 206: return "Partial Content"; + case 207: return "Multi-Status"; + case 208: return "Already Reported"; + case 226: return "IM Used"; + case 300: return "Multiple Choice"; + case 301: return "Moved Permanently"; + case 302: return "Found"; + case 303: return "See Other"; + case 304: return "Not Modified"; + case 305: return "Use Proxy"; + case 306: return "unused"; + case 307: return "Temporary Redirect"; + case 308: return "Permanent Redirect"; + case 400: return "Bad Request"; + case 401: return "Unauthorized"; + case 402: return "Payment Required"; + case 403: return "Forbidden"; + case 404: return "Not Found"; + case 405: return "Method Not Allowed"; + case 406: return "Not Acceptable"; + case 407: return "Proxy Authentication Required"; + case 408: return "Request Timeout"; + case 409: return "Conflict"; + case 410: return "Gone"; + case 411: return "Length Required"; + case 412: return "Precondition Failed"; + case 413: return "Payload Too Large"; + case 414: return "URI Too Long"; + case 415: return "Unsupported Media Type"; + case 416: return "Range Not Satisfiable"; + case 417: return "Expectation Failed"; + case 418: return "I'm a teapot"; + case 421: return "Misdirected Request"; + case 422: return "Unprocessable Entity"; + case 423: return "Locked"; + case 424: return "Failed Dependency"; + case 425: return "Too Early"; + case 426: return "Upgrade Required"; + case 428: return "Precondition Required"; + case 429: return "Too Many Requests"; + case 431: return "Request Header Fields Too Large"; + case 451: return "Unavailable For Legal Reasons"; + case 501: return "Not Implemented"; + case 502: return "Bad Gateway"; + case 503: return "Service Unavailable"; + case 504: return "Gateway Timeout"; + case 505: return "HTTP Version Not Supported"; + case 506: return "Variant Also Negotiates"; + case 507: return "Insufficient Storage"; + case 508: return "Loop Detected"; + case 510: return "Not Extended"; + case 511: return "Network Authentication Required"; + + default: + case 500: return "Internal Server Error"; + } +} + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT +inline bool can_compress(const std::string &content_type) { + return !content_type.find("text/") || content_type == "image/svg+xml" || + content_type == "application/javascript" || + content_type == "application/json" || + content_type == "application/xml" || + content_type == "application/xhtml+xml"; +} + +inline bool compress(std::string &content) { + z_stream strm; + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + + auto ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, + Z_DEFAULT_STRATEGY); + if (ret != Z_OK) { return false; } + + strm.avail_in = static_cast(content.size()); + strm.next_in = + const_cast(reinterpret_cast(content.data())); + + std::string compressed; + + std::array buff{}; + do { + strm.avail_out = buff.size(); + strm.next_out = reinterpret_cast(buff.data()); + ret = deflate(&strm, Z_FINISH); + assert(ret != Z_STREAM_ERROR); + compressed.append(buff.data(), buff.size() - strm.avail_out); + } while (strm.avail_out == 0); + + assert(ret == Z_STREAM_END); + assert(strm.avail_in == 0); + + content.swap(compressed); + + deflateEnd(&strm); + return true; +} + +class decompressor { +public: + decompressor() { + std::memset(&strm, 0, sizeof(strm)); + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + + // 15 is the value of wbits, which should be at the maximum possible value + // to ensure that any gzip stream can be decoded. The offset of 32 specifies + // that the stream type should be automatically detected either gzip or + // deflate. + is_valid_ = inflateInit2(&strm, 32 + 15) == Z_OK; + } + + ~decompressor() { inflateEnd(&strm); } + + bool is_valid() const { return is_valid_; } + + template + bool decompress(const char *data, size_t data_length, T callback) { + int ret = Z_OK; + + strm.avail_in = static_cast(data_length); + strm.next_in = const_cast(reinterpret_cast(data)); + + std::array buff{}; + do { + strm.avail_out = buff.size(); + strm.next_out = reinterpret_cast(buff.data()); + + ret = inflate(&strm, Z_NO_FLUSH); + assert(ret != Z_STREAM_ERROR); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: inflateEnd(&strm); return false; + } + + if (!callback(buff.data(), buff.size() - strm.avail_out)) { + return false; + } + } while (strm.avail_out == 0); + + return ret == Z_OK || ret == Z_STREAM_END; + } + +private: + bool is_valid_; + z_stream strm; +}; +#endif + +inline bool has_header(const Headers &headers, const char *key) { + return headers.find(key) != headers.end(); +} + +inline const char *get_header_value(const Headers &headers, const char *key, + size_t id = 0, const char *def = nullptr) { + auto it = headers.find(key); + std::advance(it, static_cast(id)); + if (it != headers.end()) { return it->second.c_str(); } + return def; +} + +inline uint64_t get_header_value_uint64(const Headers &headers, const char *key, + uint64_t def = 0) { + auto it = headers.find(key); + if (it != headers.end()) { + return std::strtoull(it->second.data(), nullptr, 10); + } + return def; +} + +inline bool read_headers(Stream &strm, Headers &headers) { + const auto bufsiz = 2048; + char buf[bufsiz]; + stream_line_reader line_reader(strm, buf, bufsiz); + + for (;;) { + if (!line_reader.getline()) { return false; } + + // Check if the line ends with CRLF. + if (line_reader.end_with_crlf()) { + // Blank line indicates end of headers. + if (line_reader.size() == 2) { break; } + } else { + continue; // Skip invalid line. + } + + // Skip trailing spaces and tabs. + auto end = line_reader.ptr() + line_reader.size() - 2; + while (line_reader.ptr() < end && (end[-1] == ' ' || end[-1] == '\t')) { + end--; + } + + // Horizontal tab and ' ' are considered whitespace and are ignored when on + // the left or right side of the header value: + // - https://stackoverflow.com/questions/50179659/ + // - https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html + static const std::regex re(R"(([^:]+):[\t ]*([^\t ].*))"); + + std::cmatch m; + if (std::regex_match(line_reader.ptr(), end, m, re)) { + auto key = std::string(m[1]); + auto val = std::string(m[2]); + headers.emplace(key, val); + } + } + + return true; +} + +inline bool read_content_with_length(Stream &strm, uint64_t len, + Progress progress, ContentReceiver out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + + uint64_t r = 0; + while (r < len) { + auto read_len = static_cast(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return false; } + + if (!out(buf, static_cast(n))) { return false; } + + r += static_cast(n); + + if (progress) { + if (!progress(r, len)) { return false; } + } + } + + return true; +} + +inline void skip_content_with_length(Stream &strm, uint64_t len) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + uint64_t r = 0; + while (r < len) { + auto read_len = static_cast(len - r); + auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ)); + if (n <= 0) { return; } + r += static_cast(n); + } +} + +inline bool read_content_without_length(Stream &strm, ContentReceiver out) { + char buf[CPPHTTPLIB_RECV_BUFSIZ]; + for (;;) { + auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ); + if (n < 0) { + return false; + } else if (n == 0) { + return true; + } + if (!out(buf, static_cast(n))) { return false; } + } + + return true; +} + +inline bool read_content_chunked(Stream &strm, ContentReceiver out) { + const auto bufsiz = 16; + char buf[bufsiz]; + + stream_line_reader line_reader(strm, buf, bufsiz); + + if (!line_reader.getline()) { return false; } + + unsigned long chunk_len; + while (true) { + char *end_ptr; + + chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16); + + if (end_ptr == line_reader.ptr()) { return false; } + if (chunk_len == ULONG_MAX) { return false; } + + if (chunk_len == 0) { break; } + + if (!read_content_with_length(strm, chunk_len, nullptr, out)) { + return false; + } + + if (!line_reader.getline()) { return false; } + + if (strcmp(line_reader.ptr(), "\r\n")) { break; } + + if (!line_reader.getline()) { return false; } + } + + if (chunk_len == 0) { + // Reader terminator after chunks + if (!line_reader.getline() || strcmp(line_reader.ptr(), "\r\n")) + return false; + } + + return true; +} + +inline bool is_chunked_transfer_encoding(const Headers &headers) { + return !strcasecmp(get_header_value(headers, "Transfer-Encoding", 0, ""), + "chunked"); +} + +template +bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status, + Progress progress, ContentReceiver receiver) { + + ContentReceiver out = [&](const char *buf, size_t n) { + return receiver(buf, n); + }; + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + decompressor decompressor; + + std::string content_encoding = x.get_header_value("Content-Encoding"); + if (content_encoding.find("gzip") != std::string::npos || + content_encoding.find("deflate") != std::string::npos) { + if (!decompressor.is_valid()) { + status = 500; + return false; + } + + out = [&](const char *buf, size_t n) { + return decompressor.decompress( + buf, n, [&](const char *buf, size_t n) { return receiver(buf, n); }); + }; + } +#else + if (x.get_header_value("Content-Encoding") == "gzip") { + status = 415; + return false; + } +#endif + + auto ret = true; + auto exceed_payload_max_length = false; + + if (is_chunked_transfer_encoding(x.headers)) { + ret = read_content_chunked(strm, out); + } else if (!has_header(x.headers, "Content-Length")) { + ret = read_content_without_length(strm, out); + } else { + auto len = get_header_value_uint64(x.headers, "Content-Length", 0); + if (len > payload_max_length) { + exceed_payload_max_length = true; + skip_content_with_length(strm, len); + ret = false; + } else if (len > 0) { + ret = read_content_with_length(strm, len, progress, out); + } + } + + if (!ret) { status = exceed_payload_max_length ? 413 : 400; } + + return ret; +} + +template +inline ssize_t write_headers(Stream &strm, const T &info, + const Headers &headers) { + ssize_t write_len = 0; + for (const auto &x : info.headers) { + if (x.first == "EXCEPTION_WHAT") { continue; } + auto len = + strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str()); + if (len < 0) { return len; } + write_len += len; + } + for (const auto &x : headers) { + auto len = + strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str()); + if (len < 0) { return len; } + write_len += len; + } + auto len = strm.write("\r\n"); + if (len < 0) { return len; } + write_len += len; + return write_len; +} + +inline ssize_t write_content(Stream &strm, ContentProvider content_provider, + size_t offset, size_t length) { + size_t begin_offset = offset; + size_t end_offset = offset + length; + while (offset < end_offset) { + ssize_t written_length = 0; + + DataSink data_sink; + data_sink.write = [&](const char *d, size_t l) { + offset += l; + written_length = strm.write(d, l); + }; + data_sink.done = [&](void) { written_length = -1; }; + data_sink.is_writable = [&](void) { return strm.is_writable(); }; + + content_provider(offset, end_offset - offset, data_sink); + if (written_length < 0) { return written_length; } + } + return static_cast(offset - begin_offset); +} + +template +inline ssize_t write_content_chunked(Stream &strm, + ContentProvider content_provider, + T is_shutting_down) { + size_t offset = 0; + auto data_available = true; + ssize_t total_written_length = 0; + while (data_available && !is_shutting_down()) { + ssize_t written_length = 0; + + DataSink data_sink; + data_sink.write = [&](const char *d, size_t l) { + data_available = l > 0; + offset += l; + + // Emit chunked response header and footer for each chunk + auto chunk = from_i_to_hex(l) + "\r\n" + std::string(d, l) + "\r\n"; + written_length = strm.write(chunk); + }; + data_sink.done = [&](void) { + data_available = false; + written_length = strm.write("0\r\n\r\n"); + }; + data_sink.is_writable = [&](void) { return strm.is_writable(); }; + + content_provider(offset, 0, data_sink); + + if (written_length < 0) { return written_length; } + total_written_length += written_length; + } + return total_written_length; +} + +template +inline bool redirect(T &cli, const Request &req, Response &res, + const std::string &path) { + Request new_req = req; + new_req.path = path; + new_req.redirect_count -= 1; + + if (res.status == 303 && (req.method != "GET" && req.method != "HEAD")) { + new_req.method = "GET"; + new_req.body.clear(); + new_req.headers.clear(); + } + + Response new_res; + + auto ret = cli.send(new_req, new_res); + if (ret) { res = new_res; } + return ret; +} + +inline std::string encode_url(const std::string &s) { + std::string result; + + for (size_t i = 0; s[i]; i++) { + switch (s[i]) { + case ' ': result += "%20"; break; + case '+': result += "%2B"; break; + case '\r': result += "%0D"; break; + case '\n': result += "%0A"; break; + case '\'': result += "%27"; break; + case ',': result += "%2C"; break; + // case ':': result += "%3A"; break; // ok? probably... + case ';': result += "%3B"; break; + default: + auto c = static_cast(s[i]); + if (c >= 0x80) { + result += '%'; + char hex[4]; + auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c); + assert(len == 2); + result.append(hex, static_cast(len)); + } else { + result += s[i]; + } + break; + } + } + + return result; +} + +inline std::string decode_url(const std::string &s, + bool convert_plus_to_space) { + std::string result; + + for (size_t i = 0; i < s.size(); i++) { + if (s[i] == '%' && i + 1 < s.size()) { + if (s[i + 1] == 'u') { + int val = 0; + if (from_hex_to_i(s, i + 2, 4, val)) { + // 4 digits Unicode codes + char buff[4]; + size_t len = to_utf8(val, buff); + if (len > 0) { result.append(buff, len); } + i += 5; // 'u0000' + } else { + result += s[i]; + } + } else { + int val = 0; + if (from_hex_to_i(s, i + 1, 2, val)) { + // 2 digits hex codes + result += static_cast(val); + i += 2; // '00' + } else { + result += s[i]; + } + } + } else if (convert_plus_to_space && s[i] == '+') { + result += ' '; + } else { + result += s[i]; + } + } + + return result; +} + +inline std::string params_to_query_str(const Params ¶ms) { + std::string query; + + for (auto it = params.begin(); it != params.end(); ++it) { + if (it != params.begin()) { query += "&"; } + query += it->first; + query += "="; + query += detail::encode_url(it->second); + } + + return query; +} + +inline void parse_query_text(const std::string &s, Params ¶ms) { + split(&s[0], &s[s.size()], '&', [&](const char *b, const char *e) { + std::string key; + std::string val; + split(b, e, '=', [&](const char *b2, const char *e2) { + if (key.empty()) { + key.assign(b2, e2); + } else { + val.assign(b2, e2); + } + }); + params.emplace(decode_url(key, true), decode_url(val, true)); + }); +} + +inline bool parse_multipart_boundary(const std::string &content_type, + std::string &boundary) { + auto pos = content_type.find("boundary="); + if (pos == std::string::npos) { return false; } + + boundary = content_type.substr(pos + 9); + return true; +} + +inline bool parse_range_header(const std::string &s, Ranges &ranges) { + static auto re_first_range = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))"); + std::smatch m; + if (std::regex_match(s, m, re_first_range)) { + auto pos = static_cast(m.position(1)); + auto len = static_cast(m.length(1)); + bool all_valid_ranges = true; + split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) { + if (!all_valid_ranges) return; + static auto re_another_range = std::regex(R"(\s*(\d*)-(\d*))"); + std::cmatch cm; + if (std::regex_match(b, e, cm, re_another_range)) { + ssize_t first = -1; + if (!cm.str(1).empty()) { + first = static_cast(std::stoll(cm.str(1))); + } + + ssize_t last = -1; + if (!cm.str(2).empty()) { + last = static_cast(std::stoll(cm.str(2))); + } + + if (first != -1 && last != -1 && first > last) { + all_valid_ranges = false; + return; + } + ranges.emplace_back(std::make_pair(first, last)); + } + }); + return all_valid_ranges; + } + return false; +} + +class MultipartFormDataParser { +public: + MultipartFormDataParser() = default; + + void set_boundary(std::string boundary) { boundary_ = std::move(boundary); } + + bool is_valid() const { return is_valid_; } + + template + bool parse(const char *buf, size_t n, T content_callback, U header_callback) { + static const std::regex re_content_type(R"(^Content-Type:\s*(.*?)\s*$)", + std::regex_constants::icase); + + static const std::regex re_content_disposition( + "^Content-Disposition:\\s*form-data;\\s*name=\"(.*?)\"(?:;\\s*filename=" + "\"(.*?)\")?\\s*$", + std::regex_constants::icase); + static const std::string dash_ = "--"; + static const std::string crlf_ = "\r\n"; + + buf_.append(buf, n); // TODO: performance improvement + + while (!buf_.empty()) { + switch (state_) { + case 0: { // Initial boundary + auto pattern = dash_ + boundary_ + crlf_; + if (pattern.size() > buf_.size()) { return true; } + auto pos = buf_.find(pattern); + if (pos != 0) { + is_done_ = true; + return false; + } + buf_.erase(0, pattern.size()); + off_ += pattern.size(); + state_ = 1; + break; + } + case 1: { // New entry + clear_file_info(); + state_ = 2; + break; + } + case 2: { // Headers + auto pos = buf_.find(crlf_); + while (pos != std::string::npos) { + // Empty line + if (pos == 0) { + if (!header_callback(file_)) { + is_valid_ = false; + is_done_ = false; + return false; + } + buf_.erase(0, crlf_.size()); + off_ += crlf_.size(); + state_ = 3; + break; + } + + auto header = buf_.substr(0, pos); + { + std::smatch m; + if (std::regex_match(header, m, re_content_type)) { + file_.content_type = m[1]; + } else if (std::regex_match(header, m, re_content_disposition)) { + file_.name = m[1]; + file_.filename = m[2]; + } + } + + buf_.erase(0, pos + crlf_.size()); + off_ += pos + crlf_.size(); + pos = buf_.find(crlf_); + } + break; + } + case 3: { // Body + { + auto pattern = crlf_ + dash_; + if (pattern.size() > buf_.size()) { return true; } + + auto pos = buf_.find(pattern); + if (pos == std::string::npos) { pos = buf_.size(); } + if (!content_callback(buf_.data(), pos)) { + is_valid_ = false; + is_done_ = false; + return false; + } + + off_ += pos; + buf_.erase(0, pos); + } + + { + auto pattern = crlf_ + dash_ + boundary_; + if (pattern.size() > buf_.size()) { return true; } + + auto pos = buf_.find(pattern); + if (pos != std::string::npos) { + if (!content_callback(buf_.data(), pos)) { + is_valid_ = false; + is_done_ = false; + return false; + } + + off_ += pos + pattern.size(); + buf_.erase(0, pos + pattern.size()); + state_ = 4; + } else { + if (!content_callback(buf_.data(), pattern.size())) { + is_valid_ = false; + is_done_ = false; + return false; + } + + off_ += pattern.size(); + buf_.erase(0, pattern.size()); + } + } + break; + } + case 4: { // Boundary + if (crlf_.size() > buf_.size()) { return true; } + if (buf_.find(crlf_) == 0) { + buf_.erase(0, crlf_.size()); + off_ += crlf_.size(); + state_ = 1; + } else { + auto pattern = dash_ + crlf_; + if (pattern.size() > buf_.size()) { return true; } + if (buf_.find(pattern) == 0) { + buf_.erase(0, pattern.size()); + off_ += pattern.size(); + is_valid_ = true; + state_ = 5; + } else { + is_done_ = true; + return true; + } + } + break; + } + case 5: { // Done + is_valid_ = false; + return false; + } + } + } + + return true; + } + +private: + void clear_file_info() { + file_.name.clear(); + file_.filename.clear(); + file_.content_type.clear(); + } + + std::string boundary_; + + std::string buf_; + size_t state_ = 0; + size_t is_valid_ = false; + size_t is_done_ = false; + size_t off_ = 0; + MultipartFormData file_; +}; + +inline std::string to_lower(const char *beg, const char *end) { + std::string out; + auto it = beg; + while (it != end) { + out += static_cast(::tolower(*it)); + it++; + } + return out; +} + +inline std::string make_multipart_data_boundary() { + static const char data[] = + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + + std::random_device seed_gen; + std::mt19937 engine(seed_gen()); + + std::string result = "--cpp-httplib-multipart-data-"; + + for (auto i = 0; i < 16; i++) { + result += data[engine() % (sizeof(data) - 1)]; + } + + return result; +} + +inline std::pair +get_range_offset_and_length(const Request &req, size_t content_length, + size_t index) { + auto r = req.ranges[index]; + + if (r.first == -1 && r.second == -1) { + return std::make_pair(0, content_length); + } + + auto slen = static_cast(content_length); + + if (r.first == -1) { + r.first = slen - r.second; + r.second = slen - 1; + } + + if (r.second == -1) { r.second = slen - 1; } + + return std::make_pair(r.first, r.second - r.first + 1); +} + +inline std::string make_content_range_header_field(size_t offset, size_t length, + size_t content_length) { + std::string field = "bytes "; + field += std::to_string(offset); + field += "-"; + field += std::to_string(offset + length - 1); + field += "/"; + field += std::to_string(content_length); + return field; +} + +template +bool process_multipart_ranges_data(const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type, + SToken stoken, CToken ctoken, + Content content) { + for (size_t i = 0; i < req.ranges.size(); i++) { + ctoken("--"); + stoken(boundary); + ctoken("\r\n"); + if (!content_type.empty()) { + ctoken("Content-Type: "); + stoken(content_type); + ctoken("\r\n"); + } + + auto offsets = get_range_offset_and_length(req, res.body.size(), i); + auto offset = offsets.first; + auto length = offsets.second; + + ctoken("Content-Range: "); + stoken(make_content_range_header_field(offset, length, res.body.size())); + ctoken("\r\n"); + ctoken("\r\n"); + if (!content(offset, length)) { return false; } + ctoken("\r\n"); + } + + ctoken("--"); + stoken(boundary); + ctoken("--\r\n"); + + return true; +} + +inline std::string make_multipart_ranges_data(const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type) { + std::string data; + + process_multipart_ranges_data( + req, res, boundary, content_type, + [&](const std::string &token) { data += token; }, + [&](const char *token) { data += token; }, + [&](size_t offset, size_t length) { + data += res.body.substr(offset, length); + return true; + }); + + return data; +} + +inline size_t +get_multipart_ranges_data_length(const Request &req, Response &res, + const std::string &boundary, + const std::string &content_type) { + size_t data_length = 0; + + process_multipart_ranges_data( + req, res, boundary, content_type, + [&](const std::string &token) { data_length += token.size(); }, + [&](const char *token) { data_length += strlen(token); }, + [&](size_t /*offset*/, size_t length) { + data_length += length; + return true; + }); + + return data_length; +} + +inline bool write_multipart_ranges_data(Stream &strm, const Request &req, + Response &res, + const std::string &boundary, + const std::string &content_type) { + return process_multipart_ranges_data( + req, res, boundary, content_type, + [&](const std::string &token) { strm.write(token); }, + [&](const char *token) { strm.write(token); }, + [&](size_t offset, size_t length) { + return write_content(strm, res.content_provider, offset, length) >= 0; + }); +} + +inline std::pair +get_range_offset_and_length(const Request &req, const Response &res, + size_t index) { + auto r = req.ranges[index]; + + if (r.second == -1) { + r.second = static_cast(res.content_length) - 1; + } + + return std::make_pair(r.first, r.second - r.first + 1); +} + +inline bool expect_content(const Request &req) { + if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" || + req.method == "PRI" || req.method == "DELETE") { + return true; + } + // TODO: check if Content-Length is set + return false; +} + +inline bool has_crlf(const char *s) { + auto p = s; + while (*p) { + if (*p == '\r' || *p == '\n') { return true; } + p++; + } + return false; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +template +inline std::string message_digest(const std::string &s, Init init, + Update update, Final final, + size_t digest_length) { + using namespace std; + + std::vector md(digest_length, 0); + CTX ctx; + init(&ctx); + update(&ctx, s.data(), s.size()); + final(md.data(), &ctx); + + stringstream ss; + for (auto c : md) { + ss << setfill('0') << setw(2) << hex << (unsigned int)c; + } + return ss.str(); +} + +inline std::string MD5(const std::string &s) { + return message_digest(s, MD5_Init, MD5_Update, MD5_Final, + MD5_DIGEST_LENGTH); +} + +inline std::string SHA_256(const std::string &s) { + return message_digest(s, SHA256_Init, SHA256_Update, SHA256_Final, + SHA256_DIGEST_LENGTH); +} + +inline std::string SHA_512(const std::string &s) { + return message_digest(s, SHA512_Init, SHA512_Update, SHA512_Final, + SHA512_DIGEST_LENGTH); +} +#endif + +#ifdef _WIN32 +class WSInit { +public: + WSInit() { + WSADATA wsaData; + WSAStartup(0x0002, &wsaData); + } + + ~WSInit() { WSACleanup(); } +}; + +static WSInit wsinit_; +#endif + +} // namespace detail + +// Header utilities +inline std::pair make_range_header(Ranges ranges) { + std::string field = "bytes="; + auto i = 0; + for (auto r : ranges) { + if (i != 0) { field += ", "; } + if (r.first != -1) { field += std::to_string(r.first); } + field += '-'; + if (r.second != -1) { field += std::to_string(r.second); } + i++; + } + return std::make_pair("Range", field); +} + +inline std::pair +make_basic_authentication_header(const std::string &username, + const std::string &password, + bool is_proxy = false) { + auto field = "Basic " + detail::base64_encode(username + ":" + password); + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, field); +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline std::pair make_digest_authentication_header( + const Request &req, const std::map &auth, + size_t cnonce_count, const std::string &cnonce, const std::string &username, + const std::string &password, bool is_proxy = false) { + using namespace std; + + string nc; + { + stringstream ss; + ss << setfill('0') << setw(8) << hex << cnonce_count; + nc = ss.str(); + } + + auto qop = auth.at("qop"); + if (qop.find("auth-int") != std::string::npos) { + qop = "auth-int"; + } else { + qop = "auth"; + } + + std::string algo = "MD5"; + if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); } + + string response; + { + auto H = algo == "SHA-256" + ? detail::SHA_256 + : algo == "SHA-512" ? detail::SHA_512 : detail::MD5; + + auto A1 = username + ":" + auth.at("realm") + ":" + password; + + auto A2 = req.method + ":" + req.path; + if (qop == "auth-int") { A2 += ":" + H(req.body); } + + response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce + + ":" + qop + ":" + H(A2)); + } + + auto field = "Digest username=\"hello\", realm=\"" + auth.at("realm") + + "\", nonce=\"" + auth.at("nonce") + "\", uri=\"" + req.path + + "\", algorithm=" + algo + ", qop=" + qop + ", nc=\"" + nc + + "\", cnonce=\"" + cnonce + "\", response=\"" + response + "\""; + + auto key = is_proxy ? "Proxy-Authorization" : "Authorization"; + return std::make_pair(key, field); +} +#endif + +inline bool parse_www_authenticate(const httplib::Response &res, + std::map &auth, + bool is_proxy) { + auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate"; + if (res.has_header(auth_key)) { + static auto re = std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~"); + auto s = res.get_header_value(auth_key); + auto pos = s.find(' '); + if (pos != std::string::npos) { + auto type = s.substr(0, pos); + if (type == "Basic") { + return false; + } else if (type == "Digest") { + s = s.substr(pos + 1); + auto beg = std::sregex_iterator(s.begin(), s.end(), re); + for (auto i = beg; i != std::sregex_iterator(); ++i) { + auto m = *i; + auto key = s.substr(static_cast(m.position(1)), + static_cast(m.length(1))); + auto val = m.length(2) > 0 + ? s.substr(static_cast(m.position(2)), + static_cast(m.length(2))) + : s.substr(static_cast(m.position(3)), + static_cast(m.length(3))); + auth[key] = val; + } + return true; + } + } + } + return false; +} + +// https://stackoverflow.com/questions/440133/how-do-i-create-a-random-alpha-numeric-string-in-c/440240#answer-440240 +inline std::string random_string(size_t length) { + auto randchar = []() -> char { + const char charset[] = "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz"; + const size_t max_index = (sizeof(charset) - 1); + return charset[static_cast(rand()) % max_index]; + }; + std::string str(length, 0); + std::generate_n(str.begin(), length, randchar); + return str; +} + +// Request implementation +inline bool Request::has_header(const char *key) const { + return detail::has_header(headers, key); +} + +inline std::string Request::get_header_value(const char *key, size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Request::get_header_value_count(const char *key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Request::set_header(const char *key, const char *val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline void Request::set_header(const char *key, const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val.c_str())) { + headers.emplace(key, val); + } +} + +inline bool Request::has_param(const char *key) const { + return params.find(key) != params.end(); +} + +inline std::string Request::get_param_value(const char *key, size_t id) const { + auto it = params.find(key); + std::advance(it, static_cast(id)); + if (it != params.end()) { return it->second; } + return std::string(); +} + +inline size_t Request::get_param_value_count(const char *key) const { + auto r = params.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline bool Request::is_multipart_form_data() const { + const auto &content_type = get_header_value("Content-Type"); + return !content_type.find("multipart/form-data"); +} + +inline bool Request::has_file(const char *key) const { + return files.find(key) != files.end(); +} + +inline MultipartFormData Request::get_file_value(const char *key) const { + auto it = files.find(key); + if (it != files.end()) { return it->second; } + return MultipartFormData(); +} + +// Response implementation +inline bool Response::has_header(const char *key) const { + return headers.find(key) != headers.end(); +} + +inline std::string Response::get_header_value(const char *key, + size_t id) const { + return detail::get_header_value(headers, key, id, ""); +} + +inline size_t Response::get_header_value_count(const char *key) const { + auto r = headers.equal_range(key); + return static_cast(std::distance(r.first, r.second)); +} + +inline void Response::set_header(const char *key, const char *val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val)) { + headers.emplace(key, val); + } +} + +inline void Response::set_header(const char *key, const std::string &val) { + if (!detail::has_crlf(key) && !detail::has_crlf(val.c_str())) { + headers.emplace(key, val); + } +} + +inline void Response::set_redirect(const char *url, int stat) { + if (!detail::has_crlf(url)) { + set_header("Location", url); + if (300 <= stat && stat < 400) { + this->status = stat; + } else { + this->status = 302; + } + } +} + +inline void Response::set_content(const char *s, size_t n, + const char *content_type) { + body.assign(s, n); + set_header("Content-Type", content_type); +} + +inline void Response::set_content(std::string s, const char *content_type) { + body = std::move(s); + set_header("Content-Type", content_type); +} + +inline void Response::set_content_provider( + size_t in_length, + std::function provider, + std::function resource_releaser) { + assert(in_length > 0); + content_length = in_length; + content_provider = [provider](size_t offset, size_t length, DataSink &sink) { + provider(offset, length, sink); + }; + content_provider_resource_releaser = resource_releaser; +} + +inline void Response::set_chunked_content_provider( + std::function provider, + std::function resource_releaser) { + content_length = 0; + content_provider = [provider](size_t offset, size_t, DataSink &sink) { + provider(offset, sink); + }; + content_provider_resource_releaser = resource_releaser; +} + +// Rstream implementation +inline ssize_t Stream::write(const char *ptr) { + return write(ptr, strlen(ptr)); +} + +inline ssize_t Stream::write(const std::string &s) { + return write(s.data(), s.size()); +} + +template +inline ssize_t Stream::write_format(const char *fmt, const Args &... args) { + std::array buf; + +#if defined(_MSC_VER) && _MSC_VER < 1900 + auto sn = _snprintf_s(buf, bufsiz, buf.size() - 1, fmt, args...); +#else + auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...); +#endif + if (sn <= 0) { return sn; } + + auto n = static_cast(sn); + + if (n >= buf.size() - 1) { + std::vector glowable_buf(buf.size()); + + while (n >= glowable_buf.size() - 1) { + glowable_buf.resize(glowable_buf.size() * 2); +#if defined(_MSC_VER) && _MSC_VER < 1900 + n = static_cast(_snprintf_s(&glowable_buf[0], glowable_buf.size(), + glowable_buf.size() - 1, fmt, + args...)); +#else + n = static_cast( + snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...)); +#endif + } + return write(&glowable_buf[0], n); + } else { + return write(buf.data(), n); + } +} + +namespace detail { + +// Socket stream implementation +inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec, + time_t read_timeout_usec) + : sock_(sock), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec) {} + +inline SocketStream::~SocketStream() {} + +inline bool SocketStream::is_readable() const { + return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0; +} + +inline bool SocketStream::is_writable() const { + return select_write(sock_, 0, 0) > 0; +} + +inline ssize_t SocketStream::read(char *ptr, size_t size) { + if (!is_readable()) { return -1; } + +#ifdef _WIN32 + if (size > static_cast(std::numeric_limits::max())) { + return -1; + } + return recv(sock_, ptr, static_cast(size), 0); +#else + return HANDLE_EINTR(recv, sock_, ptr, size, 0); +#endif +} + +inline ssize_t SocketStream::write(const char *ptr, size_t size) { + if (!is_writable()) { return -1; } + +#ifdef _WIN32 + if (size > static_cast(std::numeric_limits::max())) { + return -1; + } + return send(sock_, ptr, static_cast(size), 0); +#else + return HANDLE_EINTR(send, sock_, ptr, size, 0); +#endif +} + +inline void SocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + return detail::get_remote_ip_and_port(sock_, ip, port); +} + +// Buffer stream implementation +inline bool BufferStream::is_readable() const { return true; } + +inline bool BufferStream::is_writable() const { return true; } + +inline ssize_t BufferStream::read(char *ptr, size_t size) { +#if defined(_MSC_VER) && _MSC_VER < 1900 + auto len_read = buffer._Copy_s(ptr, size, size, position); +#else + auto len_read = buffer.copy(ptr, size, position); +#endif + position += static_cast(len_read); + return static_cast(len_read); +} + +inline ssize_t BufferStream::write(const char *ptr, size_t size) { + buffer.append(ptr, size); + return static_cast(size); +} + +inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/, + int & /*port*/) const {} + +inline const std::string &BufferStream::get_buffer() const { return buffer; } + +} // namespace detail + +// HTTP server implementation +inline Server::Server() + : keep_alive_max_count_(CPPHTTPLIB_KEEPALIVE_MAX_COUNT), + read_timeout_sec_(CPPHTTPLIB_READ_TIMEOUT_SECOND), + read_timeout_usec_(CPPHTTPLIB_READ_TIMEOUT_USECOND), + payload_max_length_(CPPHTTPLIB_PAYLOAD_MAX_LENGTH), is_running_(false), + svr_sock_(INVALID_SOCKET) { +#ifndef _WIN32 + signal(SIGPIPE, SIG_IGN); +#endif + new_task_queue = [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }; +} + +inline Server::~Server() {} + +inline Server &Server::Get(const char *pattern, Handler handler) { + get_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Post(const char *pattern, Handler handler) { + post_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Post(const char *pattern, + HandlerWithContentReader handler) { + post_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Put(const char *pattern, Handler handler) { + put_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Put(const char *pattern, + HandlerWithContentReader handler) { + put_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Patch(const char *pattern, Handler handler) { + patch_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Patch(const char *pattern, + HandlerWithContentReader handler) { + patch_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Delete(const char *pattern, Handler handler) { + delete_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Delete(const char *pattern, + HandlerWithContentReader handler) { + delete_handlers_for_content_reader_.push_back( + std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline Server &Server::Options(const char *pattern, Handler handler) { + options_handlers_.push_back(std::make_pair(std::regex(pattern), handler)); + return *this; +} + +inline bool Server::set_base_dir(const char *dir, const char *mount_point) { + return set_mount_point(mount_point, dir); +} + +inline bool Server::set_mount_point(const char *mount_point, const char *dir) { + if (detail::is_dir(dir)) { + std::string mnt = mount_point ? mount_point : "/"; + if (!mnt.empty() && mnt[0] == '/') { + base_dirs_.emplace_back(mnt, dir); + return true; + } + } + return false; +} + +inline bool Server::remove_mount_point(const char *mount_point) { + for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) { + if (it->first == mount_point) { + base_dirs_.erase(it); + return true; + } + } + return false; +} + +inline void Server::set_file_extension_and_mimetype_mapping(const char *ext, + const char *mime) { + file_extension_and_mimetype_map_[ext] = mime; +} + +inline void Server::set_file_request_handler(Handler handler) { + file_request_handler_ = std::move(handler); +} + +inline void Server::set_error_handler(Handler handler) { + error_handler_ = std::move(handler); +} + +inline void Server::set_logger(Logger logger) { logger_ = std::move(logger); } + +inline void +Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) { + expect_100_continue_handler_ = std::move(handler); +} + +inline void Server::set_keep_alive_max_count(size_t count) { + keep_alive_max_count_ = count; +} + +inline void Server::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; +} + +inline void Server::set_payload_max_length(size_t length) { + payload_max_length_ = length; +} + +inline bool Server::bind_to_port(const char *host, int port, int socket_flags) { + if (bind_internal(host, port, socket_flags) < 0) return false; + return true; +} +inline int Server::bind_to_any_port(const char *host, int socket_flags) { + return bind_internal(host, 0, socket_flags); +} + +inline bool Server::listen_after_bind() { return listen_internal(); } + +inline bool Server::listen(const char *host, int port, int socket_flags) { + return bind_to_port(host, port, socket_flags) && listen_internal(); +} + +inline bool Server::is_running() const { return is_running_; } + +inline void Server::stop() { + if (is_running_) { + assert(svr_sock_ != INVALID_SOCKET); + std::atomic sock(svr_sock_.exchange(INVALID_SOCKET)); + detail::shutdown_socket(sock); + detail::close_socket(sock); + } +} + +inline bool Server::parse_request_line(const char *s, Request &req) { + const static std::regex re( + "(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH|PRI) " + "(([^?]+)(?:\\?(.*?))?) (HTTP/1\\.[01])\r\n"); + + std::cmatch m; + if (std::regex_match(s, m, re)) { + req.version = std::string(m[5]); + req.method = std::string(m[1]); + req.target = std::string(m[2]); + req.path = detail::decode_url(m[3], false); + + // Parse query text + auto len = std::distance(m[4].first, m[4].second); + if (len > 0) { detail::parse_query_text(m[4], req.params); } + + return true; + } + + return false; +} + +inline bool Server::write_response(Stream &strm, bool last_connection, + const Request &req, Response &res) { + assert(res.status != -1); + + if (400 <= res.status && error_handler_) { error_handler_(req, res); } + + detail::BufferStream bstrm; + + // Response line + if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status, + detail::status_message(res.status))) { + return false; + } + + // Headers + if (last_connection || req.get_header_value("Connection") == "close") { + res.set_header("Connection", "close"); + } + + if (!last_connection && req.get_header_value("Connection") == "Keep-Alive") { + res.set_header("Connection", "Keep-Alive"); + } + + if (!res.has_header("Content-Type") && + (!res.body.empty() || res.content_length > 0)) { + res.set_header("Content-Type", "text/plain"); + } + + if (!res.has_header("Accept-Ranges") && req.method == "HEAD") { + res.set_header("Accept-Ranges", "bytes"); + } + + std::string content_type; + std::string boundary; + + if (req.ranges.size() > 1) { + boundary = detail::make_multipart_data_boundary(); + + auto it = res.headers.find("Content-Type"); + if (it != res.headers.end()) { + content_type = it->second; + res.headers.erase(it); + } + + res.headers.emplace("Content-Type", + "multipart/byteranges; boundary=" + boundary); + } + + if (res.body.empty()) { + if (res.content_length > 0) { + size_t length = 0; + if (req.ranges.empty()) { + length = res.content_length; + } else if (req.ranges.size() == 1) { + auto offsets = + detail::get_range_offset_and_length(req, res.content_length, 0); + auto offset = offsets.first; + length = offsets.second; + auto content_range = detail::make_content_range_header_field( + offset, length, res.content_length); + res.set_header("Content-Range", content_range); + } else { + length = detail::get_multipart_ranges_data_length(req, res, boundary, + content_type); + } + res.set_header("Content-Length", std::to_string(length)); + } else { + if (res.content_provider) { + res.set_header("Transfer-Encoding", "chunked"); + } else { + res.set_header("Content-Length", "0"); + } + } + } else { + if (req.ranges.empty()) { + ; + } else if (req.ranges.size() == 1) { + auto offsets = + detail::get_range_offset_and_length(req, res.body.size(), 0); + auto offset = offsets.first; + auto length = offsets.second; + auto content_range = detail::make_content_range_header_field( + offset, length, res.body.size()); + res.set_header("Content-Range", content_range); + res.body = res.body.substr(offset, length); + } else { + res.body = + detail::make_multipart_ranges_data(req, res, boundary, content_type); + } + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + // TODO: 'Accept-Encoding' has gzip, not gzip;q=0 + const auto &encodings = req.get_header_value("Accept-Encoding"); + if (encodings.find("gzip") != std::string::npos && + detail::can_compress(res.get_header_value("Content-Type"))) { + if (detail::compress(res.body)) { + res.set_header("Content-Encoding", "gzip"); + } + } +#endif + + auto length = std::to_string(res.body.size()); + res.set_header("Content-Length", length); + } + + if (!detail::write_headers(bstrm, res, Headers())) { return false; } + + // Flush buffer + auto &data = bstrm.get_buffer(); + strm.write(data.data(), data.size()); + + // Body + if (req.method != "HEAD") { + if (!res.body.empty()) { + if (!strm.write(res.body)) { return false; } + } else if (res.content_provider) { + if (!write_content_with_provider(strm, req, res, boundary, + content_type)) { + return false; + } + } + } + + // Log + if (logger_) { logger_(req, res); } + + return true; +} + +inline bool +Server::write_content_with_provider(Stream &strm, const Request &req, + Response &res, const std::string &boundary, + const std::string &content_type) { + if (res.content_length) { + if (req.ranges.empty()) { + if (detail::write_content(strm, res.content_provider, 0, + res.content_length) < 0) { + return false; + } + } else if (req.ranges.size() == 1) { + auto offsets = + detail::get_range_offset_and_length(req, res.content_length, 0); + auto offset = offsets.first; + auto length = offsets.second; + if (detail::write_content(strm, res.content_provider, offset, length) < + 0) { + return false; + } + } else { + if (!detail::write_multipart_ranges_data(strm, req, res, boundary, + content_type)) { + return false; + } + } + } else { + auto is_shutting_down = [this]() { + return this->svr_sock_ == INVALID_SOCKET; + }; + if (detail::write_content_chunked(strm, res.content_provider, + is_shutting_down) < 0) { + return false; + } + } + return true; +} + +inline bool Server::read_content(Stream &strm, Request &req, Response &res) { + MultipartFormDataMap::iterator cur; + if (read_content_core( + strm, req, res, + // Regular + [&](const char *buf, size_t n) { + if (req.body.size() + n > req.body.max_size()) { return false; } + req.body.append(buf, n); + return true; + }, + // Multipart + [&](const MultipartFormData &file) { + cur = req.files.emplace(file.name, file); + return true; + }, + [&](const char *buf, size_t n) { + auto &content = cur->second.content; + if (content.size() + n > content.max_size()) { return false; } + content.append(buf, n); + return true; + })) { + const auto &content_type = req.get_header_value("Content-Type"); + if (!content_type.find("application/x-www-form-urlencoded")) { + detail::parse_query_text(req.body, req.params); + } + return true; + } + return false; +} + +inline bool Server::read_content_with_content_receiver( + Stream &strm, Request &req, Response &res, ContentReceiver receiver, + MultipartContentHeader multipart_header, + ContentReceiver multipart_receiver) { + return read_content_core(strm, req, res, receiver, multipart_header, + multipart_receiver); +} + +inline bool Server::read_content_core(Stream &strm, Request &req, Response &res, + ContentReceiver receiver, + MultipartContentHeader mulitpart_header, + ContentReceiver multipart_receiver) { + detail::MultipartFormDataParser multipart_form_data_parser; + ContentReceiver out; + + if (req.is_multipart_form_data()) { + const auto &content_type = req.get_header_value("Content-Type"); + std::string boundary; + if (!detail::parse_multipart_boundary(content_type, boundary)) { + res.status = 400; + return false; + } + + multipart_form_data_parser.set_boundary(std::move(boundary)); + out = [&](const char *buf, size_t n) { + return multipart_form_data_parser.parse(buf, n, multipart_receiver, + mulitpart_header); + }; + } else { + out = receiver; + } + + if (!detail::read_content(strm, req, payload_max_length_, res.status, + Progress(), out)) { + return false; + } + + if (req.is_multipart_form_data()) { + if (!multipart_form_data_parser.is_valid()) { + res.status = 400; + return false; + } + } + + return true; +} + +inline bool Server::handle_file_request(Request &req, Response &res, + bool head) { + for (const auto &kv : base_dirs_) { + const auto &mount_point = kv.first; + const auto &base_dir = kv.second; + + // Prefix match + if (!req.path.find(mount_point)) { + std::string sub_path = "/" + req.path.substr(mount_point.size()); + if (detail::is_valid_path(sub_path)) { + auto path = base_dir + sub_path; + if (path.back() == '/') { path += "index.html"; } + + if (detail::is_file(path)) { + detail::read_file(path, res.body); + auto type = + detail::find_content_type(path, file_extension_and_mimetype_map_); + if (type) { res.set_header("Content-Type", type); } + res.status = 200; + if (!head && file_request_handler_) { + file_request_handler_(req, res); + } + return true; + } + } + } + } + return false; +} + +inline socket_t Server::create_server_socket(const char *host, int port, + int socket_flags) const { + return detail::create_socket( + host, port, + [](socket_t sock, struct addrinfo &ai) -> bool { + if (::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen))) { + return false; + } + if (::listen(sock, 5)) { // Listen through 5 channels + return false; + } + return true; + }, + socket_flags); +} + +inline int Server::bind_internal(const char *host, int port, int socket_flags) { + if (!is_valid()) { return -1; } + + svr_sock_ = create_server_socket(host, port, socket_flags); + if (svr_sock_ == INVALID_SOCKET) { return -1; } + + if (port == 0) { + struct sockaddr_storage addr; + socklen_t addr_len = sizeof(addr); + if (getsockname(svr_sock_, reinterpret_cast(&addr), + &addr_len) == -1) { + return -1; + } + if (addr.ss_family == AF_INET) { + return ntohs(reinterpret_cast(&addr)->sin_port); + } else if (addr.ss_family == AF_INET6) { + return ntohs(reinterpret_cast(&addr)->sin6_port); + } else { + return -1; + } + } else { + return port; + } +} + +inline bool Server::listen_internal() { + auto ret = true; + is_running_ = true; + + { + std::unique_ptr task_queue(new_task_queue()); + + for (;;) { + if (svr_sock_ == INVALID_SOCKET) { + // The server socket was closed by 'stop' method. + break; + } + + auto val = detail::select_read(svr_sock_, 0, 100000); + + if (val == 0) { // Timeout + task_queue->on_idle(); + continue; + } + + socket_t sock = accept(svr_sock_, nullptr, nullptr); + + if (sock == INVALID_SOCKET) { + if (errno == EMFILE) { + // The per-process limit of open file descriptors has been reached. + // Try to accept new connections after a short sleep. + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + continue; + } + if (svr_sock_ != INVALID_SOCKET) { + detail::close_socket(svr_sock_); + ret = false; + } else { + ; // The server socket was closed by user. + } + break; + } + +#if __cplusplus > 201703L + task_queue->enqueue([=, this]() { process_and_close_socket(sock); }); +#else + task_queue->enqueue([=]() { process_and_close_socket(sock); }); +#endif + } + + task_queue->shutdown(); + } + + is_running_ = false; + return ret; +} + +inline bool Server::routing(Request &req, Response &res, Stream &strm) { + // File handler + bool is_head_request = req.method == "HEAD"; + if ((req.method == "GET" || is_head_request) && + handle_file_request(req, res, is_head_request)) { + return true; + } + + if (detail::expect_content(req)) { + // Content reader handler + { + ContentReader reader( + [&](ContentReceiver receiver) { + return read_content_with_content_receiver(strm, req, res, receiver, + nullptr, nullptr); + }, + [&](MultipartContentHeader header, ContentReceiver receiver) { + return read_content_with_content_receiver(strm, req, res, nullptr, + header, receiver); + }); + + if (req.method == "POST") { + if (dispatch_request_for_content_reader( + req, res, reader, post_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PUT") { + if (dispatch_request_for_content_reader( + req, res, reader, put_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "PATCH") { + if (dispatch_request_for_content_reader( + req, res, reader, patch_handlers_for_content_reader_)) { + return true; + } + } else if (req.method == "DELETE") { + if (dispatch_request_for_content_reader( + req, res, reader, delete_handlers_for_content_reader_)) { + return true; + } + } + } + + // Read content into `req.body` + if (!read_content(strm, req, res)) { return false; } + } + + // Regular handler + if (req.method == "GET" || req.method == "HEAD") { + return dispatch_request(req, res, get_handlers_); + } else if (req.method == "POST") { + return dispatch_request(req, res, post_handlers_); + } else if (req.method == "PUT") { + return dispatch_request(req, res, put_handlers_); + } else if (req.method == "DELETE") { + return dispatch_request(req, res, delete_handlers_); + } else if (req.method == "OPTIONS") { + return dispatch_request(req, res, options_handlers_); + } else if (req.method == "PATCH") { + return dispatch_request(req, res, patch_handlers_); + } + + res.status = 400; + return false; +} + +inline bool Server::dispatch_request(Request &req, Response &res, + Handlers &handlers) { + + try { + for (const auto &x : handlers) { + const auto &pattern = x.first; + const auto &handler = x.second; + + if (std::regex_match(req.path, req.matches, pattern)) { + handler(req, res); + return true; + } + } + } catch (const std::exception &ex) { + res.status = 500; + res.set_header("EXCEPTION_WHAT", ex.what()); + } catch (...) { + res.status = 500; + res.set_header("EXCEPTION_WHAT", "UNKNOWN"); + } + return false; +} + +inline bool Server::dispatch_request_for_content_reader( + Request &req, Response &res, ContentReader content_reader, + HandlersForContentReader &handlers) { + for (const auto &x : handlers) { + const auto &pattern = x.first; + const auto &handler = x.second; + + if (std::regex_match(req.path, req.matches, pattern)) { + handler(req, res, content_reader); + return true; + } + } + return false; +} + +inline bool +Server::process_request(Stream &strm, bool last_connection, + bool &connection_close, + const std::function &setup_request) { + std::array buf{}; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + // Connection has been closed on client + if (!line_reader.getline()) { return false; } + + Request req; + Response res; + + res.version = "HTTP/1.1"; + + // Check if the request URI doesn't exceed the limit + if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) { + Headers dummy; + detail::read_headers(strm, dummy); + res.status = 414; + return write_response(strm, last_connection, req, res); + } + + // Request line and headers + if (!parse_request_line(line_reader.ptr(), req) || + !detail::read_headers(strm, req.headers)) { + res.status = 400; + return write_response(strm, last_connection, req, res); + } + + if (req.get_header_value("Connection") == "close") { + connection_close = true; + } + + if (req.version == "HTTP/1.0" && + req.get_header_value("Connection") != "Keep-Alive") { + connection_close = true; + } + + strm.get_remote_ip_and_port(req.remote_addr, req.remote_port); + req.set_header("REMOTE_ADDR", req.remote_addr); + req.set_header("REMOTE_PORT", std::to_string(req.remote_port)); + + if (req.has_header("Range")) { + const auto &range_header_value = req.get_header_value("Range"); + if (!detail::parse_range_header(range_header_value, req.ranges)) { + // TODO: error + } + } + + if (setup_request) { setup_request(req); } + + if (req.get_header_value("Expect") == "100-continue") { + auto status = 100; + if (expect_100_continue_handler_) { + status = expect_100_continue_handler_(req, res); + } + switch (status) { + case 100: + case 417: + strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status, + detail::status_message(status)); + break; + default: return write_response(strm, last_connection, req, res); + } + } + + // Rounting + if (routing(req, res, strm)) { + if (res.status == -1) { res.status = req.ranges.empty() ? 200 : 206; } + } else { + if (res.status == -1) { res.status = 404; } + } + + return write_response(strm, last_connection, req, res); +} + +inline bool Server::is_valid() const { return true; } + +inline bool Server::process_and_close_socket(socket_t sock) { + return detail::process_and_close_socket( + false, sock, keep_alive_max_count_, read_timeout_sec_, read_timeout_usec_, + [this](Stream &strm, bool last_connection, bool &connection_close) { + return process_request(strm, last_connection, connection_close, + nullptr); + }); +} + +// HTTP client implementation +inline Client::Client(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : sock_(INVALID_SOCKET), host_(host), port_(port), + host_and_port_(host_ + ":" + std::to_string(port_)), + client_cert_path_(client_cert_path), client_key_path_(client_key_path) {} + +inline Client::~Client() {} + +inline bool Client::is_valid() const { return true; } + +inline socket_t Client::create_client_socket() const { + if (!proxy_host_.empty()) { + return detail::create_client_socket(proxy_host_.c_str(), proxy_port_, + timeout_sec_, interface_); + } + return detail::create_client_socket(host_.c_str(), port_, timeout_sec_, + interface_); +} + +inline bool Client::read_response_line(Stream &strm, Response &res) { + std::array buf; + + detail::stream_line_reader line_reader(strm, buf.data(), buf.size()); + + if (!line_reader.getline()) { return false; } + + const static std::regex re("(HTTP/1\\.[01]) (\\d+?) .*\r\n"); + + std::cmatch m; + if (std::regex_match(line_reader.ptr(), m, re)) { + res.version = std::string(m[1]); + res.status = std::stoi(std::string(m[2])); + } + + return true; +} + +inline bool Client::send(const Request &req, Response &res) { + sock_ = create_client_socket(); + if (sock_ == INVALID_SOCKET) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (is_ssl() && !proxy_host_.empty()) { + bool error; + if (!connect(sock_, res, error)) { return error; } + } +#endif + + return process_and_close_socket( + sock_, 1, + [&](Stream &strm, bool last_connection, bool &connection_close) { + return handle_request(strm, req, res, last_connection, + connection_close); + }); +} + +inline bool Client::send(const std::vector &requests, + std::vector &responses) { + size_t i = 0; + while (i < requests.size()) { + sock_ = create_client_socket(); + if (sock_ == INVALID_SOCKET) { return false; } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (is_ssl() && !proxy_host_.empty()) { + Response res; + bool error; + if (!connect(sock_, res, error)) { return false; } + } +#endif + + if (!process_and_close_socket(sock_, requests.size() - i, + [&](Stream &strm, bool last_connection, + bool &connection_close) -> bool { + auto &req = requests[i++]; + auto res = Response(); + auto ret = handle_request(strm, req, res, + last_connection, + connection_close); + if (ret) { + responses.emplace_back(std::move(res)); + } + return ret; + })) { + return false; + } + } + + return true; +} + +inline bool Client::handle_request(Stream &strm, const Request &req, + Response &res, bool last_connection, + bool &connection_close) { + if (req.path.empty()) { return false; } + + bool ret; + + if (!is_ssl() && !proxy_host_.empty()) { + auto req2 = req; + req2.path = "http://" + host_and_port_ + req.path; + ret = process_request(strm, req2, res, last_connection, connection_close); + } else { + ret = process_request(strm, req, res, last_connection, connection_close); + } + + if (!ret) { return false; } + + if (300 < res.status && res.status < 400 && follow_location_) { + ret = redirect(req, res); + } + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (res.status == 401 || res.status == 407) { + auto is_proxy = res.status == 407; + const auto &username = + is_proxy ? proxy_digest_auth_username_ : digest_auth_username_; + const auto &password = + is_proxy ? proxy_digest_auth_password_ : digest_auth_password_; + + if (!username.empty() && !password.empty()) { + std::map auth; + if (parse_www_authenticate(res, auth, is_proxy)) { + Request new_req = req; + auto key = is_proxy ? "Proxy-Authorization" : "WWW-Authorization"; + new_req.headers.erase(key); + new_req.headers.insert(make_digest_authentication_header( + req, auth, 1, random_string(10), username, password, is_proxy)); + + Response new_res; + + ret = send(new_req, new_res); + if (ret) { res = new_res; } + } + } + } +#endif + + return ret; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline bool Client::connect(socket_t sock, Response &res, bool &error) { + error = true; + Response res2; + + if (!detail::process_socket( + true, sock, 1, read_timeout_sec_, read_timeout_usec_, + [&](Stream &strm, bool /*last_connection*/, bool &connection_close) { + Request req2; + req2.method = "CONNECT"; + req2.path = host_and_port_; + return process_request(strm, req2, res2, false, connection_close); + })) { + detail::close_socket(sock); + error = false; + return false; + } + + if (res2.status == 407) { + if (!proxy_digest_auth_username_.empty() && + !proxy_digest_auth_password_.empty()) { + std::map auth; + if (parse_www_authenticate(res2, auth, true)) { + Response res3; + if (!detail::process_socket( + true, sock, 1, read_timeout_sec_, read_timeout_usec_, + [&](Stream &strm, bool /*last_connection*/, + bool &connection_close) { + Request req3; + req3.method = "CONNECT"; + req3.path = host_and_port_; + req3.headers.insert(make_digest_authentication_header( + req3, auth, 1, random_string(10), + proxy_digest_auth_username_, proxy_digest_auth_password_, + true)); + return process_request(strm, req3, res3, false, + connection_close); + })) { + detail::close_socket(sock); + error = false; + return false; + } + } + } else { + res = res2; + return false; + } + } + + return true; +} +#endif + +inline bool Client::redirect(const Request &req, Response &res) { + if (req.redirect_count == 0) { return false; } + + auto location = res.get_header_value("location"); + if (location.empty()) { return false; } + + const static std::regex re( + R"(^(?:(https?):)?(?://([^:/?#]*)(?::(\d+))?)?([^?#]*(?:\?[^#]*)?)(?:#.*)?)"); + + std::smatch m; + if (!std::regex_match(location, m, re)) { return false; } + + auto scheme = is_ssl() ? "https" : "http"; + + auto next_scheme = m[1].str(); + auto next_host = m[2].str(); + auto port_str = m[3].str(); + auto next_path = m[4].str(); + + auto next_port = port_; + if (!port_str.empty()) { + next_port = std::stoi(port_str); + } else if (!next_scheme.empty()) { + next_port = next_scheme == "https" ? 443 : 80; + } + + if (next_scheme.empty()) { next_scheme = scheme; } + if (next_host.empty()) { next_host = host_; } + if (next_path.empty()) { next_path = "/"; } + + if (next_scheme == scheme && next_host == host_ && next_port == port_) { + return detail::redirect(*this, req, res, next_path); + } else { + if (next_scheme == "https") { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(next_host.c_str(), next_port); + cli.copy_settings(*this); + return detail::redirect(cli, req, res, next_path); +#else + return false; +#endif + } else { + Client cli(next_host.c_str(), next_port); + cli.copy_settings(*this); + return detail::redirect(cli, req, res, next_path); + } + } +} + +inline bool Client::write_request(Stream &strm, const Request &req, + bool last_connection) { + detail::BufferStream bstrm; + + // Request line + const auto &path = detail::encode_url(req.path); + + bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str()); + + // Additonal headers + Headers headers; + if (last_connection) { headers.emplace("Connection", "close"); } + + if (!req.has_header("Host")) { + if (is_ssl()) { + if (port_ == 443) { + headers.emplace("Host", host_); + } else { + headers.emplace("Host", host_and_port_); + } + } else { + if (port_ == 80) { + headers.emplace("Host", host_); + } else { + headers.emplace("Host", host_and_port_); + } + } + } + + if (!req.has_header("Accept")) { headers.emplace("Accept", "*/*"); } + + if (!req.has_header("User-Agent")) { + headers.emplace("User-Agent", "cpp-httplib/0.5"); + } + + if (req.body.empty()) { + if (req.content_provider) { + auto length = std::to_string(req.content_length); + headers.emplace("Content-Length", length); + } else { + headers.emplace("Content-Length", "0"); + } + } else { + if (!req.has_header("Content-Type")) { + headers.emplace("Content-Type", "text/plain"); + } + + if (!req.has_header("Content-Length")) { + auto length = std::to_string(req.body.size()); + headers.emplace("Content-Length", length); + } + } + + if (!basic_auth_username_.empty() && !basic_auth_password_.empty()) { + headers.insert(make_basic_authentication_header( + basic_auth_username_, basic_auth_password_, false)); + } + + if (!proxy_basic_auth_username_.empty() && + !proxy_basic_auth_password_.empty()) { + headers.insert(make_basic_authentication_header( + proxy_basic_auth_username_, proxy_basic_auth_password_, true)); + } + + detail::write_headers(bstrm, req, headers); + + // Flush buffer + auto &data = bstrm.get_buffer(); + strm.write(data.data(), data.size()); + + // Body + if (req.body.empty()) { + if (req.content_provider) { + size_t offset = 0; + size_t end_offset = req.content_length; + + DataSink data_sink; + data_sink.write = [&](const char *d, size_t l) { + auto written_length = strm.write(d, l); + offset += static_cast(written_length); + }; + data_sink.is_writable = [&](void) { return strm.is_writable(); }; + + while (offset < end_offset) { + req.content_provider(offset, end_offset - offset, data_sink); + } + } + } else { + strm.write(req.body); + } + + return true; +} + +inline std::shared_ptr Client::send_with_content_provider( + const char *method, const char *path, const Headers &headers, + const std::string &body, size_t content_length, + ContentProvider content_provider, const char *content_type) { + Request req; + req.method = method; + req.headers = headers; + req.path = path; + + if (content_type) { req.headers.emplace("Content-Type", content_type); } + +#ifdef CPPHTTPLIB_ZLIB_SUPPORT + if (compress_) { + if (content_provider) { + size_t offset = 0; + + DataSink data_sink; + data_sink.write = [&](const char *data, size_t data_len) { + req.body.append(data, data_len); + offset += data_len; + }; + data_sink.is_writable = [&](void) { return true; }; + + while (offset < content_length) { + content_provider(offset, content_length - offset, data_sink); + } + } else { + req.body = body; + } + + if (!detail::compress(req.body)) { return nullptr; } + req.headers.emplace("Content-Encoding", "gzip"); + } else +#endif + { + if (content_provider) { + req.content_length = content_length; + req.content_provider = content_provider; + } else { + req.body = body; + } + } + + auto res = std::make_shared(); + + return send(req, *res) ? res : nullptr; +} + +inline bool Client::process_request(Stream &strm, const Request &req, + Response &res, bool last_connection, + bool &connection_close) { + // Send request + if (!write_request(strm, req, last_connection)) { return false; } + + // Receive response and headers + if (!read_response_line(strm, res) || + !detail::read_headers(strm, res.headers)) { + return false; + } + + if (res.get_header_value("Connection") == "close" || + res.version == "HTTP/1.0") { + connection_close = true; + } + + if (req.response_handler) { + if (!req.response_handler(res)) { return false; } + } + + // Body + if (req.method != "HEAD" && req.method != "CONNECT") { + auto out = + req.content_receiver + ? static_cast([&](const char *buf, size_t n) { + return req.content_receiver(buf, n); + }) + : static_cast([&](const char *buf, size_t n) { + if (res.body.size() + n > res.body.max_size()) { return false; } + res.body.append(buf, n); + return true; + }); + + int dummy_status; + if (!detail::read_content(strm, res, (std::numeric_limits::max)(), + dummy_status, req.progress, out)) { + return false; + } + } + + // Log + if (logger_) { logger_(req, res); } + + return true; +} + +inline bool Client::process_and_close_socket( + socket_t sock, size_t request_count, + std::function + callback) { + request_count = (std::min)(request_count, keep_alive_max_count_); + return detail::process_and_close_socket(true, sock, request_count, + read_timeout_sec_, read_timeout_usec_, + callback); +} + +inline bool Client::is_ssl() const { return false; } + +inline std::shared_ptr Client::Get(const char *path) { + return Get(path, Headers(), Progress()); +} + +inline std::shared_ptr Client::Get(const char *path, + Progress progress) { + return Get(path, Headers(), std::move(progress)); +} + +inline std::shared_ptr Client::Get(const char *path, + const Headers &headers) { + return Get(path, headers, Progress()); +} + +inline std::shared_ptr +Client::Get(const char *path, const Headers &headers, Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.progress = std::move(progress); + + auto res = std::make_shared(); + return send(req, *res) ? res : nullptr; +} + +inline std::shared_ptr Client::Get(const char *path, + ContentReceiver content_receiver) { + return Get(path, Headers(), nullptr, std::move(content_receiver), Progress()); +} + +inline std::shared_ptr Client::Get(const char *path, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, Headers(), nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline std::shared_ptr Client::Get(const char *path, + const Headers &headers, + ContentReceiver content_receiver) { + return Get(path, headers, nullptr, std::move(content_receiver), Progress()); +} + +inline std::shared_ptr Client::Get(const char *path, + const Headers &headers, + ContentReceiver content_receiver, + Progress progress) { + return Get(path, headers, nullptr, std::move(content_receiver), + std::move(progress)); +} + +inline std::shared_ptr Client::Get(const char *path, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver) { + return Get(path, headers, std::move(response_handler), content_receiver, + Progress()); +} + +inline std::shared_ptr Client::Get(const char *path, + const Headers &headers, + ResponseHandler response_handler, + ContentReceiver content_receiver, + Progress progress) { + Request req; + req.method = "GET"; + req.path = path; + req.headers = headers; + req.response_handler = std::move(response_handler); + req.content_receiver = std::move(content_receiver); + req.progress = std::move(progress); + + auto res = std::make_shared(); + return send(req, *res) ? res : nullptr; +} + +inline std::shared_ptr Client::Head(const char *path) { + return Head(path, Headers()); +} + +inline std::shared_ptr Client::Head(const char *path, + const Headers &headers) { + Request req; + req.method = "HEAD"; + req.headers = headers; + req.path = path; + + auto res = std::make_shared(); + + return send(req, *res) ? res : nullptr; +} + +inline std::shared_ptr Client::Post(const char *path) { + return Post(path, std::string(), nullptr); +} + +inline std::shared_ptr Client::Post(const char *path, + const std::string &body, + const char *content_type) { + return Post(path, Headers(), body, content_type); +} + +inline std::shared_ptr Client::Post(const char *path, + const Headers &headers, + const std::string &body, + const char *content_type) { + return send_with_content_provider("POST", path, headers, body, 0, nullptr, + content_type); +} + +inline std::shared_ptr Client::Post(const char *path, + const Params ¶ms) { + return Post(path, Headers(), params); +} + +inline std::shared_ptr Client::Post(const char *path, + size_t content_length, + ContentProvider content_provider, + const char *content_type) { + return Post(path, Headers(), content_length, content_provider, content_type); +} + +inline std::shared_ptr +Client::Post(const char *path, const Headers &headers, size_t content_length, + ContentProvider content_provider, const char *content_type) { + return send_with_content_provider("POST", path, headers, std::string(), + content_length, content_provider, + content_type); +} + +inline std::shared_ptr +Client::Post(const char *path, const Headers &headers, const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Post(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline std::shared_ptr +Client::Post(const char *path, const MultipartFormDataItems &items) { + return Post(path, Headers(), items); +} + +inline std::shared_ptr +Client::Post(const char *path, const Headers &headers, + const MultipartFormDataItems &items) { + auto boundary = detail::make_multipart_data_boundary(); + + std::string body; + + for (const auto &item : items) { + body += "--" + boundary + "\r\n"; + body += "Content-Disposition: form-data; name=\"" + item.name + "\""; + if (!item.filename.empty()) { + body += "; filename=\"" + item.filename + "\""; + } + body += "\r\n"; + if (!item.content_type.empty()) { + body += "Content-Type: " + item.content_type + "\r\n"; + } + body += "\r\n"; + body += item.content + "\r\n"; + } + + body += "--" + boundary + "--\r\n"; + + std::string content_type = "multipart/form-data; boundary=" + boundary; + return Post(path, headers, body, content_type.c_str()); +} + +inline std::shared_ptr Client::Put(const char *path) { + return Put(path, std::string(), nullptr); +} + +inline std::shared_ptr Client::Put(const char *path, + const std::string &body, + const char *content_type) { + return Put(path, Headers(), body, content_type); +} + +inline std::shared_ptr Client::Put(const char *path, + const Headers &headers, + const std::string &body, + const char *content_type) { + return send_with_content_provider("PUT", path, headers, body, 0, nullptr, + content_type); +} + +inline std::shared_ptr Client::Put(const char *path, + size_t content_length, + ContentProvider content_provider, + const char *content_type) { + return Put(path, Headers(), content_length, content_provider, content_type); +} + +inline std::shared_ptr +Client::Put(const char *path, const Headers &headers, size_t content_length, + ContentProvider content_provider, const char *content_type) { + return send_with_content_provider("PUT", path, headers, std::string(), + content_length, content_provider, + content_type); +} + +inline std::shared_ptr Client::Put(const char *path, + const Params ¶ms) { + return Put(path, Headers(), params); +} + +inline std::shared_ptr +Client::Put(const char *path, const Headers &headers, const Params ¶ms) { + auto query = detail::params_to_query_str(params); + return Put(path, headers, query, "application/x-www-form-urlencoded"); +} + +inline std::shared_ptr Client::Patch(const char *path, + const std::string &body, + const char *content_type) { + return Patch(path, Headers(), body, content_type); +} + +inline std::shared_ptr Client::Patch(const char *path, + const Headers &headers, + const std::string &body, + const char *content_type) { + return send_with_content_provider("PATCH", path, headers, body, 0, nullptr, + content_type); +} + +inline std::shared_ptr Client::Patch(const char *path, + size_t content_length, + ContentProvider content_provider, + const char *content_type) { + return Patch(path, Headers(), content_length, content_provider, content_type); +} + +inline std::shared_ptr +Client::Patch(const char *path, const Headers &headers, size_t content_length, + ContentProvider content_provider, const char *content_type) { + return send_with_content_provider("PATCH", path, headers, std::string(), + content_length, content_provider, + content_type); +} + +inline std::shared_ptr Client::Delete(const char *path) { + return Delete(path, Headers(), std::string(), nullptr); +} + +inline std::shared_ptr Client::Delete(const char *path, + const std::string &body, + const char *content_type) { + return Delete(path, Headers(), body, content_type); +} + +inline std::shared_ptr Client::Delete(const char *path, + const Headers &headers) { + return Delete(path, headers, std::string(), nullptr); +} + +inline std::shared_ptr Client::Delete(const char *path, + const Headers &headers, + const std::string &body, + const char *content_type) { + Request req; + req.method = "DELETE"; + req.headers = headers; + req.path = path; + + if (content_type) { req.headers.emplace("Content-Type", content_type); } + req.body = body; + + auto res = std::make_shared(); + + return send(req, *res) ? res : nullptr; +} + +inline std::shared_ptr Client::Options(const char *path) { + return Options(path, Headers()); +} + +inline std::shared_ptr Client::Options(const char *path, + const Headers &headers) { + Request req; + req.method = "OPTIONS"; + req.path = path; + req.headers = headers; + + auto res = std::make_shared(); + + return send(req, *res) ? res : nullptr; +} + +inline void Client::stop() { + if (sock_ != INVALID_SOCKET) { + std::atomic sock(sock_.exchange(INVALID_SOCKET)); + detail::shutdown_socket(sock); + detail::close_socket(sock); + } +} + +inline void Client::set_timeout_sec(time_t timeout_sec) { + timeout_sec_ = timeout_sec; +} + +inline void Client::set_read_timeout(time_t sec, time_t usec) { + read_timeout_sec_ = sec; + read_timeout_usec_ = usec; +} + +inline void Client::set_keep_alive_max_count(size_t count) { + keep_alive_max_count_ = count; +} + +inline void Client::set_basic_auth(const char *username, const char *password) { + basic_auth_username_ = username; + basic_auth_password_ = password; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_digest_auth(const char *username, + const char *password) { + digest_auth_username_ = username; + digest_auth_password_ = password; +} +#endif + +inline void Client::set_follow_location(bool on) { follow_location_ = on; } + +inline void Client::set_compress(bool on) { compress_ = on; } + +inline void Client::set_interface(const char *intf) { interface_ = intf; } + +inline void Client::set_proxy(const char *host, int port) { + proxy_host_ = host; + proxy_port_ = port; +} + +inline void Client::set_proxy_basic_auth(const char *username, + const char *password) { + proxy_basic_auth_username_ = username; + proxy_basic_auth_password_ = password; +} + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +inline void Client::set_proxy_digest_auth(const char *username, + const char *password) { + proxy_digest_auth_username_ = username; + proxy_digest_auth_password_ = password; +} +#endif + +inline void Client::set_logger(Logger logger) { logger_ = std::move(logger); } + +/* + * SSL Implementation + */ +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT +namespace detail { + +template +inline bool process_and_close_socket_ssl( + bool is_client_request, socket_t sock, size_t keep_alive_max_count, + time_t read_timeout_sec, time_t read_timeout_usec, SSL_CTX *ctx, + std::mutex &ctx_mutex, U SSL_connect_or_accept, V setup, T callback) { + assert(keep_alive_max_count > 0); + + SSL *ssl = nullptr; + { + std::lock_guard guard(ctx_mutex); + ssl = SSL_new(ctx); + } + + if (!ssl) { + close_socket(sock); + return false; + } + + auto bio = BIO_new_socket(static_cast(sock), BIO_NOCLOSE); + SSL_set_bio(ssl, bio, bio); + + if (!setup(ssl)) { + SSL_shutdown(ssl); + { + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); + } + + close_socket(sock); + return false; + } + + auto ret = false; + + if (SSL_connect_or_accept(ssl) == 1) { + if (keep_alive_max_count > 1) { + auto count = keep_alive_max_count; + while (count > 0 && + (is_client_request || + select_read(sock, CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND, + CPPHTTPLIB_KEEPALIVE_TIMEOUT_USECOND) > 0)) { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec); + auto last_connection = count == 1; + auto connection_close = false; + + ret = callback(ssl, strm, last_connection, connection_close); + if (!ret || connection_close) { break; } + + count--; + } + } else { + SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec); + auto dummy_connection_close = false; + ret = callback(ssl, strm, true, dummy_connection_close); + } + } + + if (ret) { + SSL_shutdown(ssl); // shutdown only if not already closed by remote + } + { + std::lock_guard guard(ctx_mutex); + SSL_free(ssl); + } + + close_socket(sock); + + return ret; +} + +#if OPENSSL_VERSION_NUMBER < 0x10100000L +static std::shared_ptr> openSSL_locks_; + +class SSLThreadLocks { +public: + SSLThreadLocks() { + openSSL_locks_ = + std::make_shared>(CRYPTO_num_locks()); + CRYPTO_set_locking_callback(locking_callback); + } + + ~SSLThreadLocks() { CRYPTO_set_locking_callback(nullptr); } + +private: + static void locking_callback(int mode, int type, const char * /*file*/, + int /*line*/) { + auto &lk = (*openSSL_locks_)[static_cast(type)]; + if (mode & CRYPTO_LOCK) { + lk.lock(); + } else { + lk.unlock(); + } + } +}; + +#endif + +class SSLInit { +public: + SSLInit() { +#if OPENSSL_VERSION_NUMBER < 0x1010001fL + SSL_load_error_strings(); + SSL_library_init(); +#else + OPENSSL_init_ssl( + OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); +#endif + } + + ~SSLInit() { +#if OPENSSL_VERSION_NUMBER < 0x1010001fL + ERR_free_strings(); +#endif + } + +private: +#if OPENSSL_VERSION_NUMBER < 0x10100000L + SSLThreadLocks thread_init_; +#endif +}; + +// SSL socket stream implementation +inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl, + time_t read_timeout_sec, + time_t read_timeout_usec) + : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec), + read_timeout_usec_(read_timeout_usec) {} + +inline SSLSocketStream::~SSLSocketStream() {} + +inline bool SSLSocketStream::is_readable() const { + return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0; +} + +inline bool SSLSocketStream::is_writable() const { + return detail::select_write(sock_, 0, 0) > 0; +} + +inline ssize_t SSLSocketStream::read(char *ptr, size_t size) { + if (SSL_pending(ssl_) > 0 || + select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0) { + return SSL_read(ssl_, ptr, static_cast(size)); + } + return -1; +} + +inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) { + if (is_writable()) { return SSL_write(ssl_, ptr, static_cast(size)); } + return -1; +} + +inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip, + int &port) const { + detail::get_remote_ip_and_port(sock_, ip, port); +} + +static SSLInit sslinit_; + +} // namespace detail + +// SSL HTTP server implementation +inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path, + const char *client_ca_cert_file_path, + const char *client_ca_cert_dir_path) { + ctx_ = SSL_CTX_new(SSLv23_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_ALL | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + // auto ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); + // SSL_CTX_set_tmp_ecdh(ctx_, ecdh); + // EC_KEY_free(ecdh); + + if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 || + SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) != + 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_file_path || client_ca_cert_dir_path) { + // if (client_ca_cert_file_path) { + // auto list = SSL_load_client_CA_file(client_ca_cert_file_path); + // SSL_CTX_set_client_CA_list(ctx_, list); + // } + + SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path, + client_ca_cert_dir_path); + + SSL_CTX_set_verify( + ctx_, + SSL_VERIFY_PEER | + SSL_VERIFY_FAIL_IF_NO_PEER_CERT, // SSL_VERIFY_CLIENT_ONCE, + nullptr); + } + } +} + +inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key, + X509_STORE *client_ca_cert_store) { + ctx_ = SSL_CTX_new(SSLv23_server_method()); + + if (ctx_) { + SSL_CTX_set_options(ctx_, + SSL_OP_ALL | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | + SSL_OP_NO_COMPRESSION | + SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); + + if (SSL_CTX_use_certificate(ctx_, cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } else if (client_ca_cert_store) { + + SSL_CTX_set_cert_store(ctx_, client_ca_cert_store); + + SSL_CTX_set_verify( + ctx_, + SSL_VERIFY_PEER | + SSL_VERIFY_FAIL_IF_NO_PEER_CERT, // SSL_VERIFY_CLIENT_ONCE, + nullptr); + } + } +} + +inline SSLServer::~SSLServer() { + if (ctx_) { SSL_CTX_free(ctx_); } +} + +inline bool SSLServer::is_valid() const { return ctx_; } + +inline bool SSLServer::process_and_close_socket(socket_t sock) { + return detail::process_and_close_socket_ssl( + false, sock, keep_alive_max_count_, read_timeout_sec_, read_timeout_usec_, + ctx_, ctx_mutex_, SSL_accept, [](SSL * /*ssl*/) { return true; }, + [this](SSL *ssl, Stream &strm, bool last_connection, + bool &connection_close) { + return process_request(strm, last_connection, connection_close, + [&](Request &req) { req.ssl = ssl; }); + }); +} + +// SSL HTTP client implementation +inline SSLClient::SSLClient(const std::string &host, int port, + const std::string &client_cert_path, + const std::string &client_key_path) + : Client(host, port, client_cert_path, client_key_path) { + ctx_ = SSL_CTX_new(SSLv23_client_method()); + + detail::split(&host_[0], &host_[host_.size()], '.', + [&](const char *b, const char *e) { + host_components_.emplace_back(std::string(b, e)); + }); + if (!client_cert_path.empty() && !client_key_path.empty()) { + if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(), + SSL_FILETYPE_PEM) != 1 || + SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(), + SSL_FILETYPE_PEM) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::SSLClient(const std::string &host, int port, + X509 *client_cert, EVP_PKEY *client_key) + : Client(host, port) { + ctx_ = SSL_CTX_new(SSLv23_client_method()); + + detail::split(&host_[0], &host_[host_.size()], '.', + [&](const char *b, const char *e) { + host_components_.emplace_back(std::string(b, e)); + }); + if (client_cert != nullptr && client_key != nullptr) { + if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 || + SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) { + SSL_CTX_free(ctx_); + ctx_ = nullptr; + } + } +} + +inline SSLClient::~SSLClient() { + if (ctx_) { SSL_CTX_free(ctx_); } +} + +inline bool SSLClient::is_valid() const { return ctx_; } + +inline void SSLClient::set_ca_cert_path(const char *ca_cert_file_path, + const char *ca_cert_dir_path) { + if (ca_cert_file_path) { ca_cert_file_path_ = ca_cert_file_path; } + if (ca_cert_dir_path) { ca_cert_dir_path_ = ca_cert_dir_path; } +} + +inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) { + if (ca_cert_store) { ca_cert_store_ = ca_cert_store; } +} + +inline void SSLClient::enable_server_certificate_verification(bool enabled) { + server_certificate_verification_ = enabled; +} + +inline long SSLClient::get_openssl_verify_result() const { + return verify_result_; +} + +inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; } + +inline bool SSLClient::process_and_close_socket( + socket_t sock, size_t request_count, + std::function + callback) { + + request_count = std::min(request_count, keep_alive_max_count_); + + return is_valid() && + detail::process_and_close_socket_ssl( + true, sock, request_count, read_timeout_sec_, read_timeout_usec_, + ctx_, ctx_mutex_, + [&](SSL *ssl) { + if (ca_cert_file_path_.empty() && ca_cert_store_ == nullptr) { + SSL_CTX_set_verify(ctx_, SSL_VERIFY_NONE, nullptr); + } else if (!ca_cert_file_path_.empty()) { + if (!SSL_CTX_load_verify_locations( + ctx_, ca_cert_file_path_.c_str(), nullptr)) { + return false; + } + SSL_CTX_set_verify(ctx_, SSL_VERIFY_PEER, nullptr); + } else if (ca_cert_store_ != nullptr) { + if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store_) { + SSL_CTX_set_cert_store(ctx_, ca_cert_store_); + } + SSL_CTX_set_verify(ctx_, SSL_VERIFY_PEER, nullptr); + } + + if (SSL_connect(ssl) != 1) { return false; } + + if (server_certificate_verification_) { + verify_result_ = SSL_get_verify_result(ssl); + + if (verify_result_ != X509_V_OK) { return false; } + + auto server_cert = SSL_get_peer_certificate(ssl); + + if (server_cert == nullptr) { return false; } + + if (!verify_host(server_cert)) { + X509_free(server_cert); + return false; + } + X509_free(server_cert); + } + + return true; + }, + [&](SSL *ssl) { + SSL_set_tlsext_host_name(ssl, host_.c_str()); + return true; + }, + [&](SSL * /*ssl*/, Stream &strm, bool last_connection, + bool &connection_close) { + return callback(strm, last_connection, connection_close); + }); +} + +inline bool SSLClient::is_ssl() const { return true; } + +inline bool SSLClient::verify_host(X509 *server_cert) const { + /* Quote from RFC2818 section 3.1 "Server Identity" + + If a subjectAltName extension of type dNSName is present, that MUST + be used as the identity. Otherwise, the (most specific) Common Name + field in the Subject field of the certificate MUST be used. Although + the use of the Common Name is existing practice, it is deprecated and + Certification Authorities are encouraged to use the dNSName instead. + + Matching is performed using the matching rules specified by + [RFC2459]. If more than one identity of a given type is present in + the certificate (e.g., more than one dNSName name, a match in any one + of the set is considered acceptable.) Names may contain the wildcard + character * which is considered to match any single domain name + component or component fragment. E.g., *.a.com matches foo.a.com but + not bar.foo.a.com. f*.com matches foo.com but not bar.com. + + In some cases, the URI is specified as an IP address rather than a + hostname. In this case, the iPAddress subjectAltName must be present + in the certificate and must exactly match the IP in the URI. + + */ + return verify_host_with_subject_alt_name(server_cert) || + verify_host_with_common_name(server_cert); +} + +inline bool +SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const { + auto ret = false; + + auto type = GEN_DNS; + + struct in6_addr addr6; + struct in_addr addr; + size_t addr_len = 0; + +#ifndef __MINGW32__ + if (inet_pton(AF_INET6, host_.c_str(), &addr6)) { + type = GEN_IPADD; + addr_len = sizeof(struct in6_addr); + } else if (inet_pton(AF_INET, host_.c_str(), &addr)) { + type = GEN_IPADD; + addr_len = sizeof(struct in_addr); + } +#endif + + auto alt_names = static_cast( + X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr)); + + if (alt_names) { + auto dsn_matched = false; + auto ip_mached = false; + + auto count = sk_GENERAL_NAME_num(alt_names); + + for (auto i = 0; i < count && !dsn_matched; i++) { + auto val = sk_GENERAL_NAME_value(alt_names, i); + if (val->type == type) { + auto name = (const char *)ASN1_STRING_get0_data(val->d.ia5); + auto name_len = (size_t)ASN1_STRING_length(val->d.ia5); + + if (strlen(name) == name_len) { + switch (type) { + case GEN_DNS: dsn_matched = check_host_name(name, name_len); break; + + case GEN_IPADD: + if (!memcmp(&addr6, name, addr_len) || + !memcmp(&addr, name, addr_len)) { + ip_mached = true; + } + break; + } + } + } + } + + if (dsn_matched || ip_mached) { ret = true; } + } + + GENERAL_NAMES_free((STACK_OF(GENERAL_NAME) *)alt_names); + + return ret; +} + +inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const { + const auto subject_name = X509_get_subject_name(server_cert); + + if (subject_name != nullptr) { + char name[BUFSIZ]; + auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName, + name, sizeof(name)); + + if (name_len != -1) { + return check_host_name(name, static_cast(name_len)); + } + } + + return false; +} + +inline bool SSLClient::check_host_name(const char *pattern, + size_t pattern_len) const { + if (host_.size() == pattern_len && host_ == pattern) { return true; } + + // Wildcard match + // https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484 + std::vector pattern_components; + detail::split(&pattern[0], &pattern[pattern_len], '.', + [&](const char *b, const char *e) { + pattern_components.emplace_back(std::string(b, e)); + }); + + if (host_components_.size() != pattern_components.size()) { return false; } + + auto itr = pattern_components.begin(); + for (const auto &h : host_components_) { + auto &p = *itr; + if (p != h && p != "*") { + auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' && + !p.compare(0, p.size() - 1, h)); + if (!partial_match) { return false; } + } + ++itr; + } + + return true; +} +#endif + +namespace url { + +struct Options { + // TODO: support more options... + bool follow_location = false; + std::string client_cert_path; + std::string client_key_path; + + std::string ca_cert_file_path; + std::string ca_cert_dir_path; + bool server_certificate_verification = false; +}; + +inline std::shared_ptr Get(const char *url, Options &options) { + const static std::regex re( + R"(^(https?)://([^:/?#]+)(?::(\d+))?([^?#]*(?:\?[^#]*)?)(?:#.*)?)"); + + std::cmatch m; + if (!std::regex_match(url, m, re)) { return nullptr; } + + auto next_scheme = m[1].str(); + auto next_host = m[2].str(); + auto port_str = m[3].str(); + auto next_path = m[4].str(); + + auto next_port = !port_str.empty() ? std::stoi(port_str) + : (next_scheme == "https" ? 443 : 80); + + if (next_path.empty()) { next_path = "/"; } + + if (next_scheme == "https") { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + SSLClient cli(next_host.c_str(), next_port, options.client_cert_path, + options.client_key_path); + cli.set_follow_location(options.follow_location); + cli.set_ca_cert_path(options.ca_cert_file_path.c_str(), + options.ca_cert_dir_path.c_str()); + cli.enable_server_certificate_verification( + options.server_certificate_verification); + return cli.Get(next_path.c_str()); +#else + return nullptr; +#endif + } else { + Client cli(next_host.c_str(), next_port, options.client_cert_path, + options.client_key_path); + cli.set_follow_location(options.follow_location); + return cli.Get(next_path.c_str()); + } +} + +inline std::shared_ptr Get(const char *url) { + Options options; + return Get(url, options); +} + +} // namespace url + +namespace detail { + +#undef HANDLE_EINTR + +} // namespace detail + +// ---------------------------------------------------------------------------- + +} // namespace httplib + +#endif // CPPHTTPLIB_HTTPLIB_H + From 15716f5a348e96e721773603ea5cd314be0e0d6e Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sat, 9 May 2020 23:34:53 +0200 Subject: [PATCH 04/13] bump mtxclient for SSO --- CMakeLists.txt | 2 +- io.github.NhekoReborn.Nheko.json | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 97cb8ea2..ed714e31 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -337,7 +337,7 @@ if(USE_BUNDLED_MTXCLIENT) FetchContent_Declare( MatrixClient GIT_REPOSITORY https://github.com/Nheko-Reborn/mtxclient.git - GIT_TAG 1893cd6171c40c250ca64d388c082789452340a8 + GIT_TAG 71bd56b66cf634341ffef804f07d33f01fd57c25 ) FetchContent_MakeAvailable(MatrixClient) else() diff --git a/io.github.NhekoReborn.Nheko.json b/io.github.NhekoReborn.Nheko.json index fe3a4a25..60d984fb 100644 --- a/io.github.NhekoReborn.Nheko.json +++ b/io.github.NhekoReborn.Nheko.json @@ -146,9 +146,9 @@ "name": "mtxclient", "sources": [ { - "sha256": "a8c0239b7157fe8eadae8b06cd6c4e3531dcc61fc5a7f52dbb3c85106f70e3a5", + "sha256": "7055f1459a43a12f27f949564624f13cc593ac894e445e6de0e6563ad38ebc3e", "type": "archive", - "url": "https://github.com/Nheko-Reborn/mtxclient/archive/1893cd6171c40c250ca64d388c082789452340a8.tar.gz" + "url": "https://github.com/Nheko-Reborn/mtxclient/archive/71bd56b66cf634341ffef804f07d33f01fd57c25.tar.gz" } ] }, From 97132844357750110c900a3e91619a5b36f7a5eb Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sun, 10 May 2020 00:04:45 +0200 Subject: [PATCH 05/13] Fix not being able to log http status on login --- src/LoginPage.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/LoginPage.cpp b/src/LoginPage.cpp index 4c3999ec..856c0ad3 100644 --- a/src/LoginPage.cpp +++ b/src/LoginPage.cpp @@ -234,7 +234,7 @@ LoginPage::onMatrixIdEntered() "requesting .well-known.")); nhlog::net()->error("Autodiscovery failed. Unknown error when " "requesting .well-known. {}", - err->status_code); + err->error_code.message()); return; } From 6befadeec88c8be6db304136a079e1b56b451cc6 Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sun, 10 May 2020 01:00:20 +0200 Subject: [PATCH 06/13] Remove shadowing loginMethod --- src/LoginPage.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/LoginPage.cpp b/src/LoginPage.cpp index 856c0ad3..bb329699 100644 --- a/src/LoginPage.cpp +++ b/src/LoginPage.cpp @@ -311,9 +311,9 @@ LoginPage::versionError(const QString &error) } void -LoginPage::versionOk(LoginMethod loginMethod) +LoginPage::versionOk(LoginMethod loginMethod_) { - this->loginMethod = loginMethod; + this->loginMethod = loginMethod_; serverLayout_->removeWidget(spinner_); matrixidLayout_->removeWidget(spinner_); @@ -372,8 +372,8 @@ LoginPage::onLoginButtonClicked() auto sso = new SSOHandler(); connect(sso, &SSOHandler::ssoSuccess, this, [this, sso](std::string token) { mtx::requests::Login req{}; - req.token = token; - req.type = mtx::user_interactive::auth_types::token; + req.token = token; + req.type = mtx::user_interactive::auth_types::token; req.device_id = deviceName_->text().trimmed().isEmpty() ? initialDeviceName() : deviceName_->text().toStdString(); From 000ab4853a4b83408af42d59ed753ae76aa26e80 Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Sun, 10 May 2020 01:38:40 +0200 Subject: [PATCH 07/13] Translation updates --- resources/langs/nheko_de.ts | 136 +++++++++++++++++++++++--------- resources/langs/nheko_el.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_en.qm | Bin 0 -> 32178 bytes resources/langs/nheko_en.ts | 140 ++++++++++++++++++++++++--------- resources/langs/nheko_fi.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_fr.ts | 123 +++++++++++++++++++++-------- resources/langs/nheko_ja.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_nl.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_pl.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_ru.ts | 122 ++++++++++++++++++++-------- resources/langs/nheko_zh_CN.ts | 122 ++++++++++++++++++++-------- src/Cache.cpp | 2 +- src/ChatPage.cpp | 4 +- src/RegisterPage.cpp | 2 +- src/SSOHandler.cpp | 1 - src/timeline/TimelineModel.cpp | 2 +- 16 files changed, 925 insertions(+), 339 deletions(-) create mode 100644 resources/langs/nheko_en.qm diff --git a/resources/langs/nheko_de.ts b/resources/langs/nheko_de.ts index 3f9cdc52..fcbf8b31 100644 --- a/resources/langs/nheko_de.ts +++ b/resources/langs/nheko_de.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + Du bist dem Raum beigetreten. + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 Eingeladener Benutzer: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + Migrieren des Caches auf die aktuelle Version fehlgeschlagen. Das kann verschiedene Gründe als Ursache haben. Bitte lege einen Bugreport an und verwende in der Zwischenzeit eine ältere Version. Alternativ kannst du das Cache manuell entfernen. + + + + Room %1 created. + Raum %1 erzeugt. + + + Failed to invite %1 to %2: %3 Einladung von %1 in Raum %2 fehlgeschlagen: %3 @@ -50,29 +68,24 @@ Verbannung von %1 wurde aufgehoben. - + Failed to upload media. Please try again. Medienupload fehlgeschlagen. Bitte versuche es erneut. Cache migration failed! - + Cache migration fehlgeschlagen! - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version - + Inkompatible Cacheversion The cache on your disk is newer than this version of Nheko supports. Please update or clear your cache. - + Das Cache auf der Festplatte wurde mit einer neueren Nheko version angelegt. Bitte aktualisiere Nheko oder entferne das Cache. @@ -91,7 +104,7 @@ - + Please try to login again: %1 Bitte melde dich erneut an: %1 @@ -116,12 +129,7 @@ Raum konnte nicht erstellt werden: %1 - - Room %1 created - Raum %1 wurde erstellt. - - - + Failed to leave room: %1 Konnte den Raum nicht verlassen: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix-ID @@ -207,22 +215,46 @@ z.B. @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + Dein Anmeldename. Eine mxid sollte mit einem @ anfangen, gefolgt von dem Benutzernamen. Nach dem Benutzernamen sollten ein Doppelpunkt (:) under der Servername folgen. +Nach dem Doppelpunkt kann alternativ die Serveradresse (mit oder ohne Port) angegeben werden, wenn der Server nicht per .well-known auffindbar ist. +Beispiel: @benutzer:dein.server +Wenn Nheko deinen Server nicht automatisch erkennen kann, wird es dich nach dem Server fragen. + + + Password Passwort - + Device name Gerätename - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + Ein Name für dieses Gerät. Dieser wird anderen angezeigt, wenn sie dieses Gerät verifizieren. Wenn kein Name angegeben wurde, wird automatisch ein zufälliger Name erzeugt, der keine Rückschlüsse auf deine Identität zulassen sollte. + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + Die Adresse unter der dein Heimserver erreichbar ist. +Beispiel: https://mein.server:8787 + + + + LOGIN ANMELDEN - + Autodiscovery failed. Received malformed response. Automatische Erkennung fehlgeschlagen. Antwort war fehlerhaft. @@ -232,7 +264,7 @@ Automatische Erkennung fehlgeschlagen. Unbekannter Fehler bei Anfrage .well-known. - + The required endpoints were not found. Possibly not a Matrix server. Benötigte Ansprechpunkte nicht auffindbar. Möglicherweise kein Matrixserver. @@ -247,10 +279,20 @@ Ein unbekannter Fehler ist aufgetreten. Bitte Homeserverdomain prüfen. - + + SSO LOGIN + SSO ANMELDUNG + + + Empty password Leeres Passwort + + + SSO login failed + SSO Anmeldung fehlgeschlagen + MemberList @@ -328,9 +370,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + Der Benutzername sollte nicht leer sein und nur aus a-z, 0-9, ., _, =, - und / bestehen. + + + Password Passwort + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + Bitte wähle ein sicheres Passwort. Die genauen Anforderungen bestimmt dein Server. + Password confirmation @@ -338,11 +390,16 @@ - Home Server - Homeserver + Homeserver + Heimserver - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + Ein Server, der Registrierungen zulässt. Weil Matrix ein dezentralisiertes Protokoll ist, musst du erst einen Server ausfindig machen oder einen persönlichen Server aufsetzen. + + + REGISTER REGISTRIEREN @@ -375,7 +432,7 @@ RoomInfo - + no version stored keine Version gespeichert @@ -491,7 +548,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. -- Entschlüsselungsfehler (Fehler bei Kommunikation mit Datenbank) -- @@ -660,7 +717,12 @@ %1 hat das Anklopfen zurückgezogen. - + + You joined this room. + Du bist dem Raum beigetreten. + + + Rejected the knock from %1. Hat das Anklopfen von %1 abgewiesen. @@ -684,7 +746,7 @@ TimelineRow - + Reply Antworten @@ -697,7 +759,7 @@ TimelineView - + Reply Antworten @@ -737,7 +799,7 @@ Kein Raum geöffnet - + Close Schließen @@ -826,7 +888,7 @@ Show buttons in timeline - + Zeige Buttons in der Historie @@ -1044,7 +1106,7 @@ Open Fallback in Browser - Öffne Fallback im Browser + Öffne Fallback im Browser diff --git a/resources/langs/nheko_el.ts b/resources/langs/nheko_el.ts index 7cd94593..39ed1442 100644 --- a/resources/langs/nheko_el.ts +++ b/resources/langs/nheko_el.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 @@ -116,12 +129,7 @@ - - Room %1 created - - - - + Failed to leave room: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix ID @@ -207,22 +215,42 @@ π.χ @john:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Κωδικός - + Device name - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN ΕΙΣΟΔΟΣ - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. @@ -247,10 +275,20 @@ - + + SSO LOGIN + + + + Empty password Κενός κωδικός + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Κωδικός + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - Διακομιστής + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER ΕΓΓΡΑΦΗ @@ -375,7 +428,7 @@ RoomInfo - + no version stored @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -660,7 +713,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -684,7 +742,7 @@ TimelineRow - + Reply @@ -697,7 +755,7 @@ TimelineView - + Reply @@ -737,7 +795,7 @@ - + Close diff --git a/resources/langs/nheko_en.qm b/resources/langs/nheko_en.qm new file mode 100644 index 0000000000000000000000000000000000000000..0973db2d9c4232eec42ce38a1493607f33abb136 GIT binary patch literal 32178 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 + + Cache + + + You joined this room. + You joined this room. + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + Room %1 created. + Room %1 created. + + + Failed to invite %1 to %2: %3 Failed to invite %1 to %2: %3 @@ -50,29 +68,24 @@ Unbanned user: %1 - + Failed to upload media. Please try again. Failed to upload media. Please try again. Cache migration failed! - + Cache migration failed! - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version - + Incompatible cache version The cache on your disk is newer than this version of Nheko supports. Please update or clear your cache. - + The cache on your disk is newer than this version of Nheko supports. Please update or clear your cache. @@ -91,7 +104,7 @@ - + Please try to login again: %1 Please try to login again: %1 @@ -116,12 +129,7 @@ Room creation failed: %1 - - Room %1 created - Room %1 created. - - - + Failed to leave room: %1 Failed to leave room: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix ID @@ -207,22 +215,46 @@ e.g @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + Password Password - + Device name Device name - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + LOGIN LOGIN - + Autodiscovery failed. Received malformed response. Autodiscovery failed. Received malformed response. @@ -232,7 +264,7 @@ Autodiscovery failed. Unknown error while requesting .well-known. - + The required endpoints were not found. Possibly not a Matrix server. The required endpoints were not found. Possibly not a Matrix server. @@ -247,10 +279,20 @@ An unknown error occured. Make sure the homeserver domain is valid. - + + SSO LOGIN + SSO LOGIN + + + Empty password Empty password + + + SSO login failed + SSO login failed + MemberList @@ -328,9 +370,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + Password Password + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + Please choose a secure password. The exact requirements for password strength may depend on your server. + Password confirmation @@ -338,11 +390,16 @@ - Home Server - Home Server + Homeserver + Homeserver - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + REGISTER REGISTER @@ -375,7 +432,7 @@ RoomInfo - + no version stored no version stored @@ -491,7 +548,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. -- Decryption Error (failed to communicate with DB) -- @@ -550,8 +607,8 @@ %1 and %2 are typing. Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.) - %1%2 is typing - %1 and %2 are typing + %1%2 is typing. + %1 and %2 are typing. @@ -660,7 +717,12 @@ %1 redacted their knock. - + + You joined this room. + You joined this room. + + + Rejected the knock from %1. Rejected the knock from %1. @@ -684,7 +746,7 @@ TimelineRow - + Reply Reply @@ -697,7 +759,7 @@ TimelineView - + Reply Reply @@ -719,7 +781,7 @@ View decrypted raw message - + View decrypted raw message @@ -737,7 +799,7 @@ No room open - + Close Close @@ -821,7 +883,7 @@ Decrypt messages in sidebar - + Decrypt messages in sidebar diff --git a/resources/langs/nheko_fi.ts b/resources/langs/nheko_fi.ts index 0f0cf1ac..01b9d75d 100644 --- a/resources/langs/nheko_fi.ts +++ b/resources/langs/nheko_fi.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 Ole hyvä ja yritä kirjautua sisään uudelleen: %1 @@ -116,12 +129,7 @@ Huoneen luominen epäonnistui: %1 - - Room %1 created - - - - + Failed to leave room: %1 Huoneesta poistuminen epäonnistui: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix-tunnus @@ -207,22 +215,42 @@ esim. @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Salasana - + Device name Laitteen nimi - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN KIRJAUDU - + Autodiscovery failed. Received malformed response. Palvelimen tietojen hakeminen epäonnistui: virheellinen vastaus. @@ -232,7 +260,7 @@ Palvelimen tietojen hakeminen epäonnistui: tuntematon virhe hakiessa .well-known -tiedostoa. - + The required endpoints were not found. Possibly not a Matrix server. Vaadittuja päätepisteitä ei löydetty. Mahdollisesti ei Matrix-palvelin. @@ -247,10 +275,20 @@ Tapahtui tuntematon virhe. Varmista, että kotipalvelimen osoite on pätevä. - + + SSO LOGIN + + + + Empty password Tyhjä salasana + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Salasana + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - Kotipalvelin + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER REKISTERÖIDY @@ -375,7 +428,7 @@ RoomInfo - + no version stored ei tallennettua versiota @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. -- Virhe purkaessa salausta (tietokannan kanssa kommunikointi epäonnistui) -- @@ -660,7 +713,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -684,7 +742,7 @@ TimelineRow - + Reply @@ -697,7 +755,7 @@ TimelineView - + Reply @@ -737,7 +795,7 @@ - + Close Sulje diff --git a/resources/langs/nheko_fr.ts b/resources/langs/nheko_fr.ts index 3668e53e..9e47702b 100644 --- a/resources/langs/nheko_fr.ts +++ b/resources/langs/nheko_fr.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 @@ -116,12 +129,7 @@ - - Room %1 created - - - - + Failed to leave room: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Identifiant Matrix @@ -207,22 +215,42 @@ ex : @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Mot de passe - + Device name - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN CONNEXION - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. @@ -247,10 +275,20 @@ - + + SSO LOGIN + + + + Empty password Mot de passe vide + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Mot de passe + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,12 +386,16 @@ - Home Server - À affiner... - Serveur Matrix + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER S'ENREGISTRER @@ -376,7 +428,7 @@ RoomInfo - + no version stored @@ -492,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -661,7 +713,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -685,7 +742,7 @@ TimelineRow - + Reply @@ -698,7 +755,7 @@ TimelineView - + Reply @@ -738,7 +795,7 @@ - + Close diff --git a/resources/langs/nheko_ja.ts b/resources/langs/nheko_ja.ts index c6f38fed..049c4189 100644 --- a/resources/langs/nheko_ja.ts +++ b/resources/langs/nheko_ja.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 招待されたユーザー: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 %2に%1を招待できませんでした: %3 @@ -50,7 +68,7 @@ 永久追放を解除されたユーザー: %1 - + Failed to upload media. Please try again. メディアをアップロードできませんでした。やり直して下さい。 @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 もう一度ログインしてみて下さい: %1 @@ -116,12 +129,7 @@ 部屋を作成できませんでした: %1 - - Room %1 created - 部屋 %1 を作成しました - - - + Failed to leave room: %1 部屋から出られませんでした: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix ID @@ -207,22 +215,42 @@ 例 @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password パスワード - + Device name デバイス名 - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN ログイン - + Autodiscovery failed. Received malformed response. 自動検出できませんでした。不正な形式の応答を受信しました。 @@ -232,7 +260,7 @@ 自動検出できませんでした。.well-known要求時の不明なエラー。 - + The required endpoints were not found. Possibly not a Matrix server. 必要な端点が見つかりません。Matrixサーバーではないかもしれません。 @@ -247,10 +275,20 @@ 不明なエラーが発生しました。ホームサーバーのドメイン名が有効であるかを確認して下さい。 - + + SSO LOGIN + + + + Empty password パスワードが入力されていません + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password パスワード + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - ホームサーバー + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER 登録 @@ -375,7 +428,7 @@ RoomInfo - + no version stored バージョンが保存されていません @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. -- 復号エラー (データベースと通信できませんでした) -- @@ -659,7 +712,12 @@ %1がノックを編集しました。 - + + You joined this room. + + + + Rejected the knock from %1. %1からのノックを拒否しました。 @@ -683,7 +741,7 @@ TimelineRow - + Reply 返信 @@ -696,7 +754,7 @@ TimelineView - + Reply 返信 @@ -736,7 +794,7 @@ 部屋が開いていません - + Close 閉じる diff --git a/resources/langs/nheko_nl.ts b/resources/langs/nheko_nl.ts index f70e1fef..205de986 100644 --- a/resources/langs/nheko_nl.ts +++ b/resources/langs/nheko_nl.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 @@ -116,12 +129,7 @@ - - Room %1 created - - - - + Failed to leave room: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Matrix-id @@ -207,22 +215,42 @@ b.v @jan:matrix.org< - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Wachtwoord - + Device name - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN INLOGGEN - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. @@ -247,10 +275,20 @@ - + + SSO LOGIN + + + + Empty password Leeg wachtwoord + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Wachtwoord + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - Thuisserver + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER REGISTREREN @@ -375,7 +428,7 @@ RoomInfo - + no version stored @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -660,7 +713,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -684,7 +742,7 @@ TimelineRow - + Reply @@ -697,7 +755,7 @@ TimelineView - + Reply @@ -737,7 +795,7 @@ - + Close diff --git a/resources/langs/nheko_pl.ts b/resources/langs/nheko_pl.ts index 07ecf4a4..c089a5b4 100644 --- a/resources/langs/nheko_pl.ts +++ b/resources/langs/nheko_pl.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 Spróbuj zalogować się ponownie: %1 @@ -116,12 +129,7 @@ Tworzenie pokoju nie powiodło się: %1 - - Room %1 created - - - - + Failed to leave room: %1 Nie udało się opuścić pokoju: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID ID Matrixa @@ -207,22 +215,42 @@ np. @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Hasło - + Device name Nazwa urządzenia - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN ZALOGUJ - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. Nie odnaleziono wymaganych punktów końcowych. To może nie być serwer Matriksa. @@ -247,10 +275,20 @@ Wystąpił nieznany błąd. Upewnij się, że domena serwera domowego jest prawidłowa. - + + SSO LOGIN + + + + Empty password Puste hasło + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Hasło + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - Serwer domowy + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER ZAREJESTRUJ @@ -375,7 +428,7 @@ RoomInfo - + no version stored @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -661,7 +714,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -685,7 +743,7 @@ TimelineRow - + Reply @@ -698,7 +756,7 @@ TimelineView - + Reply @@ -738,7 +796,7 @@ - + Close diff --git a/resources/langs/nheko_ru.ts b/resources/langs/nheko_ru.ts index 25abbe40..761110f0 100644 --- a/resources/langs/nheko_ru.ts +++ b/resources/langs/nheko_ru.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 Повторите попытку входа: %1 @@ -116,12 +129,7 @@ Не удалось создать комнату: %1 - - Room %1 created - - - - + Failed to leave room: %1 Не удалось покинуть комнату: %1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID Идентификатор Matrix @@ -207,22 +215,42 @@ Пример: @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password Пароль - + Device name Имя устройства - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN ВОЙТИ - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. Необходимые конечные точки не найдены. Возможно, это не сервер Matrix. @@ -247,10 +275,20 @@ Произошла неизвестная ошибка. Убедитесь, что домен homeserver действителен. - + + SSO LOGIN + + + + Empty password Пустой пароль + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password Пароль + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - Домашний сервер + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER РЕГИСТРАЦИЯ @@ -375,7 +428,7 @@ RoomInfo - + no version stored @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -661,7 +714,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -685,7 +743,7 @@ TimelineRow - + Reply @@ -698,7 +756,7 @@ TimelineView - + Reply @@ -738,7 +796,7 @@ - + Close Закрыть diff --git a/resources/langs/nheko_zh_CN.ts b/resources/langs/nheko_zh_CN.ts index ddd8c017..5b080b74 100644 --- a/resources/langs/nheko_zh_CN.ts +++ b/resources/langs/nheko_zh_CN.ts @@ -1,6 +1,14 @@ + + Cache + + + You joined this room. + + + ChatPage @@ -10,12 +18,22 @@ - + Invited user: %1 - + + Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually. + + + + + Room %1 created. + + + + Failed to invite %1 to %2: %3 @@ -50,7 +68,7 @@ - + Failed to upload media. Please try again. @@ -60,12 +78,7 @@ - - Migrating the cache to the current version failed. This can have different reasons. Please open an issue and try to use an older version in the mean time. Alternatively you can try deleting the cache manually - - - - + Incompatible cache version @@ -91,7 +104,7 @@ - + Please try to login again: %1 请尝试再次登录：%1 @@ -116,12 +129,7 @@ 创建聊天室失败：%1 - - Room %1 created - - - - + Failed to leave room: %1 离开聊天室失败：%1 @@ -197,7 +205,7 @@ LoginPage - + Matrix ID @@ -207,22 +215,42 @@ 例如 @joe:matrix.org - + + Your login name. A mxid should start with @ followed by the user id. After the user id you need to include your server name after a :. +You can also put your homeserver address there, if your server doesn't support .well-known lookup. +Example: @user:server.my +If Nheko fails to discover your homeserver, it will show you a field to enter the server manually. + + + + Password 密码 - + Device name 设备名 - + + A name for this device, which will be shown to others, when verifying your devices. If none is provided, a random string is used for privacy purposes. + + + + + The address that can be used to contact you homeservers client API. +Example: https://server.my:8787 + + + + + LOGIN 登录 - + Autodiscovery failed. Received malformed response. @@ -232,7 +260,7 @@ - + The required endpoints were not found. Possibly not a Matrix server. 没找到要求的终端。可能不是一个 Matrix 服务器。 @@ -247,10 +275,20 @@ 发生了一个未知错误。请确认服务器域名合法。 - + + SSO LOGIN + + + + Empty password 空密码 + + + SSO login failed + + MemberList @@ -328,9 +366,19 @@ + The username must not be empty, and must contain only the characters a-z, 0-9, ., _, =, -, and /. + + + + Password 密码 + + + Please choose a secure password. The exact requirements for password strength may depend on your server. + + Password confirmation @@ -338,11 +386,16 @@ - Home Server - 服务器 + Homeserver + - + + A server that allows registration. Since matrix is decentralized, you need to first find a server you can register on or host your own. + + + + REGISTER 注册 @@ -375,7 +428,7 @@ RoomInfo - + no version stored @@ -491,7 +544,7 @@ TimelineModel - + -- Decryption Error (failed to communicate with DB) -- Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session. @@ -659,7 +712,12 @@ - + + You joined this room. + + + + Rejected the knock from %1. @@ -683,7 +741,7 @@ TimelineRow - + Reply @@ -696,7 +754,7 @@ TimelineView - + Reply @@ -736,7 +794,7 @@ - + Close diff --git a/src/Cache.cpp b/src/Cache.cpp index 8cfc4b55..3a388bb9 100644 --- a/src/Cache.cpp +++ b/src/Cache.cpp @@ -1338,7 +1338,7 @@ Cache::getLastMessageInfo(lmdb::txn &txn, const std::string &room_id) auto time = QDateTime::fromMSecsSinceEpoch(ts); fallbackDesc = DescInfo{QString::fromStdString(obj["event"]["event_id"]), local_user, - tr("You joined this room"), + tr("You joined this room."), utils::descriptiveTime(time), ts, time}; diff --git a/src/ChatPage.cpp b/src/ChatPage.cpp index 7c4aac77..4043fdf5 100644 --- a/src/ChatPage.cpp +++ b/src/ChatPage.cpp @@ -660,7 +660,7 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token) "This can have different reasons. Please open an " "issue and try to use an older version in the mean " "time. Alternatively you can try deleting the cache " - "manually")); + "manually.")); QCoreApplication::quit(); } loadStateFromCache(); @@ -1084,7 +1084,7 @@ ChatPage::createRoom(const mtx::requests::CreateRoom &req) } emit showNotification( - tr("Room %1 created").arg(QString::fromStdString(res.room_id.to_string()))); + tr("Room %1 created.").arg(QString::fromStdString(res.room_id.to_string()))); }); } diff --git a/src/RegisterPage.cpp b/src/RegisterPage.cpp index a01f2140..03e9ab34 100644 --- a/src/RegisterPage.cpp +++ b/src/RegisterPage.cpp @@ -94,7 +94,7 @@ RegisterPage::RegisterPage(QWidget *parent) password_input_->setLabel(tr("Password")); password_input_->setEchoMode(QLineEdit::Password); password_input_->setToolTip(tr("Please choose a secure password. The exact requirements " - "for password strength may depend on your server")); + "for password strength may depend on your server.")); password_confirmation_ = new TextField(); password_confirmation_->setLabel(tr("Password confirmation")); diff --git a/src/SSOHandler.cpp b/src/SSOHandler.cpp index 0ee2fc17..cacbbaa9 100644 --- a/src/SSOHandler.cpp +++ b/src/SSOHandler.cpp @@ -30,7 +30,6 @@ SSOHandler::SSOHandler(QObject *) std::thread t([this]() { this->port = svr.bind_to_any_port("localhost"); svr.listen_after_bind(); - }); t.detach(); diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp index 388a5842..99656d19 100644 --- a/src/timeline/TimelineModel.cpp +++ b/src/timeline/TimelineModel.cpp @@ -566,7 +566,7 @@ TimelineModel::updateLastMessage() room_id_, DescInfo{QString::fromStdString(mtx::accessors::event_id(event)), QString::fromStdString(http::client()->user_id().to_string()), - tr("You joined this room"), + tr("You joined this room."), utils::descriptiveTime(time), ts, time}); From 004d10bfeedb5e4278beafbd6b2f288b9b106a26 Mon Sep 17 00:00:00 2001 From: Nicolas Werner Date: Wed, 13 May 2020 01:09:40 +0200 Subject: [PATCH 08/13] Clip replies by default In the future we should probably add a gradient when clipped... --- resources/qml/delegates/ImageMessage.qml | 7 ++++--- resources/qml/delegates/MessageDelegate.qml | 2 ++ resources/qml/delegates/NoticeMessage.qml | 2 ++ resources/qml/delegates/PlayableMediaMessage.qml | 10 ++++++++-- resources/qml/delegates/Reply.qml | 1 + resources/qml/delegates/TextMessage.qml | 2 ++ 6 files changed, 19 insertions(+), 5 deletions(-) diff --git a/resources/qml/delegates/ImageMessage.qml b/resources/qml/delegates/ImageMessage.qml index c7e6d127..62d9de60 100644 --- a/resources/qml/delegates/ImageMessage.qml +++ b/resources/qml/delegates/ImageMessage.qml @@ -6,10 +6,11 @@ Item { property double tempWidth: Math.min(parent ? parent.width : undefined, model.data.width < 1 ? parent.width : model.data.width) property double tempHeight: tempWidth * model.data.proportionalHeight - property bool tooHigh: tempHeight > timelineRoot.height / 2 + property double divisor: model.isReply ? 4 : 2 + property bool tooHigh: tempHeight > timelineRoot.height / divisor - height: tooHigh ? timelineRoot.height / 2 : tempHeight - width: tooHigh ? (timelineRoot.height / 2) / model.data.proportionalHeight : tempWidth + height: tooHigh ? timelineRoot.height / divisor : tempHeight + width: tooHigh ? (timelineRoot.height / divisor) / model.data.proportionalHeight : tempWidth Image { id: blurhash diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml index ff103459..17fe7360 100644 --- a/resources/qml/delegates/MessageDelegate.qml +++ b/resources/qml/delegates/MessageDelegate.qml @@ -6,9 +6,11 @@ Item { Item { id: model property var data; + property bool isReply: false } property alias modelData: model.data + property alias isReply: model.isReply height: chooser.childrenRect.height property real implicitWidth: (chooser.child && chooser.child.implicitWidth) ? chooser.child.implicitWidth : width diff --git a/resources/qml/delegates/NoticeMessage.qml b/resources/qml/delegates/NoticeMessage.qml index 62ada6d1..be348329 100644 --- a/resources/qml/delegates/NoticeMessage.qml +++ b/resources/qml/delegates/NoticeMessage.qml @@ -1,4 +1,6 @@ TextMessage { font.italic: true color: colors.buttonText + height: isReply ? Math.min(chat.height / 8, implicitHeight) : undefined + clip: true } diff --git a/resources/qml/delegates/PlayableMediaMessage.qml b/resources/qml/delegates/PlayableMediaMessage.qml index 20177a04..bab524eb 100644 --- a/resources/qml/delegates/PlayableMediaMessage.qml +++ b/resources/qml/delegates/PlayableMediaMessage.qml @@ -20,8 +20,14 @@ Rectangle { Rectangle { id: videoContainer visible: model.data.type == MtxEvent.VideoMessage - width: Math.min(parent.width, model.data.width ? model.data.width : 400) // some media has 0 as size... - height: width*model.data.proportionalHeight + property double tempWidth: Math.min(parent ? parent.width : undefined, model.data.width < 1 ? 400 : model.data.width) + property double tempHeight: tempWidth * model.data.proportionalHeight + + property double divisor: model.isReply ? 4 : 2 + property bool tooHigh: tempHeight > timelineRoot.height / divisor + + height: tooHigh ? timelineRoot.height / divisor : tempHeight + width: tooHigh ? (timelineRoot.height / divisor) / model.data.proportionalHeight : tempWidth Image { anchors.fill: parent source: model.data.thumbnailUrl.replace("mxc://", "image://MxcImage/") diff --git a/resources/qml/delegates/Reply.qml b/resources/qml/delegates/Reply.qml index 90013de9..f9fd3f11 100644 --- a/resources/qml/delegates/Reply.qml +++ b/resources/qml/delegates/Reply.qml @@ -51,6 +51,7 @@ Item { MessageDelegate { id: reply width: parent.width + isReply: true } } diff --git a/resources/qml/delegates/TextMessage.qml b/resources/qml/delegates/TextMessage.qml index 7e4b1f29..bef4f76d 100644 --- a/resources/qml/delegates/TextMessage.qml +++ b/resources/qml/delegates/TextMessage.qml @@ -4,4 +4,6 @@ MatrixText { property string formatted: model.data.formattedBody text: "" + formatted.replace("
", "
")
 	width: parent ? parent.width : undefined
+	height: isReply ? Math.min(chat.height / 8, implicitHeight) : undefined
+	clip: true
 }

From d6981355d37db3ec3fda9a5a911cda1c82ab6cca Mon Sep 17 00:00:00 2001
From: Nicolas Werner 
Date: Wed, 13 May 2020 23:32:39 +0200
Subject: [PATCH 09/13] Align scrolling to pixels manually

---
 resources/qml/ScrollHelper.qml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/resources/qml/ScrollHelper.qml b/resources/qml/ScrollHelper.qml
index 3a8868f5..cdb4a23a 100644
--- a/resources/qml/ScrollHelper.qml
+++ b/resources/qml/ScrollHelper.qml
@@ -71,6 +71,8 @@ MouseArea {
             pixelDelta = wheel.pixelDelta.y
         }
 
+	pixelDelta = Math.round(pixelDelta)
+
         if (!pixelDelta) {
             return flickableItem.contentY;
         }

From 2c3d09edbb3236e8f3c8f41f23420615906bb158 Mon Sep 17 00:00:00 2001
From: Nicolas Werner 
Date: Wed, 13 May 2020 23:55:02 +0200
Subject: [PATCH 10/13] Try to smooth scrolling a bit by increasing cacheBuffer

---
 resources/qml/TimelineView.qml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index eca646d1..15cafd8c 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -109,6 +109,8 @@ Page {
 
 			visible: timelineManager.timeline != null
 
+			cacheBuffer: 500
+
 			anchors.left: parent.left
 			anchors.right: parent.right
 			anchors.top: parent.top

From 279bcd1bf2a052330a51637d8867ae525a3c20a0 Mon Sep 17 00:00:00 2001
From: Nicolas Werner 
Date: Thu, 14 May 2020 00:41:10 +0200
Subject: [PATCH 11/13] Show inline images

(This is such a hack and will probably break, but it works for now for
most cases...)
---
 src/timeline/TimelineModel.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 99656d19..b7e90034 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -294,6 +294,10 @@ TimelineModel::data(const QString &id, int role) const
                         if (isReply)
                                 formattedBody_ = formattedBody_.remove(replyFallback);
                 }
+
+                formattedBody_.replace("
Date: Fri, 15 May 2020 00:38:09 +0200
Subject: [PATCH 12/13] Use standard cmake args instead of old -H

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 94c37253..0cb3e044 100644
--- a/README.md
+++ b/README.md
@@ -229,14 +229,14 @@ Make sure to install the `MSVC 2017 64-bit` toolset for at least Qt 5.10
 We can now build nheko:
 
 ```bash
-cmake -H. -Bbuild -DCMAKE_BUILD_TYPE=Release
+cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release
 cmake --build build
 ```
 
 To use bundled dependencies you can use hunter, i.e.:
 
 ```bash
-cmake -H. -Bbuild -DHUNTER_ENABLED=ON -DBUILD_SHARED_LIBS=OFF -DUSE_BUNDLED_OPENSSL=OFF
+cmake -S. -Bbuild -DHUNTER_ENABLED=ON -DBUILD_SHARED_LIBS=OFF -DUSE_BUNDLED_OPENSSL=OFF
 cmake --build build --config Release
 ```
 
@@ -255,7 +255,7 @@ You might need to pass `-DCMAKE_PREFIX_PATH` to cmake to point it at your qt5 in
 e.g on macOS
 
 ```
-cmake -H. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=$(brew --prefix qt5)
+cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=$(brew --prefix qt5)
 cmake --build build
 ```
 

From 18f934efad19821bb2932ba687b2f3c42735add2 Mon Sep 17 00:00:00 2001
From: Joseph Donofry 
Date: Thu, 14 May 2020 20:35:29 -0400
Subject: [PATCH 13/13] Add un-encrypted warning icon for messages in encrypted
 rooms

---
 resources/icons/ui/unlock.png         | Bin 0 -> 385 bytes
 resources/icons/ui/unlock@2x.png      | Bin 0 -> 741 bytes
 resources/langs/nheko_de.ts           |  15 ++++++++++-----
 resources/langs/nheko_el.ts           |  15 ++++++++++-----
 resources/langs/nheko_en.ts           |  15 ++++++++++-----
 resources/langs/nheko_fi.ts           |  15 ++++++++++-----
 resources/langs/nheko_fr.ts           |  15 ++++++++++-----
 resources/langs/nheko_ja.ts           |  15 ++++++++++-----
 resources/langs/nheko_nl.ts           |  15 ++++++++++-----
 resources/langs/nheko_pl.ts           |  15 ++++++++++-----
 resources/langs/nheko_ru.ts           |  15 ++++++++++-----
 resources/langs/nheko_zh_CN.ts        |  15 ++++++++++-----
 resources/qml/EncryptionIndicator.qml |  19 +++++++++++++++++--
 resources/qml/TimelineRow.qml         |   3 ++-
 resources/res.qrc                     |   2 ++
 src/timeline/TimelineModel.cpp        |   5 +++++
 src/timeline/TimelineModel.h          |   1 +
 17 files changed, 127 insertions(+), 53 deletions(-)
 create mode 100644 resources/icons/ui/unlock.png
 create mode 100644 resources/icons/ui/unlock@2x.png

diff --git a/resources/icons/ui/unlock.png b/resources/icons/ui/unlock.png
new file mode 100644
index 0000000000000000000000000000000000000000..90e4602ad885027a149068503c6a088790856cd1
GIT binary patch
literal 385
zcmV-{0e=38P)4B=R
zkd(vChl(c@JdrJ+FX8gG;yDmJ-z`f(
ziSTWkyElA6eHOd&K$-%eLpmj6cAv76ihs`}%k@{Eh4(et!8#+qN=ym>_ZdWzJ;&6n
zOx5@>RP$FY%q4fF(s9tprf!rxkR}hL$pdNfK$;o}6z?&gy2J;-;~qeAZI!D-x~D|A
fTRTh(+J=4r_P*gJYff0x00000NkvXXu0mjfa$1|{

literal 0
HcmV?d00001

diff --git a/resources/icons/ui/unlock@2x.png b/resources/icons/ui/unlock@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..8df18143680089562e4ed06499c99c2d8ef3cbc6
GIT binary patch
literal 741
zcmeAS@N?(olHy`uVBq!ia0vp^9zg8C!3HFE?laT^Qfx`y?k)`fL2$v|<&zm0m}Ysp
zIEGZrc{}H9mPnw0oB#GnjJx3KyN~hQ~>|UVc#3HYtEzYIX+2OzN{K7>)xc(`y
z__R12SyxMwV_e|gIcugh)TXxU95Q_c)Dm-3k$ow1jhfvB
z?+0uJY!)561#F(yf6Hm8tG&OxFh*VPg!_Xehx?lKIX>^Ly=I0~I#)EfKJajPZDzg87=#Gao*wWjuL8`#zjzeKx0m#^n{4-!LY2&kLXN)u!Ou
z=x%JQB7q;Cq+(Sn1u)vNLB@d%2$0ufP8(
zd;aIh5J~oX&v@jwMSYw3>4(sTYYLA)ttTsebcY}
zKK{BY?i|OFyX%##(!pHOmDP(I%XA-?r)L=4GxAiFUa?5>
u;M?Vq2j2czVV#nb`{>{P<2qgM=h*)#h)&Cn5dH*Aw+x=HelF{r5}E+;u0(MF

literal 0
HcmV?d00001

diff --git a/resources/langs/nheko_de.ts b/resources/langs/nheko_de.ts
index fcbf8b31..2b5a5393 100644
--- a/resources/langs/nheko_de.ts
+++ b/resources/langs/nheko_de.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         Verschlüsselt
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -310,7 +315,7 @@ Beispiel: https://mein.server:8787
 
     MessageDelegate
     
-        
+        
         redacted
         gelöscht
     
@@ -548,7 +553,7 @@ Beispiel: https://mein.server:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         -- Entschlüsselungsfehler (Fehler bei Kommunikation mit Datenbank) --
@@ -746,7 +751,7 @@ Beispiel: https://mein.server:8787
 
     TimelineRow
     
-        
+        
         Reply
         Antworten
     
@@ -799,7 +804,7 @@ Beispiel: https://mein.server:8787
         Kein Raum geöffnet
     
     
-        
+        
         Close
         Schließen
     
diff --git a/resources/langs/nheko_el.ts b/resources/langs/nheko_el.ts
index 39ed1442..a6e4ff7d 100644
--- a/resources/langs/nheko_el.ts
+++ b/resources/langs/nheko_el.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -742,7 +747,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -795,7 +800,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         
     
diff --git a/resources/langs/nheko_en.ts b/resources/langs/nheko_en.ts
index e7631462..1fd9b86c 100644
--- a/resources/langs/nheko_en.ts
+++ b/resources/langs/nheko_en.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         Encrypted
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -310,7 +315,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         redacted
     
@@ -548,7 +553,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         -- Decryption Error (failed to communicate with DB) --
@@ -746,7 +751,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         Reply
     
@@ -799,7 +804,7 @@ Example: https://server.my:8787
         No room open
     
     
-        
+        
         Close
         Close
     
diff --git a/resources/langs/nheko_fi.ts b/resources/langs/nheko_fi.ts
index 01b9d75d..069fb6b2 100644
--- a/resources/langs/nheko_fi.ts
+++ b/resources/langs/nheko_fi.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         -- Virhe purkaessa salausta (tietokannan kanssa kommunikointi epäonnistui) --
@@ -742,7 +747,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -795,7 +800,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         Sulje
     
diff --git a/resources/langs/nheko_fr.ts b/resources/langs/nheko_fr.ts
index 9e47702b..d50b5fb8 100644
--- a/resources/langs/nheko_fr.ts
+++ b/resources/langs/nheko_fr.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -742,7 +747,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -795,7 +800,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         
     
diff --git a/resources/langs/nheko_ja.ts b/resources/langs/nheko_ja.ts
index 049c4189..63522065 100644
--- a/resources/langs/nheko_ja.ts
+++ b/resources/langs/nheko_ja.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         暗号化されています
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         編集済み
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         -- 復号エラー (データベースと通信できませんでした) --
@@ -741,7 +746,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         返信
     
@@ -794,7 +799,7 @@ Example: https://server.my:8787
         部屋が開いていません
     
     
-        
+        
         Close
         閉じる
     
diff --git a/resources/langs/nheko_nl.ts b/resources/langs/nheko_nl.ts
index 205de986..2c3eeee3 100644
--- a/resources/langs/nheko_nl.ts
+++ b/resources/langs/nheko_nl.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -742,7 +747,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -795,7 +800,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         
     
diff --git a/resources/langs/nheko_pl.ts b/resources/langs/nheko_pl.ts
index c089a5b4..f68ca8b3 100644
--- a/resources/langs/nheko_pl.ts
+++ b/resources/langs/nheko_pl.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -743,7 +748,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -796,7 +801,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         
     
diff --git a/resources/langs/nheko_ru.ts b/resources/langs/nheko_ru.ts
index 761110f0..95f75081 100644
--- a/resources/langs/nheko_ru.ts
+++ b/resources/langs/nheko_ru.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -743,7 +748,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -796,7 +801,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         Закрыть
     
diff --git a/resources/langs/nheko_zh_CN.ts b/resources/langs/nheko_zh_CN.ts
index 5b080b74..6b6c0646 100644
--- a/resources/langs/nheko_zh_CN.ts
+++ b/resources/langs/nheko_zh_CN.ts
@@ -189,10 +189,15 @@
 
     EncryptionIndicator
     
-        
+        
         Encrypted
         
     
+    
+        
+        This message is not encrypted!
+        
+    
 
 
     InviteeItem
@@ -306,7 +311,7 @@ Example: https://server.my:8787
 
     MessageDelegate
     
-        
+        
         redacted
         
     
@@ -544,7 +549,7 @@ Example: https://server.my:8787
 
     TimelineModel
     
-        
+        
         -- Decryption Error (failed to communicate with DB) --
         Placeholder, when the message can't be decrypted, because the DB access failed when trying to lookup the session.
         
@@ -741,7 +746,7 @@ Example: https://server.my:8787
 
     TimelineRow
     
-        
+        
         Reply
         
     
@@ -794,7 +799,7 @@ Example: https://server.my:8787
         
     
     
-        
+        
         Close
         
     
diff --git a/resources/qml/EncryptionIndicator.qml b/resources/qml/EncryptionIndicator.qml
index 00fe2ee4..428c2fae 100644
--- a/resources/qml/EncryptionIndicator.qml
+++ b/resources/qml/EncryptionIndicator.qml
@@ -3,13 +3,14 @@ import QtQuick.Controls 2.1
 import im.nheko 1.0
 
 Rectangle {
+	property bool encrypted: false
 	id: indicator
 	color: "transparent"
 	width: 16
 	height: 16
 
 	ToolTip.visible: ma.containsMouse && indicator.visible
-	ToolTip.text: qsTr("Encrypted")
+	ToolTip.text: getEncryptionTooltip()
 
 	MouseArea{
 		id: ma
@@ -20,7 +21,21 @@ Rectangle {
 	Image {
 		id: stateImg
 		anchors.fill: parent
-		source: "image://colorimage/:/icons/icons/ui/lock.png?"+colors.buttonText
+		source: getEncryptionImage()
+	}
+
+	function getEncryptionImage() {
+		if (encrypted)
+			return "image://colorimage/:/icons/icons/ui/lock.png?"+colors.buttonText
+		else
+			return "image://colorimage/:/icons/icons/ui/unlock.png?#dd3d3d"
+	}
+
+	function getEncryptionTooltip() {
+		if (encrypted)
+			return qsTr("Encrypted")
+		else
+			return qsTr("This message is not encrypted!")
 	}
 }
 
diff --git a/resources/qml/TimelineRow.qml b/resources/qml/TimelineRow.qml
index 22222ef3..8dcd0056 100644
--- a/resources/qml/TimelineRow.qml
+++ b/resources/qml/TimelineRow.qml
@@ -66,7 +66,8 @@ MouseArea {
 		}
 
 		EncryptionIndicator {
-			visible: model.isEncrypted
+			visible: model.isRoomEncrypted
+			encrypted: model.isEncrypted
 			Layout.alignment: Qt.AlignRight | Qt.AlignTop
 			Layout.preferredHeight: 16
 			width: 16
diff --git a/resources/res.qrc b/resources/res.qrc
index 64a5b3cb..a57d0416 100644
--- a/resources/res.qrc
+++ b/resources/res.qrc
@@ -14,6 +14,8 @@
         icons/ui/double-tick-indicator@2x.png
         icons/ui/lock.png
         icons/ui/lock@2x.png
+        icons/ui/unlock.png
+        icons/ui/unlock@2x.png
         icons/ui/clock.png
         icons/ui/clock@2x.png
         icons/ui/checkmark.png
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index b7e90034..6e653f10 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -224,6 +224,7 @@ TimelineModel::roleNames() const
           {Id, "id"},
           {State, "state"},
           {IsEncrypted, "isEncrypted"},
+          {IsRoomEncrypted, "isRoomEncrypted"},
           {ReplyTo, "replyTo"},
           {Reactions, "reactions"},
           {RoomId, "roomId"},
@@ -350,6 +351,9 @@ TimelineModel::data(const QString &id, int role) const
                 return std::holds_alternative<
                   mtx::events::EncryptedEvent>(events[id]);
         }
+        case IsRoomEncrypted: {
+                return cache::isRoomEncrypted(room_id_.toStdString());
+        }
         case ReplyTo:
                 return QVariant(QString::fromStdString(in_reply_to_event(event)));
         case Reactions:
@@ -387,6 +391,7 @@ TimelineModel::data(const QString &id, int role) const
                 m.insert(names[Id], data(id, static_cast(Id)));
                 m.insert(names[State], data(id, static_cast(State)));
                 m.insert(names[IsEncrypted], data(id, static_cast(IsEncrypted)));
+                m.insert(names[IsRoomEncrypted], data(id, static_cast(IsRoomEncrypted)));
                 m.insert(names[ReplyTo], data(id, static_cast(ReplyTo)));
                 m.insert(names[RoomName], data(id, static_cast(RoomName)));
                 m.insert(names[RoomTopic], data(id, static_cast(RoomTopic)));
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index a737aac7..0e9ddb72 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -157,6 +157,7 @@ public:
                 Id,
                 State,
                 IsEncrypted,
+                IsRoomEncrypted,
                 ReplyTo,
                 Reactions,
                 RoomId,