hard refactor and review

openrouter/src/OpenRouter/OpenRouter.cpp

@@ -5,56 +5,60 @@
 #include <syslog.h>
 #include "../security/cors.hpp"
 
-OpenRouter::OpenRouter() {
-    this->srv.Post("/api/settings/telnet/get", settings::get_telnet);
-    this->srv.Post("/api/settings/telnet/set", settings::set_telnet);
-    this->srv.Post("/api/settings/telnet/port/get", settings::get_telnet_port);
-    this->srv.Post("/api/settings/telnet/port/set", settings::set_telnet_port);
+OpenRouter::OpenRouter()
+{
+    this->srv.Post("/api/settings/telnet/get", api::settings::get_telnet);
+    this->srv.Post("/api/settings/telnet/set", api::settings::set_telnet);
+    this->srv.Post("/api/settings/telnet/port/get", api::settings::get_telnet_port);
+    this->srv.Post("/api/settings/telnet/port/set", api::settings::set_telnet_port);
 
-    this->srv.Post("/api/settings/ssh/status/get", settings::get_ssh_status);
-    this->srv.Post("/api/settings/ssh/status/set", settings::set_ssh_status);
-    this->srv.Post("/api/settings/ssh/keys/get", settings::get_ssh_keys);
-    this->srv.Post("/api/settings/ssh/keys/set", settings::set_ssh_keys);
-    this->srv.Post("/api/settings/ssh/port/get", settings::get_ssh_port);
-    this->srv.Post("/api/settings/ssh/port/set", settings::set_ssh_port);
+    this->srv.Post("/api/settings/ssh/status/get", api::settings::get_ssh_status);
+    this->srv.Post("/api/settings/ssh/status/set", api::settings::set_ssh_status);
+    this->srv.Post("/api/settings/ssh/keys/get", api::settings::get_ssh_keys);
+    this->srv.Post("/api/settings/ssh/keys/set", api::settings::set_ssh_keys);
+    this->srv.Post("/api/settings/ssh/port/get", api::settings::get_ssh_port);
+    this->srv.Post("/api/settings/ssh/port/set", api::settings::set_ssh_port);
 
-    this->srv.Post("/api/settings/dns/get", settings::get_dns);
-    this->srv.Post("/api/settings/dns/set", settings::set_dns);
-    this->srv.Post("/api/settings/dns/servers/get", settings::get_dns_servers);
-    this->srv.Post("/api/settings/dns/servers/set", settings::set_dns_servers);
-    this->srv.Post("/api/settings/dns/domains/get", settings::get_local_domains);
-    this->srv.Post("/api/settings/dns/domains/set", settings::set_local_domains);
+    this->srv.Post("/api/settings/dns/get", api::settings::get_dns);
+    this->srv.Post("/api/settings/dns/set", api::settings::set_dns);
+    this->srv.Post("/api/settings/dns/servers/get", api::settings::get_dns_servers);
+    this->srv.Post("/api/settings/dns/servers/set", api::settings::set_dns_servers);
+    this->srv.Post("/api/settings/dns/domains/get", api::settings::get_local_domains);
+    this->srv.Post("/api/settings/dns/domains/set", api::settings::set_local_domains);
 
-    this->srv.Post("/api/settings/ftp/get", settings::get_ftp);
-    this->srv.Post("/api/settings/ftp/set", settings::set_ftp);
+    this->srv.Post("/api/settings/ftp/get", api::settings::get_ftp);
+    this->srv.Post("/api/settings/ftp/set", api::settings::set_ftp);
 
-    this->srv.Post("/api/settings/wifi/status/get", settings::get_wifi_status);
-    this->srv.Post("/api/settings/wifi/status/set", settings::set_wifi_status);
-    this->srv.Post("/api/settings/wifi/name/get", settings::get_wifi_name);
-    this->srv.Post("/api/settings/wifi/name/set", settings::set_wifi_name);
-    this->srv.Post("/api/settings/wifi/password/get", settings::get_wifi_password);
-    this->srv.Post("/api/settings/wifi/password/set", settings::set_wifi_password);
-    this->srv.Post("/api/settings/wifi/qr/get", settings::get_wifi_qr);
-    this->srv.Post("/api/settings/wifi/channel/get", settings::get_wifi_channel);
-    this->srv.Post("/api/settings/wifi/channel/set", settings::set_wifi_channel);
+    this->srv.Post("/api/settings/wifi/status/get", api::settings::get_wifi_status);
+    this->srv.Post("/api/settings/wifi/status/set", api::settings::set_wifi_status);
+    this->srv.Post("/api/settings/wifi/name/get", api::settings::get_wifi_name);
+    this->srv.Post("/api/settings/wifi/name/set", api::settings::set_wifi_name);
+    this->srv.Post("/api/settings/wifi/password/get", api::settings::get_wifi_password);
+    this->srv.Post("/api/settings/wifi/password/set", api::settings::set_wifi_password);
+    this->srv.Post("/api/settings/wifi/qr/get", api::settings::get_wifi_qr);
+    this->srv.Post("/api/settings/wifi/channel/get", api::settings::get_wifi_channel);
+    this->srv.Post("/api/settings/wifi/channel/set", api::settings::set_wifi_channel);
 
-    this->srv.Post("/api/reboot", systemfuncs::reboot);
+    this->srv.Post("/api/reboot", api::system::reboot);
 
-    this->srv.Get("/api/syslog", systemfuncs::get_syslog);
-    this->srv.Get("/api/uptime", systemfuncs::get_uptime);
+    this->srv.Get("/api/syslog", api::system::get_syslog);
+#ifdef __linux__
+    this->srv.Get("/api/uptime", api::system::get_uptime);
+#endif // __linux__
 
-    this->srv.Options("/(.*)", set_cors_headers);
+    this->srv.Options("/(.*)", api::security::set_cors_headers);
 
-    this->srv.set_mount_point("/" , "../src/web");
+    this->srv.set_mount_point("/", "../src/web");
     this->srv.set_mount_point("/js", "../src/web/js");
     this->srv.set_mount_point("/css", "../src/web/css");
 }
 
 OpenRouter::~OpenRouter() = default;
 
-int OpenRouter::serve(const std::string &ip, int port, int socket_flags) {
+int OpenRouter::serve(const std::string &ip, int port, int socket_flags)
+{
     std::cout << GREEN << "Starting" << RESET << " server on [ " << YELLOW
-            << "0.0.0.0" << RESET << ":" << CYAN << "43244" << RESET << " ]" << std::endl;
+              << "0.0.0.0" << RESET << ":" << CYAN << "43244" << RESET << " ]" << std::endl;
 
     syslog(LOG_INFO, "openrouter administration software started.");
     this->srv.listen(ip, port, socket_flags);

openrouter/src/OpenRouter/OpenRouter.hpp

@@ -6,14 +6,15 @@
 
 #define CORS_ENABLE
 
-class OpenRouter {
-    private:
-        httplib::Server srv;
+class OpenRouter
+{
+private:
+    httplib::Server srv;
 
-    public:
-        OpenRouter();
-        ~OpenRouter();
-        int serve(const std::string &ip, int port, int socket_flags = 0);
+public:
+    OpenRouter();
+    ~OpenRouter();
+    int serve(const std::string &ip, int port, int socket_flags = 0);
 };
 
 #endif // OPENROUTER_HPP

openrouter/src/auth/auth.cpp

@@ -5,15 +5,18 @@
 #include <json.hpp>
 #include "../types.hpp"
 
-bool authenticate(const std::string &token) {
+bool authenticate(const std::string &token)
+{
     httplib::Client cli(AUTH_SERVICE);
 
     std::stringstream body;
-    body <<  R"({"token":")" << token << R"("})";
+    body << R"({"token":")" << token << R"("})";
     httplib::Result res = cli.Post("/api/access", body.str(), JSON_TYPE);
-    if (res->status == httplib::OK_200) {
+    if (res->status == httplib::OK_200)
+    {
         nlohmann::json resjson = nlohmann::json::parse(res->body);
-        if (resjson["access"] == "reject") {
+        if (resjson["access"] == "reject")
+        {
             return false;
         }
         return true;

openrouter/src/helpers.hpp

@@ -1,6 +1,17 @@
 #ifndef HELPERS_HPP
 #define HELPERS_HPP
 
+#include <httplib.h>
+#include <json.hpp>
 
+static bool check_body(const httplib::Request &request)
+{
+    if (request.body.empty())
+        return false;
+    nlohmann::json json_body = nlohmann::json::parse(request.body);
+    if (json_body["token"] == nullptr)
+        return false;
+    return true;
+}
 
 #endif // HELPERS_HPP

openrouter/src/openrouter.cpp

@@ -1,6 +1,7 @@
 #include "OpenRouter/OpenRouter.hpp"
 
-int main() {
+int main()
+{
     OpenRouter router;
     return router.serve("127.0.0.1", 43244);
 }

openrouter/src/security/cors.cpp

@@ -1,9 +1,16 @@
 #include "cors.hpp"
 #include <colors.h>
 
-void set_cors_headers(const httplib::Request &request, httplib::Response &response) {
-    std::cout << GREEN << request.path << "  " << std::endl;
-    response.set_header("Access-Control-Allow-Origin", "*");
-    response.set_header("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
-    response.set_header("Access-Control-Allow-Headers", "Authorization,X-Custom,Content-Type");
+namespace api
+{
+    namespace security
+    {
+        void set_cors_headers(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << "  " << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            response.set_header("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+            response.set_header("Access-Control-Allow-Headers", "Authorization,X-Custom,Content-Type");
+        }
+    }
 }

openrouter/src/security/cors.hpp

@@ -5,8 +5,14 @@
 
 #ifdef CORS_ENABLE
 
-// function to set cors headers
-void set_cors_headers(const httplib::Request& request, httplib::Response& response);
+namespace api
+{
+    namespace security
+    {
+        // function to set cors headers
+        void set_cors_headers(const httplib::Request &request, httplib::Response &response);
+    }
+}
 
 #endif // CORS_ENABLE
 

openrouter/src/settings/dns/dns.hpp

@@ -3,15 +3,19 @@
 
 #include <httplib.h>
 
-namespace settings {
-    void get_dns(const httplib::Request &request, httplib::Response &response);
-    void set_dns(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace settings
+    {
+        void get_dns(const httplib::Request &request, httplib::Response &response);
+        void set_dns(const httplib::Request &request, httplib::Response &response);
 
-    void get_dns_servers(const httplib::Request &request, httplib::Response &response);
-    void set_dns_servers(const httplib::Request &request, httplib::Response &response);
+        void get_dns_servers(const httplib::Request &request, httplib::Response &response);
+        void set_dns_servers(const httplib::Request &request, httplib::Response &response);
 
-    void get_local_domains(const httplib::Request &request, httplib::Response &response);
-    void set_local_domains(const httplib::Request &request, httplib::Response &response);
+        void get_local_domains(const httplib::Request &request, httplib::Response &response);
+        void set_local_domains(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // DNS_HPP

openrouter/src/settings/dns/enabled.cpp

@@ -4,25 +4,30 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define DNS_REQUIRED_STRING R"({"required":"[token,enabled]"})"
 
-namespace settings {
-    void get_dns(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_dns(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream dnsfile("/etc/openrouter/dns");
             int dns_enabled;
             dnsfile >> dns_enabled;
@@ -30,38 +35,40 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << dns_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_dns(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_dns(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["enabled"] == nullptr) {
-            response.set_content(DNS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["enabled"] == nullptr)
+            {
+                response.set_content(DNS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream dnsfileout("/etc/openrouter/dns");
             std::string new_dns_enabled = json_body["enabled"];
-            if (new_dns_enabled == "0") {
+            if (new_dns_enabled == "0")
+            {
                 system("rc stop dnsmasq");
                 system("rc del dnsmasq");
                 syslog(LOG_INFO, "%s", "DNS is disabled");
-            } else {
+            }
+            else
+            {
                 system("rc restart dnsmasq");
                 system("rc add dnsmasq");
                 syslog(LOG_INFO, "%s", "DNS is enabled");
@@ -75,8 +82,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << dns_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/dns/local_domains.cpp

@@ -4,33 +4,40 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
-namespace settings {
-    void get_local_domains(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_local_domains(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream domainsfile("/etc/dnsmasq.conf.d/hosts");
             std::stringstream responsedata;
             responsedata << R"({"domains":[)";
             std::string ip_string = "";
             std::string domain_string = "";
             int iter = 0;
-            while (!domainsfile.eof()) {
+            while (!domainsfile.eof())
+            {
                 domainsfile >> ip_string;
                 domainsfile >> domain_string;
-                if (domain_string.empty()) {
+                if (domain_string.empty())
+                {
                     continue;
                 }
                 responsedata << R"({"ip":")" << ip_string << R"(","domain":")" << domain_string << R"("},)";
@@ -38,36 +45,38 @@ namespace settings {
                 domain_string = "";
                 iter++;
             }
-            if (iter != 0) {
-                responsedata.str(responsedata.str().erase(responsedata.str().size()-1, 1) + "]}");
-            } else {
+            if (iter != 0)
+            {
+                responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}");
+            }
+            else
+            {
                 responsedata << "]}";
             }
             domainsfile.close();
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_local_domains(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_local_domains(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream domainsfile("/etc/dnsmasq.conf.d/hosts");
             nlohmann::json domains = json_body["domains"];
-            for (nlohmann::json_abi_v3_11_3::json domain : domains) {
+            for (nlohmann::json_abi_v3_11_3::json domain : domains)
+            {
                 std::string ip = domain["ip"];
                 std::string dom = domain["domain"];
                 domainsfile << ip << " " << dom << "\n";
@@ -77,8 +86,6 @@ namespace settings {
             syslog(LOG_INFO, "%s", "DNS local domains changed");
             std::string responsedata = R"({"success":"true"})";
             response.set_content(responsedata, JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/dns/servers.cpp

@@ -4,66 +4,75 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
-namespace settings {
-    void get_dns_servers(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_dns_servers(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream dnsserversfile("/etc/dnsmasq.conf.d/resolv.conf");
             std::stringstream responsedata;
             responsedata << R"({"servers":[)";
             std::string dns_server_string = "";
             int iter = 0;
-            while (std::getline(dnsserversfile, dns_server_string)) {
+            while (std::getline(dnsserversfile, dns_server_string))
+            {
                 dns_server_string.erase(0, 11);
                 responsedata << "\"" << dns_server_string << R"(",)";
                 dns_server_string = "";
                 iter++;
             }
-            if (iter != 0) {
-                responsedata.str(responsedata.str().erase(responsedata.str().size()-1, 1) + "]}");
-            } else {
+            if (iter != 0)
+            {
+                responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}");
+            }
+            else
+            {
                 responsedata << "]}";
             }
             dnsserversfile.close();
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_dns_servers(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_dns_servers(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream dnsserversfile("/etc/dnsmasq.conf.d/resolv.conf");
             nlohmann::json servers = json_body["servers"];
-            for (const nlohmann::json_abi_v3_11_3::json &server : servers) {
+            for (const nlohmann::json_abi_v3_11_3::json &server : servers)
+            {
                 std::string srv = server;
-                if (server == "") {
+                if (server == "")
+                {
                     continue;
                 }
                 dnsserversfile << "nameserver " << srv << "\n";
@@ -73,8 +82,6 @@ namespace settings {
             syslog(LOG_INFO, "%s", "DNS servers changed");
             std::string responsedata = R"({"success":"true"})";
             response.set_content(responsedata, JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/ftp/ftp.cpp

@@ -4,25 +4,30 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define FTP_REQUIRED_STRING R"({"required":"[token,enabled]"})"
 
-namespace settings {
-    void get_ftp(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_ftp(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream ftpfile("/etc/openrouter/ftp");
             int ftp_enabled;
             ftpfile >> ftp_enabled;
@@ -30,38 +35,40 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << ftp_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_ftp(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_ftp(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["enabled"] == nullptr) {
-            response.set_content(FTP_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["enabled"] == nullptr)
+            {
+                response.set_content(FTP_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream ftpfileout("/etc/openrouter/ftp");
             std::string new_ftp_enabled = json_body["enabled"];
-            if (new_ftp_enabled == "0") {
+            if (new_ftp_enabled == "0")
+            {
                 system("rc stop ftp");
                 system("rc del ftp");
                 syslog(LOG_INFO, "%s", "Ftp is disabled");
-            } else {
+            }
+            else
+            {
                 system("rc start ftp");
                 system("rc add ftp");
                 syslog(LOG_INFO, "%s", "Ftp is enabled");
@@ -75,8 +82,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << ftp_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/ftp/ftp.hpp

@@ -3,9 +3,13 @@
 
 #include <httplib.h>
 
-namespace settings {
-    void get_ftp(const httplib::Request &request, httplib::Response &response);
-    void set_ftp(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace settings
+    {
+        void get_ftp(const httplib::Request &request, httplib::Response &response);
+        void set_ftp(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // FTP_HPP

openrouter/src/settings/ssh/keys.cpp

@@ -4,68 +4,77 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define KEYS_PATH "/root/.ssh/authorized_keys"
 
-namespace settings {
-    void get_ssh_keys(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_ssh_keys(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream keysfile(KEYS_PATH);
             std::stringstream responsedata;
             responsedata << R"({"keys":[)";
             std::string key_string = "";
             int iter = 0;
-            while (std::getline(keysfile, key_string)) {
-                if (key_string.empty()) {
+            while (std::getline(keysfile, key_string))
+            {
+                if (key_string.empty())
+                {
                     continue;
                 }
                 responsedata << R"(")" << key_string << R"(",)";
                 key_string = "";
                 iter++;
             }
-            if (iter != 0) {
-                responsedata.str(responsedata.str().erase(responsedata.str().size()-1, 1) + "]}");
-            } else {
+            if (iter != 0)
+            {
+                responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}");
+            }
+            else
+            {
                 responsedata << "]}";
             }
             keysfile.close();
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_ssh_keys(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_ssh_keys(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream keysfile(KEYS_PATH);
             nlohmann::json keys = json_body["keys"];
-            for (std::string key : keys) {
+            for (std::string key : keys)
+            {
                 keysfile << key << "\n";
             }
             keysfile.close();
@@ -73,8 +82,6 @@ namespace settings {
             syslog(LOG_INFO, "%s", "SSH keys changed");
             std::string responsedata = R"({"success":"true"})";
             response.set_content(responsedata, JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/ssh/port.cpp

@@ -8,26 +8,31 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define SSH_PORT_REQUIRED_STRING R"({"required":"[token,port]"})"
 #define SSH_PORT_PATH "/etc/openrouter/ssh/port"
 
-namespace settings {
-    void get_ssh_port(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_ssh_port(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream sshportfile(SSH_PORT_PATH);
             int ssh_port;
             sshportfile >> ssh_port;
@@ -35,31 +40,30 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"port":")" << ssh_port << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_ssh_port(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_ssh_port(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["port"] == nullptr) {
-            response.set_content(SSH_PORT_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["port"] == nullptr)
+            {
+                response.set_content(SSH_PORT_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream oldsshportfile(SSH_PORT_PATH);
             int old_ssh_port;
             oldsshportfile >> old_ssh_port;
@@ -82,8 +86,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"port":")" << ssh_port << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/ssh/ssh.hpp

@@ -3,15 +3,19 @@
 
 #include <httplib.h>
 
-namespace settings {
-    void get_ssh_status(const httplib::Request &request, httplib::Response &response);
-    void set_ssh_status(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace settings
+    {
+        void get_ssh_status(const httplib::Request &request, httplib::Response &response);
+        void set_ssh_status(const httplib::Request &request, httplib::Response &response);
 
-    void get_ssh_keys(const httplib::Request &request, httplib::Response &response);
-    void set_ssh_keys(const httplib::Request &request, httplib::Response &response);
+        void get_ssh_keys(const httplib::Request &request, httplib::Response &response);
+        void set_ssh_keys(const httplib::Request &request, httplib::Response &response);
 
-    void get_ssh_port(const httplib::Request &request, httplib::Response &response);
-    void set_ssh_port(const httplib::Request &request, httplib::Response &response);
+        void get_ssh_port(const httplib::Request &request, httplib::Response &response);
+        void set_ssh_port(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // SSH_HPP

openrouter/src/settings/ssh/status.cpp

@@ -4,25 +4,30 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define SSH_REQUIRED_STRING R"({"required":"[token,status]"})"
 
-namespace settings {
-    void get_ssh_status(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_ssh_status(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream sshstatusfile("/etc/openrouter/ssh/status");
             int ssh_status;
             sshstatusfile >> ssh_status;
@@ -30,38 +35,40 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"status":")" << ssh_status << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_ssh_status(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_ssh_status(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["status"] == nullptr) {
-            response.set_content(SSH_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["status"] == nullptr)
+            {
+                response.set_content(SSH_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream sshfileout("/etc/openrouter/ssh/status");
             std::string new_ssh_status = json_body["status"];
-            if (new_ssh_status == "0") {
+            if (new_ssh_status == "0")
+            {
                 system("rc stop ssh");
                 system("rc del ssh");
                 syslog(LOG_INFO, "%s", "SSH is disabled");
-            } else {
+            }
+            else
+            {
                 system("rc start ssh");
                 system("rc add ssh");
                 syslog(LOG_INFO, "%s", "SSH is enabled");
@@ -75,8 +82,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"status":")" << ssh_status << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/telnet/enabled.cpp

@@ -8,25 +8,30 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define TELNET_REQUIRED_STRING R"({"required":"[token,enabled]"})"
 
-namespace settings {
-    void get_telnet(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_telnet(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream telnetfile("/etc/openrouter/telnet/enabled");
             int telnet_enabled;
             telnetfile >> telnet_enabled;
@@ -34,38 +39,40 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << telnet_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_telnet(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_telnet(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["enabled"] == nullptr) {
-            response.set_content(TELNET_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["enabled"] == nullptr)
+            {
+                response.set_content(TELNET_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream telnetfileout("/etc/openrouter/telnet/enabled");
             std::string new_telnet_enabled = json_body["enabled"];
-            if (new_telnet_enabled == "0") {
+            if (new_telnet_enabled == "0")
+            {
                 system("rc stop telnet");
                 system("rc del telnet");
                 syslog(LOG_INFO, "%s", "Telnet is disabled");
-            } else {
+            }
+            else
+            {
                 system("rc start telnet");
                 system("rc add telnet");
                 syslog(LOG_INFO, "%s", "Telnet is enabled");
@@ -79,8 +86,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"enabled":")" << telnet_enabled << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/telnet/port.cpp

@@ -8,25 +8,30 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define TELNET_PORT_REQUIRED_STRING R"({"required":"[token,port]"})"
 
-namespace settings {
-    void get_telnet_port(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_telnet_port(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream telnetportfile("/etc/openrouter/telnet/port");
             int telnet_port;
             telnetportfile >> telnet_port;
@@ -34,31 +39,30 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"port":")" << telnet_port << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_telnet_port(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_telnet_port(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["port"] == nullptr) {
-            response.set_content(TELNET_PORT_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["port"] == nullptr)
+            {
+                response.set_content(TELNET_PORT_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream telnetportfileout("/etc/openrouter/telnet/port");
             std::string new_telnet_port = json_body["port"];
             telnetportfileout << stoi(new_telnet_port);
@@ -73,8 +77,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"port":")" << telnet_port << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/telnet/telnet.hpp

@@ -3,12 +3,16 @@
 
 #include <httplib.h>
 
-namespace settings {
-    void get_telnet(const httplib::Request &request, httplib::Response &response);
-    void set_telnet(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace settings
+    {
+        void get_telnet(const httplib::Request &request, httplib::Response &response);
+        void set_telnet(const httplib::Request &request, httplib::Response &response);
 
-    void get_telnet_port(const httplib::Request &request, httplib::Response &response);
-    void set_telnet_port(const httplib::Request &request, httplib::Response &response);
+        void get_telnet_port(const httplib::Request &request, httplib::Response &response);
+        void set_telnet_port(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // SETTINGS_TELNET_HPP

openrouter/src/settings/wifi/channel.cpp

@@ -8,30 +8,37 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define WIFI_CHANNEL_REQUIRED_STRING R"({"required":"[token,channel]"})"
 
-namespace settings {
-    void get_wifi_channel(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_channel(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_channel;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("channel=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("channel=") == 0)
+                {
                     wifi_channel = wifisettingsbuffer;
                     wifi_channel.erase(0, 8);
                     break;
@@ -41,36 +48,37 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"channel":")" << wifi_channel << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_wifi_channel(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_wifi_channel(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["channel"] == nullptr) {
-            response.set_content(WIFI_CHANNEL_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["channel"] == nullptr)
+            {
+                response.set_content(WIFI_CHANNEL_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string old_channel;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("channel=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("channel=") == 0)
+                {
                     old_channel = wifisettingsbuffer;
                     old_channel.erase(0, 8);
                     break;
@@ -89,8 +97,10 @@ namespace settings {
             std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_channel;
             std::string changedwifisettingsbuffer;
-            while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) {
-                if (changedwifisettingsbuffer.find("channel=") == 0) {
+            while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer))
+            {
+                if (changedwifisettingsbuffer.find("channel=") == 0)
+                {
                     wifi_channel = changedwifisettingsbuffer;
                     wifi_channel.erase(0, 8);
                     break;
@@ -100,8 +110,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"channel":")" << wifi_channel << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/wifi/name.cpp

@@ -8,30 +8,37 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define WIFI_NAME_REQUIRED_STRING R"({"required":"[token,name]"})"
 
-namespace settings {
-    void get_wifi_name(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_name(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_name;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("ssid=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("ssid=") == 0)
+                {
                     wifi_name = wifisettingsbuffer;
                     wifi_name.erase(0, 5);
                     break;
@@ -41,36 +48,37 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"name":")" << wifi_name << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_wifi_name(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_wifi_name(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["name"] == nullptr) {
-            response.set_content(WIFI_NAME_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["name"] == nullptr)
+            {
+                response.set_content(WIFI_NAME_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string old_wifi_name;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("ssid=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("ssid=") == 0)
+                {
                     old_wifi_name = wifisettingsbuffer;
                     old_wifi_name.erase(0, 5);
                     break;
@@ -89,8 +97,10 @@ namespace settings {
             std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_name;
             std::string changedwifisettingsbuffer;
-            while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) {
-                if (changedwifisettingsbuffer.find("ssid=") == 0) {
+            while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer))
+            {
+                if (changedwifisettingsbuffer.find("ssid=") == 0)
+                {
                     wifi_name = changedwifisettingsbuffer;
                     wifi_name.erase(0, 5);
                     break;
@@ -100,8 +110,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"name":")" << wifi_name << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/wifi/password.cpp

@@ -8,30 +8,37 @@
 #include <string>
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define WIFI_PASSWORD_REQUIRED_STRING R"({"required":"[token,password,newpassword]"})"
 
-namespace settings {
-    void get_wifi_password(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_password(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_password;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("wpa_passphrase=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("wpa_passphrase=") == 0)
+                {
                     wifi_password = wifisettingsbuffer;
                     wifi_password.erase(0, 15);
                     break;
@@ -41,41 +48,43 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"password":")" << wifi_password << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_wifi_password(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_wifi_password(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["password"] == nullptr) {
-            response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["password"] == nullptr)
+            {
+                response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (json_body["newpassword"] == nullptr) {
-            response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["newpassword"] == nullptr)
+            {
+                response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string old_wifi_password;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("wpa_passphrase=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("wpa_passphrase=") == 0)
+                {
                     old_wifi_password = wifisettingsbuffer;
                     old_wifi_password.erase(0, 15);
                     break;
@@ -83,7 +92,8 @@ namespace settings {
             }
             wifisettingsfile.close();
             std::string req_old_password = json_body["password"];
-            if (old_wifi_password != req_old_password) {
+            if (old_wifi_password != req_old_password)
+            {
                 response.set_content(R"({"status":"reject"})", JSON_TYPE);
                 return;
             }
@@ -97,8 +107,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"success":"ok"})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/wifi/qr.cpp

@@ -5,33 +5,41 @@
 #include <QR-Code-generator/qrcodegen.hpp>
 #include <QR-Code-generator/qrtosvg.hpp>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
-namespace settings {
-    void get_wifi_qr(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_qr(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
-
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH);
             std::string wifi_name;
             std::string wifi_password;
             std::string wifisettingsbuffer;
-            while (std::getline(wifisettingsfile, wifisettingsbuffer)) {
-                if (wifisettingsbuffer.find("ssid=") == 0) {
+            while (std::getline(wifisettingsfile, wifisettingsbuffer))
+            {
+                if (wifisettingsbuffer.find("ssid=") == 0)
+                {
                     wifi_name = wifisettingsbuffer;
                     wifi_name.erase(0, 5);
                 }
-                if (wifisettingsbuffer.find("wpa_passphrase=") == 0) {
+                if (wifisettingsbuffer.find("wpa_passphrase=") == 0)
+                {
                     wifi_password = wifisettingsbuffer;
                     wifi_password.erase(0, 15);
                     break;
@@ -42,11 +50,9 @@ namespace settings {
             std::stringstream toqrstring;
             toqrstring << "WIFI:T:WPA;P:" << wifi_password << ";S:" << wifi_name << ";";
 
-            qrcodegen::QrCode qr0  = qrcodegen::QrCode::encodeText(toqrstring.str().c_str(), qrcodegen::QrCode::Ecc::MEDIUM);
+            qrcodegen::QrCode qr0 = qrcodegen::QrCode::encodeText(toqrstring.str().c_str(), qrcodegen::QrCode::Ecc::MEDIUM);
             std::string responsedata = toSvgString(qr0, 4);
             response.set_content(responsedata, SVG_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/wifi/status.cpp

@@ -4,24 +4,30 @@
 #include "../../types.hpp"
 #include <syslog.h>
 #include "../../auth/auth.hpp"
+#include "../../helpers.hpp"
 
 #define WIFI_REQUIRED_STRING R"({"required":"[token,status]"})"
-namespace settings {
-    void get_wifi_status(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_status(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ifstream wifistatusfile("/etc/openrouter/wifi/status");
             int wifi_status;
             wifistatusfile >> wifi_status;
@@ -29,38 +35,40 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"status":")" << wifi_status << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
-        }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
-    }
-
-    void set_wifi_status(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
         }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+        void set_wifi_status(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (!check_body(request))
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
 
-        if (json_body["status"] == nullptr) {
-            response.set_content(WIFI_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            if (json_body["status"] == nullptr)
+            {
+                response.set_content(WIFI_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
+            if (!authenticate(json_body["token"]))
+            {
+                response.set_content(R"({"access":"reject"})", JSON_TYPE);
+                return;
+            }
             std::ofstream wififileout("/etc/openrouter/wifi/status");
             std::string new_wifi_status = json_body["status"];
-            if (new_wifi_status == "0") {
+            if (new_wifi_status == "0")
+            {
                 system("rc stop hostapd");
                 system("rc del hostapd");
                 syslog(LOG_INFO, "%s", "WIFI is disabled");
-            } else {
+            }
+            else
+            {
                 system("rc start hostapd");
                 system("rc add hostapd");
                 syslog(LOG_INFO, "%s", "WIFI is enabled");
@@ -74,8 +82,6 @@ namespace settings {
             std::stringstream responsedata;
             responsedata << R"({"status":")" << wifi_status << R"("})";
             response.set_content(responsedata.str(), JSON_TYPE);
-            return;
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/settings/wifi/wifi.hpp

@@ -5,20 +5,24 @@
 
 #define WIFI_SETTINGS_PATH "/etc/hostapd/hostapd.conf"
 
-namespace settings {
-    void get_wifi_status(const httplib::Request &request, httplib::Response &response);
-    void set_wifi_status(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace settings
+    {
+        void get_wifi_status(const httplib::Request &request, httplib::Response &response);
+        void set_wifi_status(const httplib::Request &request, httplib::Response &response);
 
-    void get_wifi_name(const httplib::Request &request, httplib::Response &response);
-    void set_wifi_name(const httplib::Request &request, httplib::Response &response);
+        void get_wifi_name(const httplib::Request &request, httplib::Response &response);
+        void set_wifi_name(const httplib::Request &request, httplib::Response &response);
 
-    void get_wifi_password(const httplib::Request &request, httplib::Response &response);
-    void set_wifi_password(const httplib::Request &request, httplib::Response &response);
+        void get_wifi_password(const httplib::Request &request, httplib::Response &response);
+        void set_wifi_password(const httplib::Request &request, httplib::Response &response);
 
-    void get_wifi_qr(const httplib::Request &request, httplib::Response &response);
+        void get_wifi_qr(const httplib::Request &request, httplib::Response &response);
 
-    void get_wifi_channel(const httplib::Request &request, httplib::Response &response);
-    void set_wifi_channel(const httplib::Request &request, httplib::Response &response);
+        void get_wifi_channel(const httplib::Request &request, httplib::Response &response);
+        void set_wifi_channel(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // WIFI_HPP

openrouter/src/system/reboot/reboot.cpp

@@ -4,24 +4,32 @@
 #include "../types.hpp"
 #include "../../auth/auth.hpp"
 
-namespace systemfuncs {
-    void reboot(const httplib::Request &request, httplib::Response &response) {
-        std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
-        response.set_header("Access-Control-Allow-Origin", "*");
-        if (request.body.empty()) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+namespace api
+{
+    namespace system
+    {
+        void reboot(const httplib::Request &request, httplib::Response &response)
+        {
+            std::cout << GREEN << request.path << RESET << "  " << request.method << std::endl;
+            response.set_header("Access-Control-Allow-Origin", "*");
+            if (request.body.empty())
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        nlohmann::json json_body = nlohmann::json::parse(request.body);
-        if (json_body["token"] == nullptr) {
-            response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
-            return;
-        }
+            nlohmann::json json_body = nlohmann::json::parse(request.body);
+            if (json_body["token"] == nullptr)
+            {
+                response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE);
+                return;
+            }
 
-        if (authenticate(json_body["token"])) {
-            system("reboot");
+            if (authenticate(json_body["token"]))
+            {
+                std::system("reboot");
+            }
+            response.set_content(R"({"access":"reject"})", JSON_TYPE);
         }
-        response.set_content(R"({"access":"reject"})", JSON_TYPE);
     }
 }

openrouter/src/system/reboot/reboot.hpp

@@ -2,8 +2,13 @@
 #define REBOOT_HPP
 
 #include <httplib.h>
-namespace systemfuncs {
-    void reboot(const httplib::Request &request, httplib::Response &response);
+
+namespace api
+{
+    namespace system
+    {
+        void reboot(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // REBOOT_HPP

openrouter/src/system/syslog/syslog.cpp

@@ -7,12 +7,17 @@
 #include <string>
 
 #define SYSLOG_FILE "/var/log/messages"
-namespace systemfuncs {
-    void get_syslog(const httplib::Request &request, httplib::Response &response) {
-        std::stringstream responsedata;
-        std::ifstream syslogfile(SYSLOG_FILE);
-        responsedata << syslogfile.rdbuf();
-        syslogfile.close();
-        response.set_content(responsedata.str(), PLAIN_TEXT_TYPE);
+namespace api
+{
+    namespace system
+    {
+        void get_syslog(const httplib::Request &request, httplib::Response &response)
+        {
+            std::stringstream responsedata;
+            std::ifstream syslogfile(SYSLOG_FILE);
+            responsedata << syslogfile.rdbuf();
+            syslogfile.close();
+            response.set_content(responsedata.str(), PLAIN_TEXT_TYPE);
+        }
     }
 }

openrouter/src/system/syslog/syslog.hpp

@@ -3,8 +3,12 @@
 
 #include <httplib.h>
 
-namespace systemfuncs {
-    void get_syslog(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace system
+    {
+        void get_syslog(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
-#endif //SYSLOG_HPP
+#endif // SYSLOG_HPP

openrouter/src/system/system.hpp

@@ -1,7 +1,9 @@
 #ifndef SYSTEM_HPP
 #define SYSTEM_HPP
 
+#ifdef __linux__
 #include "uptime/uptime.hpp"
+#endif // __linux__
 #include "syslog/syslog.hpp"
 #include "reboot/reboot.hpp"
 

openrouter/src/system/uptime/uptime.cpp

@@ -1,28 +1,37 @@
 #include "uptime.hpp"
+#ifdef __linux__
 #include <sys/sysinfo.h>
+#endif // __linux__
 #include <sstream>
 #include "../types.hpp"
 
-namespace systemfuncs {
-    void get_uptime(const httplib::Request &request, httplib::Response &response) {
-        struct sysinfo x;
-        if (sysinfo(&x) == 0)
+namespace api
+{
+    namespace system
+    {
+        void get_uptime(const httplib::Request &request, httplib::Response &response)
         {
-            // std::cout << static_cast<unsigned long long>(x.uptime)/3600ULL << "h " 
-            //       << static_cast<unsigned long long>(x.uptime)/60ULL%60ULL << "m "
-            //       << static_cast<unsigned long long>(x.uptime)%60ULL << "s "
-            //       << std::endl;
-            std::stringstream responsedata;
-            responsedata << R"({"uptime":{"hour":")" 
-                        << static_cast<unsigned long long>(x.uptime)/3600ULL
-                        << R"(","minute":")" 
-                        << static_cast<unsigned long long>(x.uptime)/60ULL%60ULL
-                        << R"(","second":")" 
-                        << static_cast<unsigned long long>(x.uptime)%60ULL
-                        << R"("}})";
-            response.set_content(responsedata.str(), JSON_TYPE);
-            return;
+#ifdef __linux__
+            struct sysinfo x;
+            if (sysinfo(&x) == 0)
+            {
+                // std::cout << static_cast<unsigned long long>(x.uptime)/3600ULL << "h "
+                //       << static_cast<unsigned long long>(x.uptime)/60ULL%60ULL << "m "
+                //       << static_cast<unsigned long long>(x.uptime)%60ULL << "s "
+                //       << std::endl;
+                std::stringstream responsedata;
+                responsedata << R"({"uptime":{"hour":")"
+                             << static_cast<unsigned long long>(x.uptime) / 3600ULL
+                             << R"(","minute":")"
+                             << static_cast<unsigned long long>(x.uptime) / 60ULL % 60ULL
+                             << R"(","second":")"
+                             << static_cast<unsigned long long>(x.uptime) % 60ULL
+                             << R"("}})";
+                response.set_content(responsedata.str(), JSON_TYPE);
+                return;
+            }
+            response.set_content(R"({"error":"unknown"})", JSON_TYPE);
+#endif // __linux__
         }
-        response.set_content(R"({"error":"unknown"})", JSON_TYPE);
     }
 }

openrouter/src/system/uptime/uptime.hpp

@@ -3,8 +3,12 @@
 
 #include <httplib.h>
 
-namespace systemfuncs {
-    void get_uptime(const httplib::Request &request, httplib::Response &response);
+namespace api
+{
+    namespace system
+    {
+        void get_uptime(const httplib::Request &request, httplib::Response &response);
+    }
 }
 
 #endif // UPTIME_HPP

openrouter/src/web/index.html

@@ -1,5 +1,6 @@
 <!DOCTYPE html>
 <html lang="en">
+
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
@@ -13,6 +14,7 @@
     <link rel="stylesheet" href="css/syslog.css">
     <title>Openrouter Admin</title>
 </head>
+
 <body>
     <section class="adminpanel">
         <!-- header -->
@@ -24,7 +26,8 @@
                 <button class="linkbutton" id="infobutton">Info</button>
                 <button class="linkbutton" id="rebootbutton">Reboot</button>
             </div>
-            <h1>Openrouter Admin  Uptime: <p id="uptime"></p></h1>
+            <h1>Openrouter Admin Uptime: <p id="uptime"></p>
+            </h1>
             <div class="userbuttons">
                 <h1 class="headerusername"></h1>
                 <button class="exitbutton">Exit</button>
@@ -65,7 +68,9 @@
                     <div class="settingrectbody" id="dnssettingsbody">
                         <table class="dnsservers">
                             <thead>
-                                <tr><th>DNS servers</th></tr>
+                                <tr>
+                                    <th>DNS servers</th>
+                                </tr>
                             </thead>
                             <tbody id="dnsserverstablebody">
                             </tbody>
@@ -84,8 +89,10 @@
                         </table>
                     </div>
                     <div class="settingrectfooter">
-                        <button id="add_local_domain_button" class="hiddenbutton settingrectfooterbutton">Add Local Domain</button>
-                        <button id="add_dns_server_button" class="hiddenbutton settingrectfooterbutton">Add DNS server</button>
+                        <button id="add_local_domain_button" class="hiddenbutton settingrectfooterbutton">Add Local
+                            Domain</button>
+                        <button id="add_dns_server_button" class="hiddenbutton settingrectfooterbutton">Add DNS
+                            server</button>
                         <button class="settingrectfooterbutton" id="set_dns_settings">Confirm</button>
                     </div>
                 </div>
@@ -119,7 +126,9 @@
                         </div>
                         <table class="sshkeys">
                             <thead>
-                                <tr><th>SSH keys</th></tr>
+                                <tr>
+                                    <th>SSH keys</th>
+                                </tr>
                             </thead>
                             <tbody id="sshkeystablebody">
                             </tbody>
@@ -241,7 +250,7 @@
         </div>
     </div>
     <!-- add DNS server form -->
-     <!-- add local domain form -->
+    <!-- add local domain form -->
     <div class="form" id="addlocaldomainform">
         <div class="formbody addlocaldomainformbody">
             <h1 class="formheader" id="addlocaldomainformheader">Add Local Domain</h1>
@@ -286,4 +295,5 @@
     <script src="js/uptime.js"></script>
     <script src="js/login.js"></script>
 </body>
+
 </html>

openrouter/src/web/js/header.js

@@ -19,7 +19,7 @@ syslogbutton.addEventListener('click', () => {
 })
 
 headermenubutton.addEventListener('click', () => {
-    if (headerlinks.classList.contains('active')){
+    if (headerlinks.classList.contains('active')) {
         headerlinks.classList.remove('active')
         return
     }

openrouter/src/web/js/notification.js

@@ -34,7 +34,7 @@ const notification = (text, type) => {
 }
 
 // const closenotification = () => {
-    // notificationbox.classList.remove('active')
+// notificationbox.classList.remove('active')
 // }
 
 // notificationbox.addEventListener('click', closenotification)

openrouter/src/web/js/routes.js

@@ -33,9 +33,9 @@ const routes = {
     wifi_name_set: () => [host, prefix, 'settings', 'wifi', 'name', 'set'].join('/'),
     wifi_password_get: () => [host, prefix, 'settings', 'wifi', 'password', 'get'].join('/'),
     wifi_password_set: () => [host, prefix, 'settings', 'wifi', 'password', 'set'].join('/'),
-    wifi_qr_get: () => [host, prefix, 'settings', 'wifi', 'qr', 'get' ].join('/'),
-    wifi_channel_get: () => [host, prefix, 'settings', 'wifi', 'channel', 'get' ].join('/'),
-    wifi_channel_set: () => [host, prefix, 'settings', 'wifi', 'channel', 'set' ].join('/'),
+    wifi_qr_get: () => [host, prefix, 'settings', 'wifi', 'qr', 'get'].join('/'),
+    wifi_channel_get: () => [host, prefix, 'settings', 'wifi', 'channel', 'get'].join('/'),
+    wifi_channel_set: () => [host, prefix, 'settings', 'wifi', 'channel', 'set'].join('/'),
 
     reboot: () => [host, prefix, 'reboot'].join('/'),
     syslog: () => [host, prefix, 'syslog'].join('/'),

openrouter/src/web/js/settings/dns.js

@@ -43,7 +43,7 @@ const get_dns_enabled_status = () => {
 const set_dns_enabled_status = () => {
     fetch(routes.dns_status_set(), {
         method: 'POST',
-        body: `{"token":"${localStorage.getItem("token")}","enabled":"${dnsenabled.checked?1:0}"}`
+        body: `{"token":"${localStorage.getItem("token")}","enabled":"${dnsenabled.checked ? 1 : 0}"}`
     }).then(res => res.json()).then(jsondata => {
         if (jsondata.enabled === '1') {
             dnsenabled.checked = true
@@ -64,7 +64,7 @@ const set_dns_settings = () => {
     }
 }
 
-setdnssettingsbutton.addEventListener('click', () =>{
+setdnssettingsbutton.addEventListener('click', () => {
     if (confirm("Confirm DNS settings?")) {
         set_dns_settings()
     }
@@ -222,7 +222,7 @@ addlocaldomaincancelbutton.addEventListener('click', () => {
 addlocaldomainconfirmbutton.addEventListener('click', () => {
     addlocaldomainform.classList.remove('active')
     if (confirm(`Confirm DNS settings? (Add Local Domain: ${ipinput.value} ${domaininput.value})`)) {
-        localdomains.push({"ip": ipinput.value, "domain": domaininput.value});
+        localdomains.push({ "ip": ipinput.value, "domain": domaininput.value });
         set_local_domains()
         ipinput.value = ""
         domaininput.value = ""

openrouter/src/web/js/settings/ftp.js

@@ -19,7 +19,7 @@ const get_ftp_enabled_status = () => {
 const set_ftp_enabled_status = () => {
     fetch(routes.ftp_status_set(), {
         method: 'POST',
-        body: `{"token":"${localStorage.getItem("token")}","enabled":"${ftpenabled.checked?1:0}"}`
+        body: `{"token":"${localStorage.getItem("token")}","enabled":"${ftpenabled.checked ? 1 : 0}"}`
     }).then(res => res.json()).then(jsondata => {
         if (jsondata.enabled === '1') {
             ftpenabled.checked = true
@@ -31,7 +31,7 @@ const set_ftp_enabled_status = () => {
     })
 }
 
-setftpsettingsbutton.addEventListener('click', () =>{
+setftpsettingsbutton.addEventListener('click', () => {
     if (confirm("Confirm ftp settings?")) {
         set_ftp_enabled_status()
     }

openrouter/src/web/js/settings/ssh.js

@@ -27,7 +27,7 @@ const get_ssh_status = () => {
 const set_ssh_status = () => {
     fetch(routes.ssh_status_set(), {
         method: 'POST',
-        body: `{"token":"${localStorage.getItem("token")}","status":"${sshenable.checked?1:0}"}`
+        body: `{"token":"${localStorage.getItem("token")}","status":"${sshenable.checked ? 1 : 0}"}`
     }).then(res => res.json()).then(jsondata => {
         if (jsondata.status === '1') {
             sshenable.checked = true

openrouter/src/web/js/settings/telnet.js

@@ -27,7 +27,7 @@ const get_telnet_enabled_status = () => {
 const set_telnet_enabled_status = () => {
     fetch(routes.telnet_status_set(), {
         method: 'POST',
-        body: `{"token":"${localStorage.getItem("token")}","enabled":"${telnetenabled.checked?1:0}"}`
+        body: `{"token":"${localStorage.getItem("token")}","enabled":"${telnetenabled.checked ? 1 : 0}"}`
     }).then(res => res.json()).then(jsondata => {
         if (jsondata.enabled === '1') {
             telnetenabled.checked = true

openrouter/src/web/js/settings/wifi.js

@@ -31,7 +31,7 @@ const get_wifi_status = () => {
 const set_wifi_status = () => {
     fetch(routes.wifi_status_set(), {
         method: 'POST',
-        body: `{"token":"${localStorage.getItem('token')}","status":"${wifistatus.checked?"1":"0"}"}`
+        body: `{"token":"${localStorage.getItem('token')}","status":"${wifistatus.checked ? "1" : "0"}"}`
     }).then(data => data.json()).then(jsondata => {
         if (jsondata.status === "1") {
             wifistatus.checked = true
@@ -157,8 +157,8 @@ const get_wifi_qr_code = () => {
 wifiqr.addEventListener('click', () => {
     if (wifiqr.checked) {
         get_wifi_qr_code()
-        wifiqrimg.innerHTML = 
-        wifiqrimg.classList.add('active')
+        wifiqrimg.innerHTML =
+            wifiqrimg.classList.add('active')
         return
     }
     wifiqrimg.classList.remove('active')

openrouter/src/web/js/syslog.js

@@ -20,7 +20,7 @@ const get_syslog_data = () => {
             authservicefilterfunc(textdata)
             return
         }
-        syslogdata.innerHTML = textdata.replace(/\n/g,'<br>')
+        syslogdata.innerHTML = textdata.replace(/\n/g, '<br>')
     }).catch((error) => {
         notification(`Ошибка на сервере: ${error}`, "error")
     })
@@ -44,7 +44,7 @@ authservicefilter.addEventListener('click', () => {
 })
 
 const openrouterfilterfunc = (textdata) => {
-    let syslogalldata = textdata.replace(/\n/g,'<br>')
+    let syslogalldata = textdata.replace(/\n/g, '<br>')
     syslogalldata = syslogalldata.split("<br>")
     syslogalldata = syslogalldata.filter(data => {
         return data.includes("openrouter:")
@@ -57,7 +57,7 @@ const openrouterfilterfunc = (textdata) => {
 }
 
 const authservicefilterfunc = (textdata) => {
-    let syslogalldata = textdata.replace(/\n/g,'<br>')
+    let syslogalldata = textdata.replace(/\n/g, '<br>')
     syslogalldata = syslogalldata.split("<br>")
     syslogalldata = syslogalldata.filter(data => {
         return data.includes("auth_service:")
@@ -69,12 +69,16 @@ const authservicefilterfunc = (textdata) => {
     return
 }
 
+let syslogRealtimeIntervalId
 realtimesyslogchekbox.addEventListener('click', () => {
     if (realtimesyslogchekbox.checked) {
-        let socket = new WebSocket("ws://192.168.122.76/syslog");
+        syslogRealtimeIntervalId = setInterval(get_syslog_data, 1000)
+        // let socket = new WebSocket("ws://192.168.122.76/syslog");
 
-        socket.onmessage = function(event) {
-            console.log(event.data)
-        };
+        // socket.onmessage = function(event) {
+        //     console.log(event.data)
+        // };
+    } else {
+        clearInterval(syslogRealtimeIntervalId)
     }
 })