eng33
699 lines
26 KiB
C++
699 lines
26 KiB
C++
// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "network_api.h"
|
|
#include "common.h"
|
|
#include <time.h>
|
|
|
|
namespace rockchip {
|
|
namespace cgi {
|
|
|
|
#ifdef USE_RKIPC
|
|
|
|
nlohmann::json network_get_config(std::string interface) {
|
|
int speed, duplex, autoneg;
|
|
char mac[64];
|
|
char dns1[64];
|
|
char dns2[64];
|
|
char method[64];
|
|
char address[64];
|
|
char netmask[64];
|
|
char gateway[64];
|
|
char nic_support[256];
|
|
nlohmann::json config, ipv4, link;
|
|
|
|
rk_network_ipv4_get(interface.c_str(), method, address, netmask, gateway);
|
|
ipv4.emplace("sV4Address", address);
|
|
ipv4.emplace("sV4Gateway", gateway);
|
|
ipv4.emplace("sV4Method", method);
|
|
ipv4.emplace("sV4Netmask", netmask);
|
|
|
|
rk_network_dns_get(dns1, dns2);
|
|
link.emplace("sDNS1", dns1);
|
|
link.emplace("sDNS2", dns2);
|
|
rk_network_get_mac(interface.c_str(), mac);
|
|
link.emplace("sAddress", mac);
|
|
link.emplace("sInterface", interface.c_str());
|
|
|
|
if (!interface.compare("wlan0")) {
|
|
link.emplace("iPower", 1); // todo
|
|
} else {
|
|
// default eth0 on
|
|
link.emplace("iPower", 1);
|
|
rk_network_nicspeed_get(interface.c_str(), &speed, &duplex, &autoneg);
|
|
link.emplace("iDuplex", duplex);
|
|
link.emplace("iNicSpeed", speed);
|
|
if (autoneg)
|
|
link.emplace("sNicSpeed", "Auto");
|
|
else if ((speed == 10) && (duplex == 0))
|
|
link.emplace("sNicSpeed", "10baseT/Half");
|
|
else if ((speed == 10) && (duplex == 1))
|
|
link.emplace("sNicSpeed", "10baseT/Full");
|
|
else if ((speed == 100) && (duplex == 0))
|
|
link.emplace("sNicSpeed", "100baseT/Half");
|
|
else if ((speed == 100) && (duplex == 1))
|
|
link.emplace("sNicSpeed", "100baseT/Full");
|
|
else if ((speed == 1000) && (duplex == 1))
|
|
link.emplace("sNicSpeed", "1000baseT/Full");
|
|
rk_network_nicspeed_support_get(interface.c_str(), nic_support);
|
|
link.emplace("sNicSpeedSupport", nic_support);
|
|
}
|
|
|
|
config.emplace("ipv4", ipv4);
|
|
config.emplace("link", link);
|
|
|
|
return config;
|
|
}
|
|
|
|
nlohmann::json wifi_power_get() {
|
|
nlohmann::json config;
|
|
int on;
|
|
rk_wifi_power_get(&on);
|
|
config.emplace("iPower", on);
|
|
config.emplace("id", 1);
|
|
config.emplace("sType", "wifi");
|
|
|
|
return config;
|
|
}
|
|
|
|
nlohmann::json wifi_list_get() {
|
|
nlohmann::json config;
|
|
char *wifi_list = NULL;
|
|
rk_wifi_get_list(&wifi_list);
|
|
config = nlohmann::json::parse(wifi_list);
|
|
free(wifi_list);
|
|
|
|
return config;
|
|
}
|
|
|
|
void NetworkApiHandler::handler(const HttpRequest &Req, HttpResponse &Resp) {
|
|
char *str;
|
|
char pService[255];
|
|
nlohmann::json content;
|
|
std::string path_api_resource;
|
|
std::string path_specific_resource;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
|
|
// Get Path Information
|
|
int pos_first = Req.PathInfo.find_first_of("/");
|
|
path_api_resource = Req.PathInfo.substr(pos_first + 1, Req.PathInfo.size());
|
|
pos_first = path_api_resource.find_first_of("/");
|
|
if (pos_first != -1) {
|
|
path_specific_resource =
|
|
path_api_resource.substr(pos_first + 1, path_api_resource.size());
|
|
}
|
|
|
|
if (Req.Method == "GET") {
|
|
if (!path_specific_resource.compare("lan")) {
|
|
content = network_get_config("eth0");
|
|
} else if (!path_specific_resource.compare("wlan")) {
|
|
content = network_get_config("wlan0");
|
|
} else if (!path_specific_resource.compare("wifi")) {
|
|
content = wifi_power_get();
|
|
} else if (!path_specific_resource.compare("wifi-list")) {
|
|
content = wifi_list_get();
|
|
} else if (!path_specific_resource.compare("auto-cnt-wifi")) {
|
|
// str = dbserver_sql((char *)"select sService from NetworkService WHERE
|
|
// (iAutoconnect = 1) LIMIT 1",
|
|
// (char *)DBSERVER_NET_INTERFACE);
|
|
// content = nlohmann::json::parse(str).at("jData");
|
|
}
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
nlohmann::json cfg_new = Req.PostObject; // must be json::object
|
|
std::string interface;
|
|
// Set network/wlan or network/lan
|
|
if (path_specific_resource.find("lan") != std::string::npos) {
|
|
if (!path_specific_resource.compare("lan"))
|
|
interface = "eth0";
|
|
else if (!path_specific_resource.compare("wlan"))
|
|
interface = "wlan0";
|
|
nlohmann::json cfg_old = network_get_config(interface);
|
|
nlohmann::json diff = nlohmann::json::diff(cfg_old, cfg_new);
|
|
// Set according to the differences
|
|
// Set DNS1 and DNS2
|
|
if (diff.dump().find("link") != diff.dump().npos) {
|
|
std::string dns1 = "";
|
|
std::string dns2 = "";
|
|
std::string sNicSpeed = cfg_new.at("link").at("sNicSpeed").dump();
|
|
std::string Method = cfg_new.at("ipv4").at("sV4Method").dump();
|
|
sNicSpeed.erase(0, 1).erase(sNicSpeed.end() - 1, sNicSpeed.end());
|
|
Method.erase(0, 1).erase(Method.end() - 1, Method.end()); // erase \"
|
|
if (Method == "manual") {
|
|
dns1 = cfg_new.at("link").at("sDNS1").dump();
|
|
dns2 = cfg_new.at("link").at("sDNS2").dump();
|
|
dns1.erase(0, 1).erase(dns1.end() - 1, dns1.end());
|
|
dns2.erase(0, 1).erase(dns2.end() - 1, dns2.end());
|
|
}
|
|
rk_network_dns_set((char *)dns1.c_str(), (char *)dns2.c_str());
|
|
|
|
if (!sNicSpeed.compare("10baseT/Half"))
|
|
rk_network_nicspeed_set((char *)interface.c_str(), 10, 0, 0);
|
|
else if (!sNicSpeed.compare("10baseT/Full"))
|
|
rk_network_nicspeed_set((char *)interface.c_str(), 10, 1, 0);
|
|
else if (!sNicSpeed.compare("100baseT/Half"))
|
|
rk_network_nicspeed_set((char *)interface.c_str(), 100, 0, 0);
|
|
else if (!sNicSpeed.compare("100baseT/Full"))
|
|
rk_network_nicspeed_set((char *)interface.c_str(), 100, 1, 0);
|
|
else if (!sNicSpeed.compare("1000baseT/Full"))
|
|
rk_network_nicspeed_set((char *)interface.c_str(), 1000, 1, 0);
|
|
else
|
|
rk_network_nicspeed_set((char *)interface.c_str(), -1, -1, 1);
|
|
}
|
|
if (diff.dump().find("ipv4") != diff.dump().npos) {
|
|
nlohmann::json cfg_ipv4 = cfg_new.at("ipv4");
|
|
std::string Method = cfg_ipv4.at("sV4Method").dump();
|
|
Method.erase(0, 1).erase(Method.end() - 1, Method.end()); // erase \"
|
|
if (Method == "manual") {
|
|
std::string Address = cfg_ipv4.at("sV4Address").dump();
|
|
Address.erase(0, 1).erase(Address.end() - 1, Address.end());
|
|
std::string Netmask = cfg_ipv4.at("sV4Netmask").dump();
|
|
Netmask.erase(0, 1).erase(Netmask.end() - 1, Netmask.end());
|
|
std::string Gateway = cfg_ipv4.at("sV4Gateway").dump();
|
|
Gateway.erase(0, 1).erase(Gateway.end() - 1, Gateway.end());
|
|
rk_network_ipv4_set((char *)interface.c_str(), (char *)"static",
|
|
(char *)Address.c_str(), (char *)Netmask.c_str(),
|
|
(char *)Gateway.c_str());
|
|
} else {
|
|
rk_network_ipv4_set((char *)interface.c_str(), (char *)"dhcp", NULL,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
// Update info
|
|
content = network_get_config(interface);
|
|
} else if (!path_specific_resource.compare("wifi")) {
|
|
// Set wifi power
|
|
if (!Req.Params.empty()) {
|
|
for (auto p : Req.Params) {
|
|
if (p.Key == "power") {
|
|
if (p.Value == "on")
|
|
rk_wifi_power_set(1);
|
|
else
|
|
rk_wifi_power_set(0);
|
|
content = wifi_power_get();
|
|
} else if (p.Key == "scan") {
|
|
rk_wifi_scan_wifi();
|
|
content = wifi_list_get();
|
|
}
|
|
}
|
|
}
|
|
// Set wifi connect
|
|
if (!cfg_new.empty()) {
|
|
std::string ssid = cfg_new.at("sName").dump();
|
|
ssid.erase(0, 1).erase(ssid.end() - 1, ssid.end());
|
|
std::string password = cfg_new.at("sPassword").dump();
|
|
password.erase(0, 1).erase(password.end() - 1, password.end());
|
|
rk_wifi_connect_with_ssid(ssid.c_str(), password.c_str());
|
|
content = wifi_list_get();
|
|
}
|
|
}
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if (Req.Method == "DELETE") {
|
|
if (!path_specific_resource.compare("wifi")) {
|
|
for (auto p : Req.Params) {
|
|
if (p.Key == "service") {
|
|
std::string ssid = p.Value;
|
|
rk_wifi_forget_with_ssid(ssid.c_str());
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
}
|
|
}
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kBadRequest, "Not Implemented");
|
|
}
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkNTPApiHandler::handler(const HttpRequest &Req, HttpResponse &Resp) {
|
|
nlohmann::json content;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
if (Req.Method == "GET") {
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkDDNSApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
nlohmann::json content;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
if (Req.Method == "GET") {
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkPPPoEApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
nlohmann::json content;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
if (Req.Method == "GET") {
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkPortApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
nlohmann::json content;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
if (Req.Method == "GET") {
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
#else // USE_RKIPC
|
|
|
|
nlohmann::json network_get_config(std::string interface) {
|
|
char *str = netserver_get_networkip((char *)interface.c_str());
|
|
nlohmann::json config = nlohmann::json::parse(str).at(0);
|
|
std::string dns1 = "";
|
|
std::string dns2 = "";
|
|
std::string duplex_s = "";
|
|
int duplex = config.at("link").at("iDuplex");
|
|
int speed = config.at("link").at("iNicSpeed");
|
|
std::string v4_method = config.at("dbconfig").at("sV4Method");
|
|
std::string sNicSpeed = config.at("dbconfig").at("sNicSpeed");
|
|
|
|
config.at("link").erase("sNicSpeed");
|
|
config.at("link").emplace("sNicSpeed", sNicSpeed);
|
|
if (!v4_method.compare("manual")) {
|
|
dns1 = config.at("dbconfig").at("sDNS1");
|
|
dns2 = config.at("dbconfig").at("sDNS2");
|
|
config.at("link").erase("sDNS1");
|
|
config.at("link").erase("sDNS2");
|
|
config.at("link").emplace("sDNS1", dns1);
|
|
config.at("link").emplace("sDNS2", dns2);
|
|
}
|
|
config.erase("dbconfig");
|
|
config.at("ipv4").emplace("sV4Method", v4_method);
|
|
|
|
return config;
|
|
}
|
|
|
|
void NetworkApiHandler::handler(const HttpRequest &Req, HttpResponse &Resp) {
|
|
char *str;
|
|
char pService[255];
|
|
nlohmann::json content;
|
|
std::string path_api_resource;
|
|
std::string path_specific_resource;
|
|
#ifdef ENABLE_JWT
|
|
int user_level = Req.UserLevel;
|
|
#endif
|
|
|
|
// Get Path Information
|
|
int pos_first = Req.PathInfo.find_first_of("/");
|
|
path_api_resource = Req.PathInfo.substr(pos_first + 1, Req.PathInfo.size());
|
|
pos_first = path_api_resource.find_first_of("/");
|
|
if (pos_first != -1) {
|
|
path_specific_resource =
|
|
path_api_resource.substr(pos_first + 1, path_api_resource.size());
|
|
}
|
|
|
|
if (Req.Method == "GET") {
|
|
if (!path_specific_resource.compare("lan")) {
|
|
content = network_get_config("eth0");
|
|
} else if (!path_specific_resource.compare("wlan")) {
|
|
content = network_get_config("wlan0");
|
|
} else if (!path_specific_resource.compare("wifi")) {
|
|
str = dbserver_wifi_power_get();
|
|
content = nlohmann::json::parse(str).at("jData").at(0);
|
|
} else if (!path_specific_resource.compare("wifi-list")) {
|
|
str = netserver_get_service((char *)"wifi");
|
|
content = nlohmann::json::parse(str);
|
|
} else if (!path_specific_resource.compare("auto-cnt-wifi")) {
|
|
str = dbserver_sql((char *)"select sService from NetworkService WHERE "
|
|
"(iAutoconnect = 1) LIMIT 1",
|
|
(char *)DBSERVER_NET_INTERFACE);
|
|
content = nlohmann::json::parse(str).at("jData");
|
|
}
|
|
|
|
if (!content.empty()) {
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
}
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
#ifdef ENABLE_JWT
|
|
if (user_level > 1) {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Unauthorized");
|
|
return;
|
|
}
|
|
#endif
|
|
nlohmann::json cfg_new = Req.PostObject; // must be json::object
|
|
std::string interface;
|
|
// Set network/wlan or network/lan
|
|
if (path_specific_resource.find("lan") != std::string::npos) {
|
|
if (!path_specific_resource.compare("lan"))
|
|
interface = "eth0";
|
|
else if (!path_specific_resource.compare("wlan"))
|
|
interface = "wlan0";
|
|
nlohmann::json cfg_old = network_get_config(interface);
|
|
nlohmann::json diff = nlohmann::json::diff(cfg_old, cfg_new);
|
|
// Set according to the differences
|
|
if (diff.dump().find("ipv4") != diff.dump().npos) {
|
|
nlohmann::json cfg_ipv4 = cfg_new.at("ipv4");
|
|
std::string Method = cfg_ipv4.at("sV4Method").dump();
|
|
Method.erase(0, 1).erase(Method.end() - 1, Method.end()); // erase \"
|
|
if (Method == "manual") {
|
|
std::string Address = cfg_ipv4.at("sV4Address").dump();
|
|
Address.erase(0, 1).erase(Address.end() - 1, Address.end());
|
|
std::string Netmask = cfg_ipv4.at("sV4Netmask").dump();
|
|
Netmask.erase(0, 1).erase(Netmask.end() - 1, Netmask.end());
|
|
std::string Gateway = cfg_ipv4.at("sV4Gateway").dump();
|
|
Gateway.erase(0, 1).erase(Gateway.end() - 1, Gateway.end());
|
|
dbserver_network_ipv4_set((char *)interface.c_str(), (char *)"manual",
|
|
(char *)Address.c_str(),
|
|
(char *)Netmask.c_str(),
|
|
(char *)Gateway.c_str());
|
|
} else {
|
|
dbserver_network_ipv4_set((char *)interface.c_str(), (char *)"dhcp",
|
|
NULL, NULL, NULL);
|
|
}
|
|
}
|
|
// Set DNS1 and DNS2
|
|
if (diff.dump().find("link") != diff.dump().npos) {
|
|
std::string dns1 = "";
|
|
std::string dns2 = "";
|
|
std::string sNicSpeed = cfg_new.at("link").at("sNicSpeed").dump();
|
|
std::string Method = cfg_new.at("ipv4").at("sV4Method").dump();
|
|
sNicSpeed.erase(0, 1).erase(sNicSpeed.end() - 1, sNicSpeed.end());
|
|
Method.erase(0, 1).erase(Method.end() - 1, Method.end()); // erase \"
|
|
if (Method == "manual") {
|
|
dns1 = cfg_new.at("link").at("sDNS1").dump();
|
|
dns2 = cfg_new.at("link").at("sDNS2").dump();
|
|
dns1.erase(0, 1).erase(dns1.end() - 1, dns1.end());
|
|
dns2.erase(0, 1).erase(dns2.end() - 1, dns2.end());
|
|
}
|
|
dbserver_network_dns_set((char *)interface.c_str(),
|
|
(char *)dns1.c_str(), (char *)dns2.c_str());
|
|
dbserver_network_nicspeed_set((char *)interface.c_str(),
|
|
(char *)sNicSpeed.c_str());
|
|
}
|
|
// Update info
|
|
content = network_get_config(interface);
|
|
} else if (!path_specific_resource.compare("wifi")) {
|
|
// Set wifi power
|
|
if (!Req.Params.empty()) {
|
|
for (auto p : Req.Params) {
|
|
if (p.Key == "power") {
|
|
if (p.Value == "on")
|
|
dbserver_wifi_power_set(1);
|
|
else
|
|
dbserver_wifi_power_set(0);
|
|
str = dbserver_wifi_power_get();
|
|
content = nlohmann::json::parse(str).at("jData").at(0);
|
|
} else if (p.Key == "scan") {
|
|
netserver_scan_wifi();
|
|
str = netserver_get_service((char *)"wifi");
|
|
content = nlohmann::json::parse(str);
|
|
}
|
|
}
|
|
}
|
|
// Set wifi connect
|
|
if (!cfg_new.empty()) {
|
|
// netserver_scan_wifi();
|
|
str = netserver_get_service((char *)"wifi");
|
|
nlohmann::json wifi_list = nlohmann::json::parse(str);
|
|
std::string service = cfg_new.at("sService").dump();
|
|
service.erase(0, 1).erase(service.end() - 1, service.end());
|
|
std::string password = cfg_new.at("sPassword").dump();
|
|
password.erase(0, 1).erase(password.end() - 1, password.end());
|
|
int favorite = 1; // invalid parameter
|
|
int autoconnect = atoi(cfg_new.at("iAutoconnect").dump().c_str());
|
|
dbserver_network_service_connect_set((char *)service.c_str(),
|
|
(char *)password.c_str(),
|
|
&favorite, &autoconnect);
|
|
str = netserver_get_config((char *)service.c_str());
|
|
content = nlohmann::json::parse(str);
|
|
}
|
|
}
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if (Req.Method == "DELETE") {
|
|
if (!path_specific_resource.compare("wifi")) {
|
|
for (auto p : Req.Params) {
|
|
if (p.Key == "service") {
|
|
std::string service = p.Value;
|
|
dbserver_network_service_delete((char *)service.c_str());
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
}
|
|
}
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kBadRequest, "Not Implemented");
|
|
}
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkNTPApiHandler::handler(const HttpRequest &Req, HttpResponse &Resp) {
|
|
char *str;
|
|
std::string path_api_resource;
|
|
std::string path_specific_resource;
|
|
nlohmann::json content;
|
|
|
|
/* Get Path Information */
|
|
int pos_first = Req.PathInfo.find_first_of("/");
|
|
path_api_resource = Req.PathInfo.substr(pos_first + 1, Req.PathInfo.size());
|
|
pos_first = path_api_resource.find_first_of("/");
|
|
if (pos_first != -1) {
|
|
path_specific_resource =
|
|
path_api_resource.substr(pos_first + 1, path_api_resource.size());
|
|
}
|
|
|
|
if (Req.Method == "GET") {
|
|
if (path_specific_resource.empty()) {
|
|
str = dbserver_ntp_get();
|
|
content = nlohmann::json::parse(str).at("jData").at(0);
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if (path_specific_resource.find("zone") != std::string::npos) {
|
|
str = dbserver_zone_get();
|
|
content = nlohmann::json::parse(str).at("jData");
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if (path_specific_resource.find("time") != std::string::npos) {
|
|
content.emplace("time", current_time_get());
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
if (path_specific_resource.empty()) {
|
|
if (!Req.PostObject.empty()) {
|
|
nlohmann::json ntp_config = Req.PostObject;
|
|
std::string service = ntp_config.at("sNtpServers").dump();
|
|
service.erase(0, 1).erase(service.end() - 1, service.end()); // erase \"
|
|
std::string zone = ntp_config.at("sTimeZone").dump();
|
|
zone.erase(0, 1).erase(zone.end() - 1, zone.end());
|
|
std::string zone_file = ntp_config.at("sTimeZoneFile").dump();
|
|
zone_file.erase(0, 1).erase(zone_file.end() - 1, zone_file.end());
|
|
std::string zone_file_dst = ntp_config.at("sTimeZoneFileDst").dump();
|
|
zone_file_dst.erase(0, 1).erase(zone_file_dst.end() - 1,
|
|
zone_file_dst.end());
|
|
// automatic daylight saving time
|
|
int auto_dst = atoi(ntp_config.at("iAutoDst").dump().c_str());
|
|
int update_time = atoi(ntp_config.at("iRefreshTime").dump().c_str());
|
|
int auto_mode = atoi(ntp_config.at("iAutoMode").dump().c_str());
|
|
dbserver_ntp_set((char *)service.c_str(), (char *)zone.c_str(),
|
|
(char *)zone_file.c_str(),
|
|
(char *)zone_file_dst.c_str(), &auto_dst, &auto_mode,
|
|
&update_time);
|
|
}
|
|
// Update info
|
|
content = nlohmann::json::parse(dbserver_ntp_get()).at("jData").at(0);
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if (path_specific_resource.find("time") != std::string::npos) {
|
|
nlohmann::json time_config = Req.PostObject;
|
|
std::string time_s = time_config.at("time");
|
|
time_t stamp_time = standard_to_timestamp(time_s);
|
|
int ret = stime(&stamp_time);
|
|
system("hwclock -w -u");
|
|
if (!ret) {
|
|
content.emplace("time", current_time_get());
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kUnauthorized, "Set Time Fail");
|
|
}
|
|
}
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkDDNSApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
if (Req.Method == "GET") {
|
|
nlohmann::json content = nlohmann::json::array();
|
|
auto TEST = R"(
|
|
{
|
|
"enable":"true",
|
|
"DDNSType":"HiDDNS",
|
|
"serveraddress":"www.rock-chips.com",
|
|
"hostName":"wzy02",
|
|
"port":""
|
|
}
|
|
)"_json;
|
|
content.push_back(TEST);
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkPPPoEApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
if (Req.Method == "GET") {
|
|
nlohmann::json content = nlohmann::json::array();
|
|
auto TEST = R"(
|
|
{
|
|
"enable":"true",
|
|
"deviceDynamicIP":"0.0.0.0",
|
|
"userName":"admin",
|
|
"password":"123456",
|
|
"passwordConfirmation":"123456"
|
|
}
|
|
)"_json;
|
|
content.push_back(TEST);
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
void NetworkPortApiHandler::handler(const HttpRequest &Req,
|
|
HttpResponse &Resp) {
|
|
if (Req.Method == "GET") {
|
|
nlohmann::json content;
|
|
char *str = dbserver_port_get();
|
|
nlohmann::json port_all_config = nlohmann::json::parse(str).at("jData");
|
|
nlohmann::json port_current_config;
|
|
int pos_first = Req.PathInfo.find_first_of("/");
|
|
int pos_last = Req.PathInfo.find_last_of("/");
|
|
|
|
if (pos_first != pos_last) {
|
|
int id =
|
|
atoi(Req.PathInfo.substr(pos_last + 1, Req.PathInfo.size()).c_str());
|
|
port_current_config = port_all_config.at(id);
|
|
content = port_current_config;
|
|
} else {
|
|
content = port_all_config;
|
|
}
|
|
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else if ((Req.Method == "POST") || (Req.Method == "PUT")) {
|
|
nlohmann::json content = nlohmann::json::object();
|
|
nlohmann::json port_config = Req.PostObject; // must be json::object
|
|
int id = 0;
|
|
int pos_first = Req.PathInfo.find_first_of("/");
|
|
int pos_last = Req.PathInfo.find_last_of("/");
|
|
if (pos_first != pos_last)
|
|
id = atoi(Req.PathInfo.substr(pos_last + 1, Req.PathInfo.size()).c_str());
|
|
|
|
// Erase unchanged data
|
|
char *prev = dbserver_port_get();
|
|
nlohmann::json cfg_old_all = nlohmann::json::parse(prev).at("jData");
|
|
nlohmann::json diff = nlohmann::json::diff(cfg_old_all.at(id), port_config);
|
|
for (auto &x : nlohmann::json::iterator_wrapper(cfg_old_all.at(id))) {
|
|
if (diff.dump().find(x.key()) == diff.dump().npos)
|
|
port_config.erase(x.key());
|
|
}
|
|
// The port protocol cannot be changed
|
|
if (port_config.dump().find("sProtocol") != port_config.dump().npos)
|
|
port_config.erase("sProtocol");
|
|
|
|
// Set new config, only one table is transmitted at a time.
|
|
if (!port_config.empty())
|
|
dbserver_port_set((char *)port_config.dump().c_str(), id);
|
|
|
|
// Get new info
|
|
char *str = dbserver_port_get();
|
|
nlohmann::json port_all_config = nlohmann::json::parse(str).at("jData");
|
|
content = port_all_config.at(id);
|
|
Resp.setHeader(HttpStatus::kOk, "OK");
|
|
Resp.setApiData(content);
|
|
} else {
|
|
Resp.setErrorResponse(HttpStatus::kNotImplemented, "Not Implemented");
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace cgi
|
|
} // namespace rockchip
|