wt/openrouter
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

deleted rootfs and auth_service

Browse Source
This commit is contained in:
wt committed 2024-12-15 01:58:36 +07:00
1 parent b694830190
commit 85652a4e99
156 files changed
-2051
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/settings/dns/dns.hpp
+21
View File
@@ -0,0 +1,21 @@
#ifndef DNS_HPP
#define DNS_HPP
#include <httplib.h>
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_local_domains(const httplib::Request &request, httplib::Response &response);
void set_local_domains(const httplib::Request &request, httplib::Response &response);
}
}
#endif // DNS_HPP
src/settings/dns/enabled.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "dns.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define DNS_REQUIRED_STRING R"({"required":"[token,enabled]"})"
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);
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::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);
}
}
}
src/settings/dns/local_domains.cpp
+91
View File
@@ -0,0 +1,91 @@
#include "dns.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
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);
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);
}
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"]))
{
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);
}
}
}
src/settings/dns/servers.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "dns.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
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);
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);
}
}
}
src/settings/ftp/ftp.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "ftp.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define FTP_REQUIRED_STRING R"({"required":"[token,enabled]"})"
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);
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::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);
}
}
}
src/settings/ftp/ftp.hpp
+15
View File
@@ -0,0 +1,15 @@
#ifndef FTP_HPP
#define FTP_HPP
#include <httplib.h>
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
src/settings/settings.hpp
+10
View File
@@ -0,0 +1,10 @@
#ifndef SETTINGS_HPP
#define SETTINGS_HPP
#include "wifi/wifi.hpp"
#include "telnet/telnet.hpp"
#include "ssh/ssh.hpp"
#include "ftp/ftp.hpp"
#include "dns/dns.hpp"
#endif // SETTINGS_HPP
src/settings/ssh/keys.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "ssh.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define KEYS_PATH "/root/.ssh/authorized_keys"
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);
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);
}
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"]))
{
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);
}
}
}
src/settings/ssh/port.cpp
+91
View File
@@ -0,0 +1,91 @@
#include "ssh.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#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 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);
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 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;
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());
system("rc restart ssh");
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);
}
}
}
src/settings/ssh/ssh.hpp
+21
View File
@@ -0,0 +1,21 @@
#ifndef SSH_HPP
#define SSH_HPP
#include <httplib.h>
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_port(const httplib::Request &request, httplib::Response &response);
void set_ssh_port(const httplib::Request &request, httplib::Response &response);
}
}
#endif // SSH_HPP
src/settings/ssh/status.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "ssh.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define SSH_REQUIRED_STRING R"({"required":"[token,status]"})"
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);
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")
{
system("rc stop ssh");
system("rc del ssh");
syslog(LOG_INFO, "%s", "SSH is disabled");
}
else
{
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);
}
}
}
src/settings/telnet/enabled.cpp
+91
View File
@@ -0,0 +1,91 @@
#include "telnet.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define TELNET_REQUIRED_STRING R"({"required":"[token,enabled]"})"
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);
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::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);
}
}
}
src/settings/telnet/port.cpp
+82
View File
@@ -0,0 +1,82 @@
#include "telnet.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define TELNET_PORT_REQUIRED_STRING R"({"required":"[token,port]"})"
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);
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::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);
}
}
}
src/settings/telnet/telnet.hpp
+18
View File
@@ -0,0 +1,18 @@
#ifndef SETTINGS_TELNET_HPP
#define SETTINGS_TELNET_HPP
#include <httplib.h>
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);
}
}
#endif // SETTINGS_TELNET_HPP
src/settings/wifi/channel.cpp
+115
View File
@@ -0,0 +1,115 @@
#include "wifi.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define WIFI_CHANNEL_REQUIRED_STRING R"({"required":"[token,channel]"})"
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);
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)
{
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);
}
}
}
src/settings/wifi/name.cpp
+115
View File
@@ -0,0 +1,115 @@
#include "wifi.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define WIFI_NAME_REQUIRED_STRING R"({"required":"[token,name]"})"
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);
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)
{
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);
}
}
}
src/settings/wifi/password.cpp
+112
View File
@@ -0,0 +1,112 @@
#include "wifi.hpp"
#include <colors.h>
#include "../../types.hpp"
#include <json.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define WIFI_PASSWORD_REQUIRED_STRING R"({"required":"[token,password,newpassword]"})"
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);
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)
{
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);
}
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)
{
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);
}
}
}
src/settings/wifi/qr.cpp
+58
View File
@@ -0,0 +1,58 @@
#include "wifi.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <QR-Code-generator/qrcodegen.hpp>
#include <QR-Code-generator/qrtosvg.hpp>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
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);
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)
{
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);
}
}
}
src/settings/wifi/status.cpp
+87
View File
@@ -0,0 +1,87 @@
#include "wifi.hpp"
#include <colors.h>
#include <json.hpp>
#include "../../types.hpp"
#include <syslog.h>
#include "../../auth/auth.hpp"
#include "../../helpers.hpp"
#define WIFI_REQUIRED_STRING R"({"required":"[token,status]"})"
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"]))
{
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::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);
}
}
}
src/settings/wifi/wifi.hpp
+28
View File
@@ -0,0 +1,28 @@
#ifndef WIFI_HPP
#define WIFI_HPP
#include <httplib.h>
#define WIFI_SETTINGS_PATH "/etc/hostapd/hostapd.conf"
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_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_channel(const httplib::Request &request, httplib::Response &response);
void set_wifi_channel(const httplib::Request &request, httplib::Response &response);
}
}
#endif // WIFI_HPP