1496 lines
47 KiB
C++
1496 lines
47 KiB
C++
#include <shared_mutex>
|
|
#include <terminal_api/ControlProtoCInterface.h>
|
|
#include "system_client.h"
|
|
|
|
std::shared_mutex mtx;
|
|
TSID sid_counter { 0 };
|
|
std::map<TSID, std::unique_ptr<system_client>> clients;
|
|
|
|
EXTERNC CP_Result CP_SetQoSSettings(TSID sid, const std::string &qos_settings_json, bool is_enable){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto resp = clients[sid]->send_set_qos_settings_json(qos_settings_json, is_enable);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetQoSSettings(TSID sid, std::string &qos_settings_json, bool &is_enable){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_get_qos_settings_json(qos_settings_json, is_enable);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetBUC_LNB_settings(TSID sid, buc_lnb_settings &settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto settings_ = reinterpret_cast<buc_lnb_settings_com&>(settings);
|
|
auto resp = clients[sid]->send_set_buc_lnb_settings(settings_);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetBUC_LNB_settings(TSID sid, buc_lnb_settings &settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
buc_lnb_settings_com settings_com;
|
|
auto resp = clients[sid]->send_get_buc_lnb_settings(settings_com);
|
|
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
settings = reinterpret_cast<buc_lnb_settings&>(settings_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
EXTERNC CP_Result CP_SetModulatorSettings(TSID sid, modulator_settings& settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto settings_ = reinterpret_cast<modulator_settings_com&>(settings);
|
|
auto resp = clients[sid]->send_set_modulator_settings(settings_);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
EXTERNC CP_Result CP_SetDemodulatorSettings(TSID sid, demodulator_settings& settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto settings_ = reinterpret_cast<demodulator_settings_com&>(settings);
|
|
auto resp = clients[sid]->send_set_demodulator_settings(settings_);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
EXTERNC CP_Result CP_GetModulatorSettings(TSID sid, modulator_settings& settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
modulator_settings_com settings_com;
|
|
auto resp = clients[sid]->send_get_modulator_settings(settings_com);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
settings = reinterpret_cast<modulator_settings&>(settings_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
EXTERNC CP_Result CP_GetDemodulatorSettings(TSID sid, demodulator_settings& settings){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
demodulator_settings_com settings_com;
|
|
auto resp = clients[sid]->send_get_demodulator_settings(settings_com);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
std::cout << "settings_com.rollof: " << settings_com.rollof << std::endl;
|
|
std::cout << "settings_com.gain: " << settings_com.gain << std::endl;
|
|
settings = reinterpret_cast<demodulator_settings&>(settings_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDemodulatorState(TSID sid, demodulator_state &state){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
demodulator_state_com state_com;
|
|
auto resp = clients[sid]->send_get_demodulator_state(state_com);
|
|
|
|
if (resp == response_type::error)
|
|
{
|
|
std::cout << "error" << std::endl;
|
|
return ERROR;
|
|
}
|
|
state = reinterpret_cast<demodulator_state&>(state_com);
|
|
state.locks = reinterpret_cast<demodulator_locks&>(state_com.locks);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
}
|
|
EXTERNC CP_Result CP_GetModulatorState(TSID sid, modulator_state &state){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
modulator_state_com state_com;
|
|
auto resp = clients[sid]->send_get_modulator_state(state_com);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
state = reinterpret_cast<modulator_state&>(state_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetCinCState(TSID sid, CinC_state &state){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
CinC_state_com state_com;
|
|
auto resp = clients[sid]->send_get_cinc_state(state_com);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
state = reinterpret_cast<CinC_state&>(state_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDeviceState(TSID sid, device_state &state){
|
|
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
device_state_com state_com;
|
|
auto resp = clients[sid]->send_get_device_state(state_com);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
state = reinterpret_cast<device_state&>(state_com);
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetRollofBaudrate(TSID sid, double rollof, double baudrate)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto resp = clients[sid]->send_rollof_and_baudrate(rollof, baudrate);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetQoSParams(TSID sid, const std::string &type_node, const std::string & node)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
name_classes_qos name_class;
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
if(type_node == "realtime1")
|
|
{
|
|
name_class = name_classes_qos::realtime1;
|
|
}
|
|
else if(type_node == "realtime2")
|
|
{
|
|
name_class = name_classes_qos::realtime2;
|
|
}
|
|
else if(type_node == "realtime3")
|
|
{
|
|
name_class = name_classes_qos::realtime3;
|
|
}
|
|
else if(type_node == "critical1")
|
|
{
|
|
name_class = name_classes_qos::critical1;
|
|
}
|
|
else if(type_node == "critical2")
|
|
{
|
|
name_class = name_classes_qos::critical2;
|
|
}
|
|
else if(type_node == "critical3")
|
|
{
|
|
name_class = name_classes_qos::critical3;
|
|
}
|
|
else if(type_node == "cir")
|
|
{
|
|
name_class = name_classes_qos::cir;
|
|
}
|
|
else if(type_node == "pir")
|
|
{
|
|
name_class = name_classes_qos::pir;
|
|
}
|
|
else if(type_node == "wcr1")
|
|
{
|
|
name_class = name_classes_qos::wcr1;
|
|
}
|
|
else if(type_node == "wcr2")
|
|
{
|
|
name_class = name_classes_qos::wcr2;
|
|
}
|
|
else if(type_node == "wcr3")
|
|
{
|
|
name_class = name_classes_qos::wcr3;
|
|
}
|
|
else if(type_node == "enable")
|
|
{
|
|
name_class = name_classes_qos::enable;
|
|
}
|
|
else if(type_node == "ful_node")
|
|
{
|
|
name_class = name_classes_qos::ful_node;
|
|
}
|
|
|
|
auto resp = clients[sid]->send_set_qos_params(node, name_class);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetQoSParams(TSID sid, const std::string &type_node, std::string * node)
|
|
{
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
std::string node_ = std::string();
|
|
name_classes_qos name_class;
|
|
if(type_node == "realtime1")
|
|
{
|
|
name_class = name_classes_qos::realtime1;
|
|
}
|
|
else if(type_node == "realtime2")
|
|
{
|
|
name_class = name_classes_qos::realtime2;
|
|
}
|
|
else if(type_node == "realtime3")
|
|
{
|
|
name_class = name_classes_qos::realtime3;
|
|
}
|
|
else if(type_node == "critical1")
|
|
{
|
|
name_class = name_classes_qos::critical1;
|
|
}
|
|
else if(type_node == "critical2")
|
|
{
|
|
name_class = name_classes_qos::critical2;
|
|
}
|
|
else if(type_node == "critical3")
|
|
{
|
|
name_class = name_classes_qos::critical3;
|
|
}
|
|
else if(type_node == "cir")
|
|
{
|
|
name_class = name_classes_qos::cir;
|
|
}
|
|
else if(type_node == "pir")
|
|
{
|
|
name_class = name_classes_qos::pir;
|
|
}
|
|
else if(type_node == "wcr1")
|
|
{
|
|
name_class = name_classes_qos::wcr1;
|
|
}
|
|
else if(type_node == "wcr2")
|
|
{
|
|
name_class = name_classes_qos::wcr2;
|
|
}
|
|
else if(type_node == "wcr3")
|
|
{
|
|
name_class = name_classes_qos::wcr3;
|
|
}
|
|
else if(type_node == "enable")
|
|
{
|
|
name_class = name_classes_qos::enable;
|
|
}
|
|
else if(type_node == "ful_node")
|
|
{
|
|
name_class = name_classes_qos::ful_node;
|
|
}
|
|
|
|
auto resp = clients[sid]->send_get_qos_params(node_, name_class);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*node = node_;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetDpdiParams(TSID sid, DPDI_parmeters dpdi_params)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
dpdi_parameters dpdi_pars;
|
|
dpdi_pars.is_delay_window = dpdi_params.is_delay_window;
|
|
dpdi_pars.max_delay = dpdi_params.max_delay;
|
|
dpdi_pars.min_delay = dpdi_params.min_delay;
|
|
dpdi_pars.freq_offset = dpdi_params.freq_offset;
|
|
dpdi_pars.latitude_station_grad = dpdi_params.latitude_station_grad;
|
|
dpdi_pars.latitude_station_minute = dpdi_params.latitude_station_minute;
|
|
dpdi_pars.longitude_sattelite_grad = dpdi_params.longitude_sattelite_grad;
|
|
dpdi_pars.longitude_sattelite_minute = dpdi_params.longitude_sattelite_minute;
|
|
dpdi_pars.longitude_station_grad = dpdi_params.longitude_station_grad;
|
|
dpdi_pars.longitude_station_minute = dpdi_params.longitude_station_minute;
|
|
auto resp = clients[sid]->send_set_dpdi_params(dpdi_pars);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetNetwork(TSID sid, const char *param_name, const char *val)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
network_value net_val;
|
|
std::string cmd(param_name);
|
|
if(cmd == "mode")
|
|
net_val = network_value::mode_interface;
|
|
else if(cmd == "addr")
|
|
net_val = network_value::network;
|
|
else if(cmd == "mask")
|
|
net_val = network_value::mask;
|
|
else if(cmd == "gateway")
|
|
net_val = network_value::gateway;
|
|
else if(cmd == "dhcp_on")
|
|
net_val = network_value::dhcp_on;
|
|
else if(cmd == "dhcp_range")
|
|
net_val = network_value::dhcp_range;
|
|
else if(cmd == "addr_data")
|
|
net_val = network_value::network_data;
|
|
else if(cmd == "name_serv")
|
|
net_val = network_value::name_serv;
|
|
else if(cmd == "network_debug_send")
|
|
net_val = network_value::network_debug_send;
|
|
else if(cmd == "network_port_metric")
|
|
net_val = network_value::network_port_metric;
|
|
else if(cmd == "network_port_data")
|
|
net_val = network_value::network_port_data;
|
|
else if(cmd == "if_debug_mode")
|
|
net_val = network_value::if_debug_mode;
|
|
else if(cmd == "periodic_send_metrics")
|
|
net_val = network_value::periodic_send_metrics;
|
|
|
|
auto resp = clients[sid]->send_network_settings(net_val, val);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetNetwork(TSID sid, const char *param_name, std::string *val)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
network_value net_val;
|
|
std::string cmd(param_name);
|
|
std::string val_from_server;
|
|
if(cmd == "mode")
|
|
net_val = network_value::mode_interface;
|
|
else if(cmd == "addr")
|
|
net_val = network_value::network;
|
|
else if(cmd == "version")
|
|
net_val = network_value::version;
|
|
else if(cmd == "chip_id")
|
|
net_val = network_value::chip_id;
|
|
else if(cmd == "mask")
|
|
net_val = network_value::mask;
|
|
else if(cmd == "gateway")
|
|
net_val = network_value::gateway;
|
|
else if(cmd == "dhcp_on")
|
|
net_val = network_value::dhcp_on;
|
|
else if(cmd == "dhcp_range")
|
|
net_val = network_value::dhcp_range;
|
|
else if(cmd == "addr_data")
|
|
net_val = network_value::network_data;
|
|
else if(cmd == "serial")
|
|
net_val = network_value::serial;
|
|
else if(cmd == "mac_eth0")
|
|
net_val = network_value::mac_eth0;
|
|
else if(cmd == "mac_eth1")
|
|
net_val = network_value::mac_eth1;
|
|
else if(cmd == "name_serv")
|
|
net_val = network_value::name_serv;
|
|
else if(cmd == "network_debug_send")
|
|
net_val = network_value::network_debug_send;
|
|
else if(cmd == "network_port_metric")
|
|
net_val = network_value::network_port_metric;
|
|
else if(cmd == "network_port_data")
|
|
net_val = network_value::network_port_data;
|
|
else if(cmd == "if_debug_mode")
|
|
net_val = network_value::if_debug_mode;
|
|
else if(cmd == "periodic_send_metrics")
|
|
net_val = network_value::periodic_send_metrics;
|
|
|
|
auto resp = clients[sid]->send_get_network_settings(net_val, val_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*val = val_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetLBQParams(TSID sid, const uint32_t &tick_ms, const uint32_t &bucket_size)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
auto resp = clients[sid]->send_set_lbq_params(tick_ms, bucket_size);
|
|
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetDmaDebug(TSID sid, const char *command, std::string val)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
cmd_dma_debugg dma_debugg;
|
|
std::string param_name(command);
|
|
|
|
if (param_name == "start")
|
|
dma_debugg = cmd_dma_debugg::start;
|
|
else if (param_name == "stop")
|
|
dma_debugg = cmd_dma_debugg::stop;
|
|
else if (param_name == "reset")
|
|
dma_debugg = cmd_dma_debugg::reset;
|
|
else if (param_name == "reinit")
|
|
dma_debugg = cmd_dma_debugg::reinit;
|
|
else if (param_name == "modcod")
|
|
dma_debugg = cmd_dma_debugg::modcod;
|
|
else if (param_name == "log_bool")
|
|
dma_debugg = cmd_dma_debugg::log_bool;
|
|
else if (param_name == "data_mode")
|
|
dma_debugg = cmd_dma_debugg::data_mode;
|
|
else if (param_name == "buc_voltage")
|
|
dma_debugg = cmd_dma_debugg::buc_voltage;
|
|
else if (param_name == "lnb_voltage")
|
|
dma_debugg = cmd_dma_debugg::lnb_voltage;
|
|
else if (param_name == "10MHz_tx")
|
|
dma_debugg = cmd_dma_debugg::_10mhz_tx;
|
|
else if (param_name == "10MHz_rx")
|
|
dma_debugg = cmd_dma_debugg::_10mhz_rx;
|
|
else if (param_name == "10MHz_out")
|
|
dma_debugg = cmd_dma_debugg::_10MHz_out;
|
|
else if (param_name == "powerdown_plata")
|
|
dma_debugg = cmd_dma_debugg::powerdown_plata;
|
|
else if (param_name == "default_params")
|
|
dma_debugg = cmd_dma_debugg::default_params;
|
|
else if (param_name == "current_state_tx")
|
|
dma_debugg = cmd_dma_debugg::current_state_tx;
|
|
else if (param_name == "current_state_oib")
|
|
dma_debugg = cmd_dma_debugg::current_state_oib;
|
|
else if (param_name == "save_config")
|
|
dma_debugg = cmd_dma_debugg::save_config;
|
|
else if (param_name == "begin_save_config")
|
|
dma_debugg = cmd_dma_debugg::begin_save_config;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_set_dma_debug(dma_debugg, val);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetAcmParams(TSID sid, ACM_parameters_serv_ acm_params)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
ACM_parameters_serv acm_pars;
|
|
acm_pars.enable = acm_params.enable;
|
|
acm_pars.max_attenuation = acm_params.max_attenuation;
|
|
acm_pars.max_modcod = acm_params.max_modcod;
|
|
acm_pars.min_attenuation = acm_params.min_attenuation;
|
|
acm_pars.min_modcod = acm_params.min_modcod;
|
|
acm_pars.snr_treashold = acm_params.snr_treashold;
|
|
acm_pars.enable_auto_atten = acm_params.enable_auto_atten;
|
|
acm_pars.snr_treashold_acm = acm_params.snr_treashold_acm;
|
|
acm_pars.period_pack = acm_params.period_pack;
|
|
auto resp = clients[sid]->send_set_acm_params(acm_pars);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_Set10gConfig(TSID sid, const char *parameter, std::string val)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
cmd_10g_config _10g_config;
|
|
std::string param_name(parameter);
|
|
if(param_name == "udp_payload_length")
|
|
_10g_config = cmd_10g_config::udp_payload_lenght;
|
|
else if (param_name == "local_ip")
|
|
_10g_config = cmd_10g_config::local_ip;
|
|
else if (param_name == "dest_ip")
|
|
_10g_config = cmd_10g_config::dest_ip;
|
|
else if (param_name == "gateway_ip")
|
|
_10g_config = cmd_10g_config::gateway_ip;
|
|
else if (param_name == "subnet_mask")
|
|
_10g_config = cmd_10g_config::subnet_mask;
|
|
else if (param_name == "udp_source_port")
|
|
_10g_config = cmd_10g_config::udp_source_port;
|
|
else if (param_name == "udp_dest_port")
|
|
_10g_config = cmd_10g_config::udp_dest_port;
|
|
else if (param_name == "local_mac_1")
|
|
_10g_config = cmd_10g_config::local_mac_31_0;
|
|
else if (param_name == "local_mac_2")
|
|
_10g_config = cmd_10g_config::local_mac_32_47;
|
|
else if (param_name == "chan0")
|
|
_10g_config = cmd_10g_config::mtx_chan0;
|
|
else if (param_name == "chan1")
|
|
_10g_config = cmd_10g_config::mtx_chan1;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_set_10g_config(_10g_config, val);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDpdiParams(TSID sid, DPDI_parmeters *dpdi_pars_get)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
dpdi_parameters dpdi_from_server;
|
|
auto resp = clients[sid]->send_get_dpdi_params(dpdi_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
DPDI_parmeters dpdi_pars;
|
|
dpdi_pars.is_delay_window = dpdi_from_server.is_delay_window;
|
|
dpdi_pars.max_delay = dpdi_from_server.max_delay;
|
|
dpdi_pars.min_delay = dpdi_from_server.min_delay;
|
|
dpdi_pars.freq_offset = dpdi_from_server.freq_offset;
|
|
dpdi_pars.latitude_station_grad = dpdi_from_server.latitude_station_grad;
|
|
dpdi_pars.latitude_station_minute = dpdi_from_server.latitude_station_minute;
|
|
dpdi_pars.longitude_sattelite_grad = dpdi_from_server.longitude_sattelite_grad;
|
|
dpdi_pars.longitude_sattelite_minute = dpdi_from_server.longitude_sattelite_minute;
|
|
dpdi_pars.longitude_station_grad = dpdi_from_server.longitude_station_grad;
|
|
dpdi_pars.longitude_station_minute = dpdi_from_server.longitude_station_minute;
|
|
*dpdi_pars_get = dpdi_pars;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetAcmParams(TSID sid, ACM_parameters_serv_ *acm_params)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
cmd_get_acm_param acm_from_server;
|
|
auto resp = clients[sid]->send_get_acm_params(acm_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
ACM_parameters_serv_ acm_from_serv_;
|
|
acm_from_serv_.enable = acm_from_server.enable;
|
|
acm_from_serv_.enable_auto_atten = acm_from_server.enable_auto_atten;
|
|
acm_from_serv_.min_attenuation = acm_from_server.min_attenuation;
|
|
acm_from_serv_.max_attenuation = acm_from_server.max_attenuation;
|
|
acm_from_serv_.min_modcod = acm_from_server.min_modcod;
|
|
acm_from_serv_.snr_treashold = acm_from_server.snr_treashold;
|
|
acm_from_serv_.max_modcod = acm_from_server.max_modcod;
|
|
acm_from_serv_.snr_treashold_acm = acm_from_server.snr_treashold_acm;
|
|
acm_from_serv_.period_pack = acm_from_server.period_pack;
|
|
*acm_params = acm_from_serv_;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDmaDebug(TSID sid, const char *command, std::string *val)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
std::string value_from_server;
|
|
cmd_get_dma_debugg_enum cmd;
|
|
std::string param_name(command);
|
|
|
|
if(param_name == "speed_tx")
|
|
cmd = cmd_get_dma_debugg_enum::speed_tx;
|
|
else if (param_name == "speed_rx")
|
|
cmd = cmd_get_dma_debugg_enum::speed_rx;
|
|
if(param_name == "speed_tx_iface")
|
|
cmd = cmd_get_dma_debugg_enum::speed_tx_iface;
|
|
else if (param_name == "speed_rx_iface")
|
|
cmd = cmd_get_dma_debugg_enum::speed_rx_iface;
|
|
else if (param_name == "modcod")
|
|
cmd = cmd_get_dma_debugg_enum::modcod;
|
|
else if (param_name == "drop_bad_rx")
|
|
cmd = cmd_get_dma_debugg_enum::drop_bad_rx;
|
|
else if (param_name == "drop_full_rx")
|
|
cmd = cmd_get_dma_debugg_enum::drop_full_rx;
|
|
else if (param_name == "packet_ok_rx")
|
|
cmd = cmd_get_dma_debugg_enum::packet_ok_rx;
|
|
else if (param_name == "packet_little_tx")
|
|
cmd = cmd_get_dma_debugg_enum::packet_little_tx;
|
|
else if (param_name == "packet_big_tx")
|
|
cmd = cmd_get_dma_debugg_enum::packet_big_tx;
|
|
else if (param_name == "bad_modcod_tx")
|
|
cmd = cmd_get_dma_debugg_enum::bad_modcod_tx;
|
|
else if (param_name == "bad_length_tx")
|
|
cmd = cmd_get_dma_debugg_enum::bad_length_tx;
|
|
else if (param_name == "reset_cnt_rx")
|
|
cmd = cmd_get_dma_debugg_enum::reset_cnt_rx;
|
|
else if (param_name == "buc_voltage")
|
|
cmd = cmd_get_dma_debugg_enum::buc_voltage;
|
|
else if (param_name == "lnb_voltage")
|
|
cmd = cmd_get_dma_debugg_enum::lnb_voltage;
|
|
else if (param_name == "10MHz_tx")
|
|
cmd = cmd_get_dma_debugg_enum::_10mhz_tx;
|
|
else if (param_name == "10MHz_rx")
|
|
cmd = cmd_get_dma_debugg_enum::_10mhz_rx;
|
|
else if (param_name == "10MHz_out")
|
|
cmd = cmd_get_dma_debugg_enum::_10MHz_out;
|
|
else if (param_name == "current_state_tx")
|
|
cmd = cmd_get_dma_debugg_enum::current_state_tx;
|
|
else if (param_name == "data_mode")
|
|
cmd = cmd_get_dma_debugg_enum::data_mode;
|
|
else if (param_name == "delay_dpdi")
|
|
cmd = cmd_get_dma_debugg_enum::real_dpdi_shift;
|
|
else if (param_name == "freq_error_offset")
|
|
cmd = cmd_get_dma_debugg_enum::freq_error_offset;
|
|
else if (param_name == "freq_fine_estimate")
|
|
cmd = cmd_get_dma_debugg_enum::freq_fine_estimate;
|
|
else if (param_name == "powerdown_plata")
|
|
cmd = cmd_get_dma_debugg_enum::powerdown_plata;
|
|
else if (param_name == "current_state_oib")
|
|
cmd = cmd_get_dma_debugg_enum::current_state_oib;
|
|
else if (param_name == "ratio_signal_signal")
|
|
cmd = cmd_get_dma_debugg_enum::ratio_signal_signal;
|
|
else if (param_name == "status_init")
|
|
cmd = cmd_get_dma_debugg_enum::status_init;
|
|
|
|
auto resp = clients[sid]->send_get_dma_debug(cmd, value_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*val = value_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetLevelDemod(TSID sid, const char * param ,double *value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
double level_from_server;
|
|
cmd_level_dem level_value;
|
|
std::string param_name(param);
|
|
if(param_name == "snr")
|
|
level_value = cmd_level_dem::snr;
|
|
else if(param_name == "rssi")
|
|
level_value = cmd_level_dem::rssi;
|
|
else if(param_name == "pkt_sync")
|
|
level_value = cmd_level_dem::pkt_sync;
|
|
else if(param_name == "afc_lock")
|
|
level_value = cmd_level_dem::afc_lock;
|
|
else if(param_name == "freq_lock")
|
|
level_value = cmd_level_dem::freq_search_lock;
|
|
else if(param_name == "sym_sync_lock")
|
|
level_value = cmd_level_dem::sym_sync_lock;
|
|
else if(param_name == "phase_inv")
|
|
level_value = cmd_level_dem::phase_inv;
|
|
else if (param_name == "afc_err")
|
|
level_value = cmd_level_dem::afc_error;
|
|
else if (param_name == "crs_freq_err")
|
|
level_value = cmd_level_dem::crs_freq_error;
|
|
else if (param_name == "sym_err")
|
|
level_value = cmd_level_dem::sym_error;
|
|
else if (param_name == "fine_freq_err")
|
|
level_value = cmd_level_dem::fine_freq_error;
|
|
else if (param_name == "gain_aru")
|
|
level_value = cmd_level_dem::gc_gain_aru;
|
|
else if (param_name == "rollof")
|
|
level_value = cmd_level_dem::rollof;
|
|
else if (param_name == "carrier_lock")
|
|
level_value = cmd_level_dem::carrier_lock;
|
|
else if (param_name == "filt_adapt_lock")
|
|
level_value = cmd_level_dem::filt_adapt_lock;
|
|
else if (param_name == "snr_acm")
|
|
level_value = cmd_level_dem::snr_acm;
|
|
else if (param_name == "modcod_tx")
|
|
level_value = cmd_level_dem::modcod_tx;
|
|
auto resp = clients[sid]->send_get_level_dem(level_value, level_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*value = level_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_ZynqParams(TSID sid, const char *zynq_param, double *value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
zynq_value zyn_value;
|
|
double par_from_server;
|
|
std::string param_name(zynq_param);
|
|
if(param_name == "ps_voltage")
|
|
zyn_value = zynq_value::ps_volt;
|
|
else if(param_name == "ps_temper_celsius")
|
|
zyn_value = zynq_value::ps_temp;
|
|
else if(param_name == "pl_voltage")
|
|
zyn_value = zynq_value::pl_volt;
|
|
else if(param_name == "pl_temper_celsius")
|
|
zyn_value = zynq_value::pl_temp;
|
|
else if(param_name == "adrv-c_temper_celsius")
|
|
zyn_value = zynq_value::adrv_temp;
|
|
else if(param_name == "adrv-d_temper_celsius")
|
|
zyn_value = zynq_value::adrv_temp2;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_zynq_cmd(zyn_value, par_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
*value = par_from_server;
|
|
return OK;
|
|
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetModulatorParams(TSID sid, const char *modulator_param, uint32_t *value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
modulator_value mod_val;
|
|
uint32_t par_from_server;
|
|
std::string param_name(modulator_param);
|
|
if(param_name == "baudrate")
|
|
mod_val = modulator_value::baud_rate;
|
|
else if (param_name == "center_freq")
|
|
mod_val = modulator_value::lo_freaquency;
|
|
else if (param_name == "rollof")
|
|
mod_val = modulator_value::rollof;
|
|
else if (param_name == "mode_trans")
|
|
mod_val = modulator_value::mode_transmitt;
|
|
else if (param_name == "if_overload")
|
|
mod_val = modulator_value::if_overload;
|
|
else if (param_name == "gold_seq")
|
|
mod_val = modulator_value::gold_seq;
|
|
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_get_modulator_param(mod_val, par_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*value = par_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDemodulatorParams(TSID sid, const char *demodulator_param, uint32_t *value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
getdemodulator_value demod_val;
|
|
uint32_t par_from_server;
|
|
std::string param_name(demodulator_param);
|
|
if(param_name == "baudrate")
|
|
demod_val = getdemodulator_value::baud_rate;
|
|
else if (param_name == "center_freq")
|
|
demod_val = getdemodulator_value::lo_freaquency;
|
|
else if (param_name == "dummy_cnt")
|
|
demod_val = getdemodulator_value::dummy_counter;
|
|
else if (param_name == "modcod")
|
|
demod_val = getdemodulator_value::modcod;
|
|
else if (param_name == "mode_gain_control")
|
|
demod_val = getdemodulator_value::mode_gain_control;
|
|
else if (param_name == "sig_min")
|
|
demod_val = getdemodulator_value::sig_min;
|
|
else if (param_name == "sig_max")
|
|
demod_val = getdemodulator_value::sig_max;
|
|
else if (param_name == "rvt")
|
|
demod_val = getdemodulator_value::rvt;
|
|
else if (param_name == "fec_size")
|
|
demod_val = getdemodulator_value::fec_size;
|
|
else if (param_name == "mode_demod")
|
|
demod_val = getdemodulator_value::mode_demod;
|
|
else if (param_name == "cnt_bad_lock_cinc")
|
|
demod_val = getdemodulator_value::cnt_bad_lock_cinc;
|
|
else if (param_name == "gold_seq")
|
|
demod_val = getdemodulator_value::gold_seq;
|
|
else if (param_name == "attitude_signals")
|
|
demod_val = getdemodulator_value::attitude_signals;
|
|
else if (param_name == "cnt_dem_time_sinc")
|
|
demod_val = getdemodulator_value::cnt_dem_time_sinc;
|
|
else if (param_name == "cnt_dem_lock_afc")
|
|
demod_val = getdemodulator_value::cnt_dem_lock_afc;
|
|
else if (param_name == "cnt_dem_sync_pack")
|
|
demod_val = getdemodulator_value::cnt_dem_sync_pack;
|
|
else if (param_name == "cnt_dem_sinc_frec_corse")
|
|
demod_val = getdemodulator_value::cnt_dem_sinc_frec_corse;
|
|
else if (param_name == "freq_lock_estimate")
|
|
demod_val = getdemodulator_value::freq_lock_estimate;
|
|
else if (param_name == "reset_cinc")
|
|
demod_val = getdemodulator_value::is_reset_CinC;
|
|
else if (param_name == "type_pack")
|
|
demod_val = getdemodulator_value::type_pack;
|
|
else if (param_name == "is_pilots")
|
|
demod_val = getdemodulator_value::is_pilots;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_get_demodulator_param(demod_val, par_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
*value = par_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_DemodulatorParams(TSID sid, const char *demodulator_param, uint32_t value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
demodulator_value demod_val;
|
|
std::string param_name(demodulator_param);
|
|
if(param_name == "baudrate")
|
|
demod_val = demodulator_value::baud_rate;
|
|
else if (param_name == "center_freq")
|
|
demod_val = demodulator_value::lo_freaquency;
|
|
else if (param_name == "demod_reset")
|
|
demod_val = demodulator_value::demod_reset;
|
|
else if (param_name == "fec_size")
|
|
demod_val = demodulator_value::fec_frame_size;
|
|
else if (param_name == "rvt")
|
|
demod_val = demodulator_value::rvt;
|
|
else if (param_name == "mode_gain_control")
|
|
demod_val = demodulator_value::mode_gain_control;
|
|
else if (param_name == "sig_min")
|
|
demod_val = demodulator_value::sig_min;
|
|
else if (param_name == "sig_max")
|
|
demod_val = demodulator_value::sig_max;
|
|
else if (param_name == "afc_rst")
|
|
demod_val = demodulator_value::afc_rst;
|
|
else if (param_name == "mode_demod")
|
|
demod_val = demodulator_value::mode_demod;
|
|
else if (param_name == "gold_seq")
|
|
demod_val = demodulator_value::gold_seq;
|
|
else if (param_name == "attitude_signals")
|
|
demod_val = demodulator_value::attitude_signals;
|
|
else if (param_name == "reset_cinc")
|
|
demod_val = demodulator_value::is_reset_CinC;
|
|
else return ERROR;
|
|
auto resp = clients[sid]->send_set_demodulator_param(demod_val,value);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
EXTERNC CP_Result CP_ModulatorParams(TSID sid, const char *modulator_param, uint32_t value)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
modulator_value mod_val;
|
|
std::string param_name(modulator_param);
|
|
if(param_name == "baudrate")
|
|
mod_val = modulator_value::baud_rate;
|
|
else if (param_name == "center_freq")
|
|
mod_val = modulator_value::lo_freaquency;
|
|
else if (param_name == "temp_treshold")
|
|
mod_val = modulator_value::temp_treshold;
|
|
else if (param_name == "modcod")
|
|
mod_val = modulator_value::modcod;
|
|
else if (param_name == "reset")
|
|
mod_val = modulator_value::mod_reset;
|
|
else if (param_name == "rollof")
|
|
mod_val = modulator_value::rollof;
|
|
else if (param_name == "mode_trans")
|
|
mod_val = modulator_value::mode_transmitt;
|
|
else if (param_name == "gold_seq")
|
|
mod_val = modulator_value::gold_seq;
|
|
|
|
else return ERROR;
|
|
auto resp = clients[sid]->send_modulator_param(mod_val,value);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_RadioEnable(TSID sid, const char *radio_interface, bool on_of)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
cmd_radio radio;
|
|
std::string radio_name(radio_interface);
|
|
if(radio_name == "TX1")
|
|
radio = cmd_radio::tx1;
|
|
else if (radio_name == "TX2")
|
|
radio = cmd_radio::tx2;
|
|
else if (radio_name == "RX1")
|
|
radio = cmd_radio::rx1;
|
|
else if (radio_name == "RX2")
|
|
radio = cmd_radio::rx2;
|
|
else if(radio_name == "GLOBAL")
|
|
radio = cmd_radio::global;
|
|
else if(radio_name == "GLOBAL2")
|
|
radio = cmd_radio::global2;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_radio_enable(radio,on_of);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
}
|
|
EXTERNC CP_Result CP_SetGain(TSID sid,const char *gain_interface,double gain){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
gain_value value;
|
|
std::string gain_name(gain_interface);
|
|
if(gain_name == "TX1")
|
|
value = gain_value::tx1;
|
|
else if (gain_name == "TX2")
|
|
value = gain_value::tx2;
|
|
else if (gain_name == "RX1")
|
|
value = gain_value::rx1;
|
|
else if (gain_name == "RX2")
|
|
value = gain_value::rx2;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_set_gain_param(value,gain);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetGain(TSID sid, const char *gain_interface, double *gain){
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
double gain_from_server;
|
|
gain_value value;
|
|
std::string gain_name(gain_interface);
|
|
if(gain_name == "TX1")
|
|
value = gain_value::tx1;
|
|
else if (gain_name == "TX2")
|
|
value = gain_value::tx2;
|
|
else if (gain_name == "RX1")
|
|
value = gain_value::rx1;
|
|
else if (gain_name == "RX2")
|
|
value = gain_value::rx2;
|
|
else if (gain_name == "TXPWD")
|
|
value = gain_value::txpwd;
|
|
else if (gain_name == "RXPWD")
|
|
value = gain_value::rxpwd;
|
|
else return ERROR;
|
|
|
|
auto resp = clients[sid]->send_get_gain_param(value,gain_from_server);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
*gain = gain_from_server;
|
|
return OK;
|
|
}
|
|
catch(const std::exception& e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
}
|
|
|
|
EXTERNC CP_Result CP_SetDemFreq(TSID sid, uint32_t freq)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_set_dem_freq_cmd(freq);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_GetDemFreq(TSID sid, uint32_t * freq)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
uint32_t freq_from_serv;
|
|
auto resp = clients[sid]->send_get_dem_freq_cmd(freq_from_serv);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
*freq = freq_from_serv;
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
|
|
EXTERNC CP_Result CP_Login(const char * user, const char * pwd, TSID * sid, unsigned int * access)
|
|
{
|
|
std::unique_lock lock(mtx);
|
|
try
|
|
{
|
|
clients[sid_counter] = std::make_unique<system_client>("/tmp/control.sock");
|
|
access_rights access_lvl;
|
|
auto resp = clients[sid_counter]->send_login_cmd(user, pwd, access_lvl);
|
|
*access = static_cast<unsigned int>(access_lvl);
|
|
*sid = sid_counter;
|
|
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
while (clients.find(sid_counter) != clients.end())
|
|
sid_counter++;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_Logout(TSID sid)
|
|
{
|
|
std::unique_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_logout_cmd();
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
|
|
clients.erase(sid);
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC void CP_SetCmdStdoutCallback(TSID sid, CP_cmd_stdout_cb cb)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return;
|
|
|
|
clients[sid]->set_stdout_callback(cb);
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_Ping(TSID sid, const char * ip_address, int packet_count)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end() || packet_count < 1)
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_ping_cmd(ip_address, static_cast<size_t>(packet_count));
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
else if (resp == response_type::abort)
|
|
return ABORT;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_Traceroute(TSID sid, const char * ip_address)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_traceroute_cmd(ip_address);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
else if (resp == response_type::abort)
|
|
return ABORT;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC void CP_CmdAbort(TSID sid)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return;
|
|
|
|
clients[sid]->abort();
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_ShowInterface(TSID sid, const char * interface)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
std::string interface_name(interface);
|
|
interface_value value;
|
|
if (interface_name == "all")
|
|
value = interface_value::all;
|
|
else if (interface_name == "sat0")
|
|
value = interface_value::sat0;
|
|
else if (interface_name == "gigabit")
|
|
value = interface_value::gigabit;
|
|
else if (interface_name == "modulator")
|
|
value = interface_value::modulator;
|
|
else if (interface_name == "demodulator")
|
|
value = interface_value::demodulator;
|
|
else
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_show_interface_cmd(value);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
else if (resp == response_type::abort)
|
|
return ABORT;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|
|
|
|
EXTERNC CP_Result CP_Copy(TSID sid, const char * src, const char * dst)
|
|
{
|
|
std::shared_lock lock(mtx);
|
|
try
|
|
{
|
|
if (clients.find(sid) == clients.end())
|
|
return ERROR;
|
|
|
|
std::string src_str(src);
|
|
std::string dst_str(dst);
|
|
|
|
fm::side_description src_desc;
|
|
fm::side_description dst_desc;
|
|
|
|
if (src_str.find("flash:") == 0)
|
|
{
|
|
src_desc.s_type = fm::side_type::local;
|
|
size_t pos = src_str.find(":");
|
|
src_desc.filepath = src_str.substr(pos + 1, src_str.size() - pos - 1);
|
|
}
|
|
else if (src_str.find("tftp://") == 0)
|
|
{
|
|
src_desc.s_type = fm::side_type::tftp;
|
|
size_t pos = src_str.find("://");
|
|
src_desc.filepath = src_str.substr(pos + 3, src_str.size() - pos - 3);
|
|
}
|
|
else
|
|
return ERROR;
|
|
|
|
if (dst_str.find("flash:") == 0)
|
|
{
|
|
dst_desc.s_type = fm::side_type::local;
|
|
size_t pos = dst_str.find(":");
|
|
dst_desc.filepath = dst_str.substr(pos + 1, dst_str.size() - pos - 1);
|
|
}
|
|
else if (dst_str.find("tftp://") == 0)
|
|
{
|
|
dst_desc.s_type = fm::side_type::tftp;
|
|
size_t pos = dst_str.find("://");
|
|
dst_desc.filepath = dst_str.substr(pos + 3, dst_str.size() - pos - 3);
|
|
}
|
|
else
|
|
return ERROR;
|
|
|
|
if (src_desc.s_type == fm::side_type::tftp && dst_desc.s_type == fm::side_type::tftp)
|
|
return ERROR;
|
|
|
|
auto resp = clients[sid]->send_copy_cmd(src_desc, dst_desc);
|
|
if (resp == response_type::error)
|
|
return ERROR;
|
|
else if (resp == response_type::abort)
|
|
return ABORT;
|
|
|
|
return OK;
|
|
}
|
|
catch(const std::exception & e)
|
|
{
|
|
return ERROR;
|
|
}
|
|
}
|