diff --git a/meson.build b/meson.build index 9998a13..be0a1d2 100644 --- a/meson.build +++ b/meson.build @@ -1,4 +1,4 @@ -project('openrouter', 'cpp', default_options : ['c_std=c20', 'cpp_std=c++20']) +project('openrouter', 'cpp', default_options : ['cpp_std=c++20', 'cpp_args=-Wall']) include_dirs = include_directories('src', 'src/libs') executable( 'openrouter', diff --git a/src/OpenRouter/OpenRouter.cpp b/src/OpenRouter/OpenRouter.cpp index cc631f7..2cf5327 100644 --- a/src/OpenRouter/OpenRouter.cpp +++ b/src/OpenRouter/OpenRouter.cpp @@ -7,39 +7,39 @@ 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/telnet/get", api::settings::telnet::get_telnet); + this->srv.Post("/api/settings/telnet/set", api::settings::telnet::set_telnet); + this->srv.Post("/api/settings/telnet/port/get", api::settings::telnet::get_telnet_port); + this->srv.Post("/api/settings/telnet/port/set", api::settings::telnet::set_telnet_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/ssh/server/get", api::settings::get_ssh_server_http); - this->srv.Post("/api/settings/ssh/server/set", api::settings::set_ssh_server_http); + this->srv.Post("/api/settings/ssh/status/get", api::settings::ssh::get_ssh_status); + this->srv.Post("/api/settings/ssh/status/set", api::settings::ssh::set_ssh_status); + this->srv.Post("/api/settings/ssh/keys/get", api::settings::ssh::get_ssh_keys); + this->srv.Post("/api/settings/ssh/keys/set", api::settings::ssh::set_ssh_keys); + this->srv.Post("/api/settings/ssh/port/get", api::settings::ssh::get_ssh_port); + this->srv.Post("/api/settings/ssh/port/set", api::settings::ssh::set_ssh_port); + this->srv.Post("/api/settings/ssh/server/get", api::settings::ssh::get_ssh_server_http); + this->srv.Post("/api/settings/ssh/server/set", api::settings::ssh::set_ssh_server_http); - 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/dns/get", api::settings::dns::get_dns); + this->srv.Post("/api/settings/dns/set", api::settings::dns::set_dns); + this->srv.Post("/api/settings/dns/servers/get", api::settings::dns::get_dns_servers); + this->srv.Post("/api/settings/dns/servers/set", api::settings::dns::set_dns_servers); + this->srv.Post("/api/settings/dns/domains/get", api::settings::dns::get_local_domains); + this->srv.Post("/api/settings/dns/domains/set", api::settings::dns::set_local_domains); - 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/ftp/get", api::settings::ftp::get_ftp); + this->srv.Post("/api/settings/ftp/set", api::settings::ftp::set_ftp); - 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/settings/wifi/status/get", api::settings::wifi::get_wifi_status); + this->srv.Post("/api/settings/wifi/status/set", api::settings::wifi::set_wifi_status); + this->srv.Post("/api/settings/wifi/name/get", api::settings::wifi::get_wifi_name); + this->srv.Post("/api/settings/wifi/name/set", api::settings::wifi::set_wifi_name); + this->srv.Post("/api/settings/wifi/password/get", api::settings::wifi::get_wifi_password); + this->srv.Post("/api/settings/wifi/password/set", api::settings::wifi::set_wifi_password); + this->srv.Post("/api/settings/wifi/qr/get", api::settings::wifi::get_wifi_qr); + this->srv.Post("/api/settings/wifi/channel/get", api::settings::wifi::get_wifi_channel); + this->srv.Post("/api/settings/wifi/channel/set", api::settings::wifi::set_wifi_channel); this->srv.Post("/api/reboot", api::system::reboot); diff --git a/src/auth/auth.cpp b/src/auth/auth.cpp index b8bcb56..9540906 100644 --- a/src/auth/auth.cpp +++ b/src/auth/auth.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include @@ -9,9 +8,9 @@ bool authenticate(const std::string &token) { httplib::Client cli(AUTH_SERVICE); - std::stringstream body; - body << R"({"token":")" << token << R"("})"; - httplib::Result res = cli.Post("/api/access", body.str(), JSON_TYPE); + std::string body = R"({"token":")" + token + R"("})"; + // body << R"({"token":")" << token << R"("})"; + httplib::Result res = cli.Post("/api/access", body, JSON_TYPE); if (res->status == httplib::OK_200) { nlohmann::json resjson = nlohmann::json::parse(res->body); diff --git a/src/settings/dns/dns.hpp b/src/settings/dns/dns.hpp index 0105ff7..7ae5f9e 100644 --- a/src/settings/dns/dns.hpp +++ b/src/settings/dns/dns.hpp @@ -7,14 +7,17 @@ namespace api { namespace settings { - void get_dns(const httplib::Request &request, httplib::Response &response); - void set_dns(const httplib::Request &request, httplib::Response &response); + namespace dns + { + 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); + } } } diff --git a/src/settings/dns/enabled.cpp b/src/settings/dns/enabled.cpp index 50fa7a3..934416b 100644 --- a/src/settings/dns/enabled.cpp +++ b/src/settings/dns/enabled.cpp @@ -12,76 +12,79 @@ namespace api { namespace settings { - void get_dns(const httplib::Request &request, httplib::Response &response) + namespace dns { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_dns(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream dnsfile("/etc/openrouter/dns"); - int dns_enabled; - dnsfile >> dns_enabled; - dnsfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << dns_enabled << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + dnsfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << dns_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_dns(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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") + { + system("rc stop dnsmasq"); + system("rc del dnsmasq"); + syslog(LOG_INFO, "%s", "DNS is disabled"); + } + else + { + system("rc restart dnsmasq"); + system("rc add dnsmasq"); + syslog(LOG_INFO, "%s", "DNS is enabled"); + } + dnsfileout << stoi(new_dns_enabled); + dnsfileout.close(); + std::ifstream dnsfile("/etc/openrouter/dns"); + int dns_enabled; + dnsfile >> dns_enabled; + dnsfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << dns_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ofstream dnsfileout("/etc/openrouter/dns"); - std::string new_dns_enabled = json_body["enabled"]; - if (new_dns_enabled == "0") - { - system("rc stop dnsmasq"); - system("rc del dnsmasq"); - syslog(LOG_INFO, "%s", "DNS is disabled"); - } - else - { - system("rc restart dnsmasq"); - system("rc add dnsmasq"); - syslog(LOG_INFO, "%s", "DNS is enabled"); - } - dnsfileout << stoi(new_dns_enabled); - dnsfileout.close(); - std::ifstream dnsfile("/etc/openrouter/dns"); - int dns_enabled; - dnsfile >> dns_enabled; - dnsfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << dns_enabled << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/dns/local_domains.cpp b/src/settings/dns/local_domains.cpp index 8a86c65..45d9a98 100644 --- a/src/settings/dns/local_domains.cpp +++ b/src/settings/dns/local_domains.cpp @@ -10,82 +10,85 @@ namespace api { namespace settings { - void get_local_domains(const httplib::Request &request, httplib::Response &response) + namespace dns { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_local_domains(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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()) - { - domainsfile >> ip_string; - domainsfile >> domain_string; - if (domain_string.empty()) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - continue; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - responsedata << R"({"ip":")" << ip_string << R"(","domain":")" << domain_string << R"("},)"; - ip_string = ""; - domain_string = ""; - iter++; - } - if (iter != 0) - { - responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}"); - } - else - { - responsedata << "]}"; - } - domainsfile.close(); - response.set_content(responsedata.str(), JSON_TYPE); - } + nlohmann::json json_body = nlohmann::json::parse(request.body); - 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; + 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()) + { + domainsfile >> ip_string; + domainsfile >> domain_string; + if (domain_string.empty()) + { + continue; + } + responsedata << R"({"ip":")" << ip_string << R"(","domain":")" << domain_string << R"("},)"; + ip_string = ""; + domain_string = ""; + iter++; + } + if (iter != 0) + { + responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}"); + } + else + { + responsedata << "]}"; + } + domainsfile.close(); + response.set_content(responsedata.str(), JSON_TYPE); } - nlohmann::json json_body = nlohmann::json::parse(request.body); - if (!authenticate(json_body["token"])) + void set_local_domains(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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"])) + { + 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) + { + std::string ip = domain["ip"]; + std::string dom = domain["domain"]; + domainsfile << ip << " " << dom << "\n"; + } + domainsfile.close(); + system("rc restart dnsmasq"); + syslog(LOG_INFO, "%s", "DNS local domains changed"); + std::string responsedata = R"({"success":"true"})"; + response.set_content(responsedata, JSON_TYPE); } - std::ofstream domainsfile("/etc/dnsmasq.conf.d/hosts"); - nlohmann::json domains = json_body["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"; - } - domainsfile.close(); - system("rc restart dnsmasq"); - syslog(LOG_INFO, "%s", "DNS local domains changed"); - std::string responsedata = R"({"success":"true"})"; - response.set_content(responsedata, JSON_TYPE); } } } diff --git a/src/settings/dns/servers.cpp b/src/settings/dns/servers.cpp index d356fa3..f6c03e6 100644 --- a/src/settings/dns/servers.cpp +++ b/src/settings/dns/servers.cpp @@ -10,78 +10,81 @@ namespace api { namespace settings { - void get_dns_servers(const httplib::Request &request, httplib::Response &response) + namespace dns { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_dns_servers(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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)) - { - 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 - { - responsedata << "]}"; - } - dnsserversfile.close(); - response.set_content(responsedata.str(), 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 (!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"])) - { - 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) - { - std::string srv = server; - if (server == "") + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - continue; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - dnsserversfile << "nameserver " << srv << "\n"; + nlohmann::json json_body = nlohmann::json::parse(request.body); + + 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)) + { + 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 + { + responsedata << "]}"; + } + dnsserversfile.close(); + response.set_content(responsedata.str(), 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 (!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"])) + { + 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) + { + std::string srv = server; + if (server == "") + { + continue; + } + dnsserversfile << "nameserver " << srv << "\n"; + } + dnsserversfile.close(); + system("rc restart dnsmasq"); + syslog(LOG_INFO, "%s", "DNS servers changed"); + std::string responsedata = R"({"success":"true"})"; + response.set_content(responsedata, JSON_TYPE); } - dnsserversfile.close(); - system("rc restart dnsmasq"); - syslog(LOG_INFO, "%s", "DNS servers changed"); - std::string responsedata = R"({"success":"true"})"; - response.set_content(responsedata, JSON_TYPE); } } } diff --git a/src/settings/ftp/ftp.cpp b/src/settings/ftp/ftp.cpp index 4733a2e..b3c326b 100644 --- a/src/settings/ftp/ftp.cpp +++ b/src/settings/ftp/ftp.cpp @@ -12,76 +12,79 @@ namespace api { namespace settings { - void get_ftp(const httplib::Request &request, httplib::Response &response) + namespace ftp { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_ftp(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream ftpfile("/etc/openrouter/ftp"); - int ftp_enabled; - ftpfile >> ftp_enabled; - ftpfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << ftp_enabled << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + ftpfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << ftp_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_ftp(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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") + { + system("rc stop ftp"); + system("rc del ftp"); + syslog(LOG_INFO, "%s", "Ftp is disabled"); + } + else + { + system("rc start ftp"); + system("rc add ftp"); + syslog(LOG_INFO, "%s", "Ftp is enabled"); + } + ftpfileout << stoi(new_ftp_enabled); + ftpfileout.close(); + std::ifstream ftpfile("/etc/openrouter/ftp"); + int ftp_enabled; + ftpfile >> ftp_enabled; + ftpfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << ftp_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ofstream ftpfileout("/etc/openrouter/ftp"); - std::string new_ftp_enabled = json_body["enabled"]; - if (new_ftp_enabled == "0") - { - system("rc stop ftp"); - system("rc del ftp"); - syslog(LOG_INFO, "%s", "Ftp is disabled"); - } - else - { - system("rc start ftp"); - system("rc add ftp"); - syslog(LOG_INFO, "%s", "Ftp is enabled"); - } - ftpfileout << stoi(new_ftp_enabled); - ftpfileout.close(); - std::ifstream ftpfile("/etc/openrouter/ftp"); - int ftp_enabled; - ftpfile >> ftp_enabled; - ftpfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << ftp_enabled << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/ftp/ftp.hpp b/src/settings/ftp/ftp.hpp index b99da95..8a97b57 100644 --- a/src/settings/ftp/ftp.hpp +++ b/src/settings/ftp/ftp.hpp @@ -7,8 +7,11 @@ namespace api { namespace settings { - void get_ftp(const httplib::Request &request, httplib::Response &response); - void set_ftp(const httplib::Request &request, httplib::Response &response); + namespace ftp + { + void get_ftp(const httplib::Request &request, httplib::Response &response); + void set_ftp(const httplib::Request &request, httplib::Response &response); + } } } diff --git a/src/settings/ssh/keys.cpp b/src/settings/ssh/keys.cpp index c183e6d..13d7201 100644 --- a/src/settings/ssh/keys.cpp +++ b/src/settings/ssh/keys.cpp @@ -12,76 +12,79 @@ namespace api { namespace settings { - void get_ssh_keys(const httplib::Request &request, httplib::Response &response) + namespace ssh { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_ssh_keys(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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()) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - continue; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - responsedata << R"(")" << key_string << R"(",)"; - key_string = ""; - iter++; - } - if (iter != 0) - { - responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}"); - } - else - { - responsedata << "]}"; - } - keysfile.close(); - response.set_content(responsedata.str(), JSON_TYPE); - } + nlohmann::json json_body = nlohmann::json::parse(request.body); - 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; + 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()) + { + continue; + } + responsedata << R"(")" << key_string << R"(",)"; + key_string = ""; + iter++; + } + if (iter != 0) + { + responsedata.str(responsedata.str().erase(responsedata.str().size() - 1, 1) + "]}"); + } + else + { + responsedata << "]}"; + } + keysfile.close(); + response.set_content(responsedata.str(), JSON_TYPE); } - nlohmann::json json_body = nlohmann::json::parse(request.body); - if (!authenticate(json_body["token"])) + void set_ssh_keys(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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"])) + { + 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) + { + keysfile << key << "\n"; + } + keysfile.close(); + system("rc restart ssh"); + syslog(LOG_INFO, "%s", "SSH keys changed"); + std::string responsedata = R"({"success":"true"})"; + response.set_content(responsedata, JSON_TYPE); } - std::ofstream keysfile(KEYS_PATH); - nlohmann::json keys = json_body["keys"]; - for (std::string key : keys) - { - keysfile << key << "\n"; - } - keysfile.close(); - system("rc restart ssh"); - syslog(LOG_INFO, "%s", "SSH keys changed"); - std::string responsedata = R"({"success":"true"})"; - response.set_content(responsedata, JSON_TYPE); } } } diff --git a/src/settings/ssh/port.cpp b/src/settings/ssh/port.cpp index f51ca8b..9723b9e 100644 --- a/src/settings/ssh/port.cpp +++ b/src/settings/ssh/port.cpp @@ -17,87 +17,90 @@ namespace api { namespace settings { - void get_ssh_port(const httplib::Request &request, httplib::Response &response) + namespace ssh { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_ssh_port(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream sshportfile(SSH_PORT_PATH); - int ssh_port; - sshportfile >> ssh_port; - sshportfile.close(); - std::stringstream responsedata; - responsedata << R"({"port":")" << ssh_port << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + sshportfile.close(); + std::stringstream responsedata; + responsedata << R"({"port":")" << ssh_port << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_ssh_port(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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; + oldsshportfile.close(); + std::ofstream sshportfileout(SSH_PORT_PATH); + std::string new_ssh_port = json_body["port"]; + sshportfileout << stoi(new_ssh_port); + sshportfileout.close(); + std::stringstream systemrequest; + if (get_ssh_server() == DROPBEAR_SSH) + { + systemrequest << "sed -i \"s/DROPBEAR_PORT=" << old_ssh_port << "/DROPBEAR_PORT=" << new_ssh_port << "/g\" /etc/default/dropbear"; + } else if (get_ssh_server() == OPENSSH_SSH) + { + systemrequest << "sed -i \"/Port " << old_ssh_port << "/s//Port " << new_ssh_port << "/\" /etc/ssh/sshd_config"; + } + std::cout << systemrequest.str() << std::endl; + system(systemrequest.str().c_str()); + if (get_ssh_server() == OPENSSH_SSH) + { + system("rc restart ssh"); + } else if (get_ssh_server() == DROPBEAR_SSH) + { + system("rc restart dropbear"); + } + std::string syslogstring = "SSH port changed to " + new_ssh_port; + syslog(LOG_INFO, "%s", syslogstring.c_str()); + std::ifstream sshportfile(SSH_PORT_PATH); + int ssh_port; + sshportfile >> ssh_port; + sshportfile.close(); + std::stringstream responsedata; + responsedata << R"({"port":")" << ssh_port << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ifstream oldsshportfile(SSH_PORT_PATH); - int old_ssh_port; - oldsshportfile >> old_ssh_port; - oldsshportfile.close(); - std::ofstream sshportfileout(SSH_PORT_PATH); - std::string new_ssh_port = json_body["port"]; - sshportfileout << stoi(new_ssh_port); - sshportfileout.close(); - std::stringstream systemrequest; - if (get_ssh_server() == DROPBEAR_SSH) - { - systemrequest << "sed -i \"s/DROPBEAR_PORT=" << old_ssh_port << "/DROPBEAR_PORT=" << new_ssh_port << "/g\" /etc/default/dropbear"; - } else if (get_ssh_server() == OPENSSH_SSH) - { - systemrequest << "sed -i \"/Port " << old_ssh_port << "/s//Port " << new_ssh_port << "/\" /etc/ssh/sshd_config"; - } - std::cout << systemrequest.str() << std::endl; - system(systemrequest.str().c_str()); - if (get_ssh_server() == OPENSSH_SSH) - { - system("rc restart ssh"); - } else if (get_ssh_server() == DROPBEAR_SSH) - { - system("rc restart dropbear"); - } - std::string syslogstring = "SSH port changed to " + new_ssh_port; - syslog(LOG_INFO, "%s", syslogstring.c_str()); - std::ifstream sshportfile(SSH_PORT_PATH); - int ssh_port; - sshportfile >> ssh_port; - sshportfile.close(); - std::stringstream responsedata; - responsedata << R"({"port":")" << ssh_port << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/ssh/server.cpp b/src/settings/ssh/server.cpp index ff48465..35275e5 100644 --- a/src/settings/ssh/server.cpp +++ b/src/settings/ssh/server.cpp @@ -12,82 +12,85 @@ namespace api { namespace settings { - std::string get_ssh_server() + namespace ssh { - std::ifstream serverfile("/etc/openrouter/ssh/server"); - std::string ssh_server = ""; - serverfile >> ssh_server; - serverfile.close(); - return ssh_server; - } - - std::string set_ssh_server(std::string &server) - { - std::ofstream serverfile("/etc/openrouter/ssh/server"); - serverfile << server; - serverfile.close(); - return get_ssh_server(); - } - - void get_ssh_server_http(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)) + std::string get_ssh_server() { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - if (!authenticate(json_body["token"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::stringstream responsedata; - responsedata << R"({"server":")" << get_ssh_server() << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); - } - void set_ssh_server_http(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["server"] == nullptr) - { - response.set_content(SSH_SERVER_REQUIRED_STRING, JSON_TYPE); - return; + std::ifstream serverfile("/etc/openrouter/ssh/server"); + std::string ssh_server = ""; + serverfile >> ssh_server; + serverfile.close(); + return ssh_server; } - if (!authenticate(json_body["token"])) + std::string set_ssh_server(std::string &server) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + std::ofstream serverfile("/etc/openrouter/ssh/server"); + serverfile << server; + serverfile.close(); + return get_ssh_server(); } - std::stringstream responsedata; - std::string server = json_body["server"]; - std::string new_server = set_ssh_server(server); - if (new_server == DROPBEAR_SSH) + + void get_ssh_server_http(const httplib::Request &request, httplib::Response &response) { - system("rc stop ssh"); - system("rc del ssh"); - system("rc start dropbear"); - system("rc add dropbear"); - } else if (new_server == OPENSSH_SSH) { - system("rc stop dropbear"); - system("rc del dropbear"); - system("rc start ssh"); - system("rc add ssh"); + 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"])) + { + response.set_content(R"({"access":"reject"})", JSON_TYPE); + return; + } + std::stringstream responsedata; + responsedata << R"({"server":")" << get_ssh_server() << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); + } + void set_ssh_server_http(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["server"] == nullptr) + { + response.set_content(SSH_SERVER_REQUIRED_STRING, JSON_TYPE); + return; + } + + if (!authenticate(json_body["token"])) + { + response.set_content(R"({"access":"reject"})", JSON_TYPE); + return; + } + std::stringstream responsedata; + std::string server = json_body["server"]; + std::string new_server = set_ssh_server(server); + if (new_server == DROPBEAR_SSH) + { + system("rc stop ssh"); + system("rc del ssh"); + system("rc start dropbear"); + system("rc add dropbear"); + } else if (new_server == OPENSSH_SSH) { + system("rc stop dropbear"); + system("rc del dropbear"); + system("rc start ssh"); + system("rc add ssh"); + } + responsedata << R"({"server":")" << new_server << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - responsedata << R"({"server":")" << new_server << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } \ No newline at end of file diff --git a/src/settings/ssh/ssh.hpp b/src/settings/ssh/ssh.hpp index f79b04f..58a7f52 100644 --- a/src/settings/ssh/ssh.hpp +++ b/src/settings/ssh/ssh.hpp @@ -10,20 +10,23 @@ namespace api { namespace settings { - std::string get_ssh_server(); - std::string set_ssh_server(std::string &server); + namespace ssh + { + std::string get_ssh_server(); + std::string set_ssh_server(std::string &server); - void get_ssh_server_http(const httplib::Request &request, httplib::Response &response); - void set_ssh_server_http(const httplib::Request &request, httplib::Response &response); + void get_ssh_server_http(const httplib::Request &request, httplib::Response &response); + void set_ssh_server_http(const httplib::Request &request, httplib::Response &response); - 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_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); + } } } diff --git a/src/settings/ssh/status.cpp b/src/settings/ssh/status.cpp index 8f2cd48..a284a07 100644 --- a/src/settings/ssh/status.cpp +++ b/src/settings/ssh/status.cpp @@ -12,88 +12,91 @@ namespace api { namespace settings { - void get_ssh_status(const httplib::Request &request, httplib::Response &response) + namespace ssh { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_ssh_status(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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; - sshstatusfile.close(); - std::stringstream responsedata; - responsedata << R"({"status":")" << ssh_status << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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 (get_ssh_server() == DROPBEAR_SSH) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - system("rc stop dropbear"); - system("rc del dropbear"); - } else if (get_ssh_server() == OPENSSH_SSH) { - system("rc stop ssh"); - system("rc del ssh"); + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - syslog(LOG_INFO, "%s", "SSH is disabled"); - } - else - { - if (get_ssh_server() == DROPBEAR_SSH) + nlohmann::json json_body = nlohmann::json::parse(request.body); + + if (!authenticate(json_body["token"])) { - system("rc start dropbear"); - system("rc add dropbear"); - } else if (get_ssh_server() == OPENSSH_SSH) { - system("rc start ssh"); - system("rc add ssh"); + response.set_content(R"({"access":"reject"})", JSON_TYPE); + return; } - syslog(LOG_INFO, "%s", "SSH is enabled"); + std::ifstream sshstatusfile("/etc/openrouter/ssh/status"); + int ssh_status; + sshstatusfile >> ssh_status; + sshstatusfile.close(); + std::stringstream responsedata; + responsedata << R"({"status":")" << ssh_status << R"("})"; + response.set_content(responsedata.str(), 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 (!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 (!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 (get_ssh_server() == DROPBEAR_SSH) + { + system("rc stop dropbear"); + system("rc del dropbear"); + } else if (get_ssh_server() == OPENSSH_SSH) { + system("rc stop ssh"); + system("rc del ssh"); + } + syslog(LOG_INFO, "%s", "SSH is disabled"); + } + else + { + if (get_ssh_server() == DROPBEAR_SSH) + { + system("rc start dropbear"); + system("rc add dropbear"); + } else if (get_ssh_server() == OPENSSH_SSH) { + system("rc start ssh"); + system("rc add ssh"); + } + syslog(LOG_INFO, "%s", "SSH is enabled"); + } + sshfileout << stoi(new_ssh_status); + sshfileout.close(); + std::ifstream sshfile("/etc/openrouter/ssh/status"); + int ssh_status; + sshfile >> ssh_status; + sshfile.close(); + std::stringstream responsedata; + responsedata << R"({"status":")" << ssh_status << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - sshfileout << stoi(new_ssh_status); - sshfileout.close(); - std::ifstream sshfile("/etc/openrouter/ssh/status"); - int ssh_status; - sshfile >> ssh_status; - sshfile.close(); - std::stringstream responsedata; - responsedata << R"({"status":")" << ssh_status << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/telnet/enabled.cpp b/src/settings/telnet/enabled.cpp index 94a48f5..53698e6 100644 --- a/src/settings/telnet/enabled.cpp +++ b/src/settings/telnet/enabled.cpp @@ -16,76 +16,79 @@ namespace api { namespace settings { - void get_telnet(const httplib::Request &request, httplib::Response &response) + namespace telnet { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_telnet(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream telnetfile("/etc/openrouter/telnet/enabled"); - int telnet_enabled; - telnetfile >> telnet_enabled; - telnetfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << telnet_enabled << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + telnetfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << telnet_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_telnet(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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") + { + system("rc stop telnet"); + system("rc del telnet"); + syslog(LOG_INFO, "%s", "Telnet is disabled"); + } + else + { + system("rc start telnet"); + system("rc add telnet"); + syslog(LOG_INFO, "%s", "Telnet is enabled"); + } + telnetfileout << stoi(new_telnet_enabled); + telnetfileout.close(); + std::ifstream telnetfile("/etc/openrouter/telnet/enabled"); + int telnet_enabled; + telnetfile >> telnet_enabled; + telnetfile.close(); + std::stringstream responsedata; + responsedata << R"({"enabled":")" << telnet_enabled << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ofstream telnetfileout("/etc/openrouter/telnet/enabled"); - std::string new_telnet_enabled = json_body["enabled"]; - if (new_telnet_enabled == "0") - { - system("rc stop telnet"); - system("rc del telnet"); - syslog(LOG_INFO, "%s", "Telnet is disabled"); - } - else - { - system("rc start telnet"); - system("rc add telnet"); - syslog(LOG_INFO, "%s", "Telnet is enabled"); - } - telnetfileout << stoi(new_telnet_enabled); - telnetfileout.close(); - std::ifstream telnetfile("/etc/openrouter/telnet/enabled"); - int telnet_enabled; - telnetfile >> telnet_enabled; - telnetfile.close(); - std::stringstream responsedata; - responsedata << R"({"enabled":")" << telnet_enabled << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/telnet/port.cpp b/src/settings/telnet/port.cpp index 06c1516..d1816a2 100644 --- a/src/settings/telnet/port.cpp +++ b/src/settings/telnet/port.cpp @@ -16,67 +16,70 @@ namespace api { namespace settings { - void get_telnet_port(const httplib::Request &request, httplib::Response &response) + namespace telnet { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_telnet_port(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream telnetportfile("/etc/openrouter/telnet/port"); - int telnet_port; - telnetportfile >> telnet_port; - telnetportfile.close(); - std::stringstream responsedata; - responsedata << R"({"port":")" << telnet_port << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + telnetportfile.close(); + std::stringstream responsedata; + responsedata << R"({"port":")" << telnet_port << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_telnet_port(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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); + telnetportfileout.close(); + system("rc restart telnet"); + std::string syslogstring = "Telnet port changed to " + new_telnet_port; + syslog(LOG_INFO, "%s", syslogstring.c_str()); + std::ifstream telnetportfile("/etc/openrouter/telnet/port"); + int telnet_port; + telnetportfile >> telnet_port; + telnetportfile.close(); + std::stringstream responsedata; + responsedata << R"({"port":")" << telnet_port << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ofstream telnetportfileout("/etc/openrouter/telnet/port"); - std::string new_telnet_port = json_body["port"]; - telnetportfileout << stoi(new_telnet_port); - telnetportfileout.close(); - system("rc restart telnet"); - std::string syslogstring = "Telnet port changed to " + new_telnet_port; - syslog(LOG_INFO, "%s", syslogstring.c_str()); - std::ifstream telnetportfile("/etc/openrouter/telnet/port"); - int telnet_port; - telnetportfile >> telnet_port; - telnetportfile.close(); - std::stringstream responsedata; - responsedata << R"({"port":")" << telnet_port << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/telnet/telnet.hpp b/src/settings/telnet/telnet.hpp index a870fc3..fbcb8f5 100644 --- a/src/settings/telnet/telnet.hpp +++ b/src/settings/telnet/telnet.hpp @@ -7,11 +7,14 @@ namespace api { namespace settings { - void get_telnet(const httplib::Request &request, httplib::Response &response); - void set_telnet(const httplib::Request &request, httplib::Response &response); + namespace telnet + { + 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); + } } } diff --git a/src/settings/wifi/channel.cpp b/src/settings/wifi/channel.cpp index 04cd10b..b3663bb 100644 --- a/src/settings/wifi/channel.cpp +++ b/src/settings/wifi/channel.cpp @@ -16,100 +16,103 @@ namespace api { namespace settings { - void get_wifi_channel(const httplib::Request &request, httplib::Response &response) + namespace wifi { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_wifi_channel(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - wifi_channel = wifisettingsbuffer; - wifi_channel.erase(0, 8); - break; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - } - wifisettingsfile.close(); - std::stringstream responsedata; - responsedata << R"({"channel":")" << wifi_channel << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); - } + nlohmann::json json_body = nlohmann::json::parse(request.body); - 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 (!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) + if (!authenticate(json_body["token"])) { - old_channel = wifisettingsbuffer; - old_channel.erase(0, 8); - break; + response.set_content(R"({"access":"reject"})", JSON_TYPE); + return; } - } - wifisettingsfile.close(); - std::string new_channel = json_body["channel"]; - std::stringstream systemrequest; - systemrequest << "sed -i \"/channel=" << old_channel << "/s//channel=" << new_channel << "/\" /etc/hostapd/hostapd.conf"; - std::cout << systemrequest.str() << std::endl; - system(systemrequest.str().c_str()); - system("rc restart hostapd"); - std::string syslogstring = "WIFI channel changed to " + new_channel; - syslog(LOG_INFO, "%s", syslogstring.c_str()); - - std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH); - std::string wifi_channel; - std::string changedwifisettingsbuffer; - while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) - { - if (changedwifisettingsbuffer.find("channel=") == 0) + std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH); + std::string wifi_channel; + std::string wifisettingsbuffer; + while (std::getline(wifisettingsfile, wifisettingsbuffer)) { - wifi_channel = changedwifisettingsbuffer; - wifi_channel.erase(0, 8); - break; + if (wifisettingsbuffer.find("channel=") == 0) + { + wifi_channel = wifisettingsbuffer; + wifi_channel.erase(0, 8); + break; + } } + wifisettingsfile.close(); + std::stringstream responsedata; + responsedata << R"({"channel":")" << wifi_channel << R"("})"; + response.set_content(responsedata.str(), 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 (!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 (!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) + { + old_channel = wifisettingsbuffer; + old_channel.erase(0, 8); + break; + } + } + wifisettingsfile.close(); + std::string new_channel = json_body["channel"]; + std::stringstream systemrequest; + systemrequest << "sed -i \"/channel=" << old_channel << "/s//channel=" << new_channel << "/\" /etc/hostapd/hostapd.conf"; + std::cout << systemrequest.str() << std::endl; + system(systemrequest.str().c_str()); + system("rc restart hostapd"); + std::string syslogstring = "WIFI channel changed to " + new_channel; + syslog(LOG_INFO, "%s", syslogstring.c_str()); + + std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH); + std::string wifi_channel; + std::string changedwifisettingsbuffer; + while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) + { + if (changedwifisettingsbuffer.find("channel=") == 0) + { + wifi_channel = changedwifisettingsbuffer; + wifi_channel.erase(0, 8); + break; + } + } + changedwifisettingsfile.close(); + std::stringstream responsedata; + responsedata << R"({"channel":")" << wifi_channel << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - changedwifisettingsfile.close(); - std::stringstream responsedata; - responsedata << R"({"channel":")" << wifi_channel << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/wifi/name.cpp b/src/settings/wifi/name.cpp index 17299ad..245bca6 100644 --- a/src/settings/wifi/name.cpp +++ b/src/settings/wifi/name.cpp @@ -16,100 +16,103 @@ namespace api { namespace settings { - void get_wifi_name(const httplib::Request &request, httplib::Response &response) + namespace wifi { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_wifi_name(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - wifi_name = wifisettingsbuffer; - wifi_name.erase(0, 5); - break; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - } - wifisettingsfile.close(); - std::stringstream responsedata; - responsedata << R"({"name":")" << wifi_name << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); - } + nlohmann::json json_body = nlohmann::json::parse(request.body); - 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 (!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) + if (!authenticate(json_body["token"])) { - old_wifi_name = wifisettingsbuffer; - old_wifi_name.erase(0, 5); - break; + response.set_content(R"({"access":"reject"})", JSON_TYPE); + return; } - } - wifisettingsfile.close(); - std::string new_wifi_name = json_body["name"]; - std::stringstream systemrequest; - systemrequest << "sed -i \"/ssid=" << old_wifi_name << "/s//ssid=" << new_wifi_name << "/\" /etc/hostapd/hostapd.conf"; - std::cout << systemrequest.str() << std::endl; - system(systemrequest.str().c_str()); - system("rc restart hostapd"); - std::string syslogstring = "WIFI name changed to " + new_wifi_name; - syslog(LOG_INFO, "%s", syslogstring.c_str()); - - std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH); - std::string wifi_name; - std::string changedwifisettingsbuffer; - while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) - { - if (changedwifisettingsbuffer.find("ssid=") == 0) + std::ifstream wifisettingsfile(WIFI_SETTINGS_PATH); + std::string wifi_name; + std::string wifisettingsbuffer; + while (std::getline(wifisettingsfile, wifisettingsbuffer)) { - wifi_name = changedwifisettingsbuffer; - wifi_name.erase(0, 5); - break; + if (wifisettingsbuffer.find("ssid=") == 0) + { + wifi_name = wifisettingsbuffer; + wifi_name.erase(0, 5); + break; + } } + wifisettingsfile.close(); + std::stringstream responsedata; + responsedata << R"({"name":")" << wifi_name << R"("})"; + response.set_content(responsedata.str(), 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 (!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 (!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) + { + old_wifi_name = wifisettingsbuffer; + old_wifi_name.erase(0, 5); + break; + } + } + wifisettingsfile.close(); + std::string new_wifi_name = json_body["name"]; + std::stringstream systemrequest; + systemrequest << "sed -i \"/ssid=" << old_wifi_name << "/s//ssid=" << new_wifi_name << "/\" /etc/hostapd/hostapd.conf"; + std::cout << systemrequest.str() << std::endl; + system(systemrequest.str().c_str()); + system("rc restart hostapd"); + std::string syslogstring = "WIFI name changed to " + new_wifi_name; + syslog(LOG_INFO, "%s", syslogstring.c_str()); + + std::ifstream changedwifisettingsfile(WIFI_SETTINGS_PATH); + std::string wifi_name; + std::string changedwifisettingsbuffer; + while (std::getline(changedwifisettingsfile, changedwifisettingsbuffer)) + { + if (changedwifisettingsbuffer.find("ssid=") == 0) + { + wifi_name = changedwifisettingsbuffer; + wifi_name.erase(0, 5); + break; + } + } + changedwifisettingsfile.close(); + std::stringstream responsedata; + responsedata << R"({"name":")" << wifi_name << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - changedwifisettingsfile.close(); - std::stringstream responsedata; - responsedata << R"({"name":")" << wifi_name << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } \ No newline at end of file diff --git a/src/settings/wifi/password.cpp b/src/settings/wifi/password.cpp index 6ece31b..2cdd928 100644 --- a/src/settings/wifi/password.cpp +++ b/src/settings/wifi/password.cpp @@ -16,97 +16,100 @@ namespace api { namespace settings { - void get_wifi_password(const httplib::Request &request, httplib::Response &response) + namespace wifi { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_wifi_password(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - wifi_password = wifisettingsbuffer; - wifi_password.erase(0, 15); - break; + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - } - wifisettingsfile.close(); - std::stringstream responsedata; - responsedata << R"({"password":")" << wifi_password << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); - } + nlohmann::json json_body = nlohmann::json::parse(request.body); - 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["newpassword"] == nullptr) - { - response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE); - return; - } - - 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) + if (!authenticate(json_body["token"])) { - old_wifi_password = wifisettingsbuffer; - old_wifi_password.erase(0, 15); - break; + 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) + { + wifi_password = wifisettingsbuffer; + wifi_password.erase(0, 15); + break; + } + } + wifisettingsfile.close(); + std::stringstream responsedata; + responsedata << R"({"password":")" << wifi_password << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - wifisettingsfile.close(); - std::string req_old_password = json_body["password"]; - if (old_wifi_password != req_old_password) + + void set_wifi_password(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"status":"reject"})", JSON_TYPE); - return; + 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["newpassword"] == nullptr) + { + response.set_content(WIFI_PASSWORD_REQUIRED_STRING, JSON_TYPE); + return; + } + + 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) + { + old_wifi_password = wifisettingsbuffer; + old_wifi_password.erase(0, 15); + break; + } + } + wifisettingsfile.close(); + std::string req_old_password = json_body["password"]; + if (old_wifi_password != req_old_password) + { + response.set_content(R"({"status":"reject"})", JSON_TYPE); + return; + } + std::string new_wifi_password = json_body["newpassword"]; + std::stringstream systemrequest; + systemrequest << "sed -i \"/wpa_passphrase=" << old_wifi_password << "/s//wpa_passphrase=" << new_wifi_password << "/\" /etc/hostapd/hostapd.conf"; + system(systemrequest.str().c_str()); + system("rc restart hostapd"); + std::string syslogstring = "WIFI password changed"; + syslog(LOG_INFO, "%s", syslogstring.c_str()); + std::stringstream responsedata; + responsedata << R"({"success":"ok"})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::string new_wifi_password = json_body["newpassword"]; - std::stringstream systemrequest; - systemrequest << "sed -i \"/wpa_passphrase=" << old_wifi_password << "/s//wpa_passphrase=" << new_wifi_password << "/\" /etc/hostapd/hostapd.conf"; - system(systemrequest.str().c_str()); - system("rc restart hostapd"); - std::string syslogstring = "WIFI password changed"; - syslog(LOG_INFO, "%s", syslogstring.c_str()); - std::stringstream responsedata; - responsedata << R"({"success":"ok"})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/wifi/qr.cpp b/src/settings/wifi/qr.cpp index 828bfe9..1901747 100644 --- a/src/settings/wifi/qr.cpp +++ b/src/settings/wifi/qr.cpp @@ -11,48 +11,51 @@ namespace api { namespace settings { - void get_wifi_qr(const httplib::Request &request, httplib::Response &response) + namespace wifi { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_wifi_qr(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); - - 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) + std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; + response.set_header("Access-Control-Allow-Origin", "*"); + if (!check_body(request)) { - wifi_name = wifisettingsbuffer; - wifi_name.erase(0, 5); + response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); + return; } - if (wifisettingsbuffer.find("wpa_passphrase=") == 0) + nlohmann::json json_body = nlohmann::json::parse(request.body); + + if (!authenticate(json_body["token"])) { - wifi_password = wifisettingsbuffer; - wifi_password.erase(0, 15); - break; + 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) + { + wifi_name = wifisettingsbuffer; + wifi_name.erase(0, 5); + } + if (wifisettingsbuffer.find("wpa_passphrase=") == 0) + { + wifi_password = wifisettingsbuffer; + wifi_password.erase(0, 15); + break; + } + } + wifisettingsfile.close(); + + 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); + std::string responsedata = toSvgString(qr0, 4); + response.set_content(responsedata, SVG_TYPE); } - wifisettingsfile.close(); - - 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); - std::string responsedata = toSvgString(qr0, 4); - response.set_content(responsedata, SVG_TYPE); } } } diff --git a/src/settings/wifi/status.cpp b/src/settings/wifi/status.cpp index 17c1797..fe0a8b6 100644 --- a/src/settings/wifi/status.cpp +++ b/src/settings/wifi/status.cpp @@ -12,76 +12,79 @@ namespace api { namespace settings { - void get_wifi_status(const httplib::Request &request, httplib::Response &response) + namespace wifi { - std::cout << GREEN << request.path << RESET << " " << request.method << std::endl; - response.set_header("Access-Control-Allow-Origin", "*"); - if (!check_body(request)) + void get_wifi_status(const httplib::Request &request, httplib::Response &response) { - response.set_content(ACCESS_REQUIRED_STRING, JSON_TYPE); - return; - } - nlohmann::json json_body = nlohmann::json::parse(request.body); + 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"])) - { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; - } - std::ifstream wifistatusfile("/etc/openrouter/wifi/status"); - int wifi_status; - wifistatusfile >> wifi_status; - wifistatusfile.close(); - std::stringstream responsedata; - responsedata << R"({"status":")" << wifi_status << R"("})"; - response.set_content(responsedata.str(), 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 (!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 (!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; + wifistatusfile.close(); + std::stringstream responsedata; + responsedata << R"({"status":")" << wifi_status << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - if (!authenticate(json_body["token"])) + void set_wifi_status(const httplib::Request &request, httplib::Response &response) { - response.set_content(R"({"access":"reject"})", JSON_TYPE); - return; + 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 (!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") + { + system("rc stop hostapd"); + system("rc del hostapd"); + syslog(LOG_INFO, "%s", "WIFI is disabled"); + } + else + { + system("rc start hostapd"); + system("rc add hostapd"); + syslog(LOG_INFO, "%s", "WIFI is enabled"); + } + wififileout << stoi(new_wifi_status); + wififileout.close(); + std::ifstream wififile("/etc/openrouter/wifi/status"); + int wifi_status; + wififile >> wifi_status; + wififile.close(); + std::stringstream responsedata; + responsedata << R"({"status":")" << wifi_status << R"("})"; + response.set_content(responsedata.str(), JSON_TYPE); } - std::ofstream wififileout("/etc/openrouter/wifi/status"); - std::string new_wifi_status = json_body["status"]; - if (new_wifi_status == "0") - { - system("rc stop hostapd"); - system("rc del hostapd"); - syslog(LOG_INFO, "%s", "WIFI is disabled"); - } - else - { - system("rc start hostapd"); - system("rc add hostapd"); - syslog(LOG_INFO, "%s", "WIFI is enabled"); - } - wififileout << stoi(new_wifi_status); - wififileout.close(); - std::ifstream wififile("/etc/openrouter/wifi/status"); - int wifi_status; - wififile >> wifi_status; - wififile.close(); - std::stringstream responsedata; - responsedata << R"({"status":")" << wifi_status << R"("})"; - response.set_content(responsedata.str(), JSON_TYPE); } } } diff --git a/src/settings/wifi/wifi.hpp b/src/settings/wifi/wifi.hpp index 82012ab..c7b9374 100644 --- a/src/settings/wifi/wifi.hpp +++ b/src/settings/wifi/wifi.hpp @@ -9,19 +9,22 @@ 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); + namespace wifi + { + 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); + } } }