mirror/bbfdm
1
0
Fork 0
mirror of https://dev.iopsys.eu/bbf/bbfdm.git synced 2025-12-10 07:44:39 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

bbf: save diagnostics data under '/etc/bbfdm/dmmap_diagnostics' instead of '/vat/state/cwmp'

Browse source
This commit is contained in:
Amin Ben Ramdhane 2020-09-28 10:08:13 +01:00
parent 38b0c69f94
commit 027d8fb599
43 changed files with 1005 additions and 1580 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
README
View file

@ -1,29 +1,14 @@
configure autotools
BBF Compilation
===================
$ autoreconf -if
clean it all up
===============
$ make distclean
or
$ git clean -df
development environment
=======================
Make sure you have all the packages installed from packages-arch-tr069 git
repository.
$ ln -sf `pwd`/scripts/defaults /usr/share/bbfdm/defaults
run icwmpd
=============
$ export UCI_CONFIG_DIR="`pwd`/config/"
$ export UBUS_SOCKET="/tmp/ubus.sock"
$ ./bin/icwmpd -f
autoreconf -i
./configure CC="gcc-9" --enable-tr181 --enable-tr104 --enable-tr143 --enable-tr157 --enable-libopenssl CPPFLAGS=-DCUSTOM_PREFIX=\\\"X_IOPSYS_EU_\\\"
make
cp bin/.libs/libbbfdm.so* /usr/lib/
cp bin/.libs/libbbf_api.so* /usr/lib/
mkdir /usr/include/libbbfdm
mkdir /usr/include/libbbf_api
cp *.h /usr/include/libbbfdm/
cp dmtree/tr181/*.h /usr/include/libbbfdm/
cp dmtree/tr157/*.h /usr/include/libbbfdm/
cp libbbf_api/*.h /usr/include/libbbf_api/

11
dmbbfcommon.c
View file

@ -36,22 +36,13 @@ int dm_add_end_session(struct dmctx *ctx, void(*function)(struct execute_end_ses
return 0;
}
int cwmp_free_dm_end_session(struct execute_end_session *execute_end_session)
{
if(execute_end_session != NULL)
{
FREE(execute_end_session);
}
return 0;
}
void apply_end_session()
{
struct execute_end_session *p, *q;
list_for_each_entry_safe(p, q, &(list_execute_end_session), list) {
p->function(p);
list_del(&(p->list));
cwmp_free_dm_end_session(p);
FREE(p);
}
}

1
dmbbfcommon.h
View file

@ -15,7 +15,6 @@ extern int end_session_flag;
extern unsigned int upnp_in_user_mask;
extern struct list_head list_execute_end_session;
int bbfdmuci_lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *package, char *section, char *option, char *value);
void bbf_apply_end_session(void);
int set_bbfdatamodel_type(int bbf_type);
int bbf_set_ip_version(int ipversion);

136
dmdiagnostics.c
View file

@ -16,27 +16,29 @@ int read_next;
struct download_diag download_stats = {0};
struct upload_diagnostic_stats upload_stats = {0};
char *get_param_diagnostics(char *diag, char *option)
char *get_diagnostics_option(char *sec_name, char *option)
{
char buf[32] = {0}, *value;
snprintf(buf, sizeof(buf), "@%s[0]", diag);
dmuci_get_varstate_string("cwmp", buf, option, &value);
return value;
char *value;
dmuci_get_option_value_string_bbfdm(DMMAP_DIAGNOSTIGS, sec_name, option, &value);
return value;
}
void set_param_diagnostics(char *diag, char *option, char *value)
char *get_diagnostics_option_fallback_def(char *sec_name, char *option, char *default_value)
{
struct uci_section *curr_section = NULL;
char buf[32] = {0}, *tmp;
char *value = get_diagnostics_option(sec_name, option);
return (*value != '\0') ? value : default_value;
}
curr_section = dmuci_walk_state_section("cwmp", diag, NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if(!curr_section)
{
dmuci_add_state_section("cwmp", diag, &curr_section, &tmp);
}
snprintf(buf, sizeof(buf), "@%s[0]", diag);
dmuci_set_varstate_value("cwmp", buf, option, value);
void set_diagnostics_option(char *sec_name, char *option, char *value)
{
struct uci_section *section = NULL;
check_create_dmmap_package(DMMAP_DIAGNOSTIGS);
section = dmuci_walk_section_bbfdm(DMMAP_DIAGNOSTIGS, sec_name, NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!section)
dmuci_set_value_bbfdm(DMMAP_DIAGNOSTIGS, sec_name, "", sec_name);
dmuci_set_value_bbfdm(DMMAP_DIAGNOSTIGS, sec_name, option, value);
}
void init_download_stats(void)
@ -84,7 +86,7 @@ static void ftp_download_per_packet(libtrace_packet_t *packet)
pch=strtok_r(val, " \r\n\t", &pchr);
download_stats.test_bytes_received = atoi(pch);
}
if(strcmp(tcp_flag, "PSH ACK ") == 0 && strlen(nexthdr) > strlen(FTP_PASV_RESPONSE) && strncmp(nexthdr, FTP_PASV_RESPONSE, strlen(FTP_PASV_RESPONSE)) == 0)
if (strcmp(tcp_flag, "PSH ACK ") == 0 && strlen(nexthdr) > strlen(FTP_PASV_RESPONSE) && strncmp(nexthdr, FTP_PASV_RESPONSE, strlen(FTP_PASV_RESPONSE)) == 0)
{
download_stats.ftp_syn = 1;
return;
@ -113,12 +115,12 @@ static void ftp_download_per_packet(libtrace_packet_t *packet)
strftime(s_now, sizeof s_now, "%Y-%m-%dT%H:%M:%S", &lt);
snprintf(download_stats.romtime, sizeof(download_stats.romtime), "%s.%06ldZ", s_now, (long) ts.tv_usec);
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == download_stats.random_seq && download_stats.ack_seq == 0)
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == download_stats.random_seq && download_stats.ack_seq == 0)
{
download_stats.ack_seq = ntohl(tcp->seq);
return;
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == download_stats.ack_seq )
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == download_stats.ack_seq )
{
ts = trace_get_timeval(packet);
(void) localtime_r(&(ts.tv_sec), &lt);
@ -195,12 +197,12 @@ static void http_download_per_packet(libtrace_packet_t *packet)
return;
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == download_stats.get_ack && download_stats.ack_seq == 0) {
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == download_stats.get_ack && download_stats.ack_seq == 0) {
download_stats.ack_seq = ntohl(tcp->ack_seq);
return;
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == download_stats.ack_seq ) {
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == download_stats.ack_seq ) {
ts = trace_get_timeval(packet);
(void) localtime_r(&(ts.tv_sec), &lt);
strftime(s_now, sizeof s_now, "%Y-%m-%dT%H:%M:%S", &lt);
@ -247,34 +249,34 @@ static void set_download_stats(char *protocol)
{
char buf[16] = {0};
if(strcmp(protocol, "cwmp")== 0)
init_uci_varstate_ctx();
if (strcmp(protocol, "cwmp")== 0)
alloc_uci_ctx_bbfdm();
set_param_diagnostics("downloaddiagnostic", "ROMtime", download_stats.romtime);
set_param_diagnostics("downloaddiagnostic", "BOMtime", download_stats.bomtime);
set_param_diagnostics("downloaddiagnostic", "EOMtime", download_stats.eomtime);
set_param_diagnostics("downloaddiagnostic", "TCPOpenRequestTime", download_stats.tcpopenrequesttime);
set_param_diagnostics("downloaddiagnostic", "TCPOpenResponseTime", download_stats.tcpopenresponsetime);
set_diagnostics_option("download", "ROMtime", download_stats.romtime);
set_diagnostics_option("download", "BOMtime", download_stats.bomtime);
set_diagnostics_option("download", "EOMtime", download_stats.eomtime);
set_diagnostics_option("download", "TCPOpenRequestTime", download_stats.tcpopenrequesttime);
set_diagnostics_option("download", "TCPOpenResponseTime", download_stats.tcpopenresponsetime);
snprintf(buf, sizeof(buf), "%d", download_stats.test_bytes_received);
set_param_diagnostics("downloaddiagnostic", "TestBytesReceived", buf);
set_diagnostics_option("download", "TestBytesReceived", buf);
if(strcmp(protocol, "cwmp")== 0)
end_uci_varstate_ctx();
if (strcmp(protocol, "cwmp")== 0)
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
}
static void set_upload_stats(char *protocol)
{
if(strcmp(protocol, "cwmp")== 0)
init_uci_varstate_ctx();
if (strcmp(protocol, "cwmp")== 0)
alloc_uci_ctx_bbfdm();
set_param_diagnostics("uploaddiagnostic", "ROMtime", upload_stats.romtime);
set_param_diagnostics("uploaddiagnostic", "BOMtime", upload_stats.bomtime);
set_param_diagnostics("uploaddiagnostic", "EOMtime", upload_stats.eomtime);
set_param_diagnostics("uploaddiagnostic", "TCPOpenRequestTime", upload_stats.tcpopenrequesttime);
set_param_diagnostics("uploaddiagnostic", "TCPOpenResponseTime", upload_stats.tcpopenresponsetime);
set_diagnostics_option("upload", "ROMtime", upload_stats.romtime);
set_diagnostics_option("upload", "BOMtime", upload_stats.bomtime);
set_diagnostics_option("upload", "EOMtime", upload_stats.eomtime);
set_diagnostics_option("upload", "TCPOpenRequestTime", upload_stats.tcpopenrequesttime);
set_diagnostics_option("upload", "TCPOpenResponseTime", upload_stats.tcpopenresponsetime);
if(strcmp(protocol, "cwmp")== 0)
end_uci_varstate_ctx();
if (strcmp(protocol, "cwmp")== 0)
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
}
static void http_upload_per_packet(libtrace_packet_t *packet)
@ -347,7 +349,7 @@ static void http_upload_per_packet(libtrace_packet_t *packet)
upload_stats.ack_seq = ntohl(tcp->ack_seq);
return;
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == upload_stats.ack_seq && upload_stats.tmp == 0)
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == upload_stats.ack_seq && upload_stats.tmp == 0)
{
ts = trace_get_timeval(packet);
(void) localtime_r(&(ts.tv_sec), &lt);
@ -405,7 +407,7 @@ static void ftp_upload_per_packet(libtrace_packet_t *packet)
if (tcp->ack) strcat(tcp_flag, "ACK ");
if (tcp->urg) strcat(tcp_flag, "URG ");
if(strcmp(tcp_flag, "PSH ACK ") == 0 && strlen(nexthdr) > strlen(FTP_PASV_RESPONSE) && strncmp(nexthdr, FTP_PASV_RESPONSE, strlen(FTP_PASV_RESPONSE)) == 0)
if (strcmp(tcp_flag, "PSH ACK ") == 0 && strlen(nexthdr) > strlen(FTP_PASV_RESPONSE) && strncmp(nexthdr, FTP_PASV_RESPONSE, strlen(FTP_PASV_RESPONSE)) == 0)
{
upload_stats.ftp_syn = 1;
return;
@ -433,12 +435,12 @@ static void ftp_upload_per_packet(libtrace_packet_t *packet)
strftime(s_now, sizeof s_now, "%Y-%m-%dT%H:%M:%S", &lt);
snprintf(upload_stats.romtime, sizeof(upload_stats.romtime), "%s.%06ldZ", s_now, (long) ts.tv_usec);
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == upload_stats.random_seq && upload_stats.ack_seq == 0)
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->seq) == upload_stats.random_seq && upload_stats.ack_seq == 0)
{
upload_stats.ack_seq = ntohl(tcp->ack_seq);
return;
}
if(strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == upload_stats.ack_seq )
if (strcmp(tcp_flag, "ACK ") == 0 && ntohl(tcp->ack_seq) == upload_stats.ack_seq )
{
ts = trace_get_timeval(packet);
(void) localtime_r(&(ts.tv_sec), &lt);
@ -542,8 +544,8 @@ int get_default_gateway_device(char **gw)
while(fgets(line , 100 , f)) {
p = strtok_r(line, " \t", &saveptr);
c = strtok_r(NULL, " \t", &saveptr);
if(p!=NULL && c!=NULL) {
if(strcmp(c, "00000000") == 0) {
if (p!=NULL && c!=NULL) {
if (strcmp(c, "00000000") == 0) {
dmasprintf(gw, "%s", p);
fclose(f);
return 0;
@ -561,12 +563,12 @@ int start_upload_download_diagnostic(int diagnostic_type)
int error;
if (diagnostic_type == DOWNLOAD_DIAGNOSTIC) {
dmuci_get_varstate_string("cwmp", "@downloaddiagnostic[0]", "url", &url);
dmuci_get_varstate_string("cwmp", "@downloaddiagnostic[0]", "device", &interface);
url = get_diagnostics_option("download", "url");
interface = get_diagnostics_option("download", "device");
} else {
dmuci_get_varstate_string("cwmp", "@uploaddiagnostic[0]", "url", &url);
dmuci_get_varstate_string("cwmp", "@uploaddiagnostic[0]", "TestFileLength", &size);
dmuci_get_varstate_string("cwmp", "@uploaddiagnostic[0]", "device", &interface);
url = get_diagnostics_option("upload", "url");
size = get_diagnostics_option("upload", "TestFileLength");
interface = get_diagnostics_option("upload", "device");
}
if (interface[0] == '\0') {
@ -576,40 +578,40 @@ int start_upload_download_diagnostic(int diagnostic_type)
}
if (diagnostic_type == DOWNLOAD_DIAGNOSTIC) {
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 5, DOWNLOAD_DIAGNOSTIC_PATH, "run", "usp", url, interface);
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
dmuci_get_varstate_string("cwmp", "@downloaddiagnostic[0]", "url", &url);
dmuci_get_varstate_string("cwmp", "@downloaddiagnostic[0]", "DiagnosticState", &status);
url = get_diagnostics_option("download", "url");
status = get_diagnostics_option("download", "DiagnosticState");
if (status && strcmp(status, "Complete") == 0) {
init_download_stats();
if(strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_HTTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_HTTP)) == 0)
if (strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_HTTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_HTTP)) == 0)
extract_stats(DOWNLOAD_DUMP_FILE, DOWNLOAD_DIAGNOSTIC_HTTP, DOWNLOAD_DIAGNOSTIC, "usp");
if(strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_FTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_FTP)) == 0)
if (strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_FTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_FTP)) == 0)
extract_stats(DOWNLOAD_DUMP_FILE, DOWNLOAD_DIAGNOSTIC_FTP, DOWNLOAD_DIAGNOSTIC, "usp");
} else if (status && strncmp(status, "Error_", strlen("Error_")) == 0)
return -1;
} else {
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 6, UPLOAD_DIAGNOSTIC_PATH, "run", "usp", url, interface, size);
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
dmuci_get_varstate_string("cwmp", "@uploaddiagnostic[0]", "url", &url);
dmuci_get_varstate_string("cwmp", "@uploaddiagnostic[0]", "DiagnosticState", &status);
url = get_diagnostics_option("upload", "url");
status = get_diagnostics_option("upload", "DiagnosticState");
if (status && strcmp(status, "Complete") == 0) {
init_upload_stats();
if(strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_HTTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_HTTP)) == 0)
if (strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_HTTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_HTTP)) == 0)
extract_stats(UPLOAD_DUMP_FILE, DOWNLOAD_DIAGNOSTIC_HTTP, UPLOAD_DIAGNOSTIC, "usp");
if(strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_FTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_FTP)) == 0)
if (strncmp(url, DOWNLOAD_UPLOAD_PROTOCOL_FTP, strlen(DOWNLOAD_UPLOAD_PROTOCOL_FTP)) == 0)
extract_stats(UPLOAD_DUMP_FILE, DOWNLOAD_DIAGNOSTIC_FTP, UPLOAD_DIAGNOSTIC, "usp");
} else if (status && strncmp(status, "Error_", strlen("Error_")) == 0)
return -1;

6
dmdiagnostics.h
View file

@ -23,6 +23,7 @@
#define FTP_TRANSFERT_COMPLETE "226 Transfer"
#define FTP_RETR_REQUEST "RETR"
#define FTP_STOR_REQUEST "STOR"
#define DMMAP_DIAGNOSTIGS "dmmap_diagnostics"
struct download_diag
{
@ -70,8 +71,9 @@ enum diagnostic_type {
UPLOAD_DIAGNOSTIC
};
char *get_param_diagnostics(char *diag, char *option);
void set_param_diagnostics(char *diag, char *option, char *value);
char *get_diagnostics_option(char *sec_name, char *option);
char *get_diagnostics_option_fallback_def(char *sec_name, char *option, char *default_value);
void set_diagnostics_option(char *sec_name, char *option, char *value);
void init_download_stats(void);
void init_upload_stats(void);
int extract_stats(char *dump_file, int proto, int diagnostic_type, char *protocol);

15
dmentry.c
View file

@ -119,12 +119,9 @@ static int dm_ctx_init_custom(struct dmctx *ctx, unsigned int dm_type, unsigned
#ifdef BBF_TR064
UPNP_SUPPORTED_DM *tUPNPSupportedDM = NULL;
#endif
if (custom == CTX_INIT_ALL) {
uci_ctx = uci_alloc_context();
uci_varstate_ctx = uci_alloc_context();
DMUCI_INIT(bbfdm);
get_db_config_path();
}
if (custom == CTX_INIT_ALL)
dmuci_init();
INIT_LIST_HEAD(&ctx->list_parameter);
INIT_LIST_HEAD(&ctx->set_list_tmp);
INIT_LIST_HEAD(&ctx->list_fault_param);
@ -165,11 +162,7 @@ static int dm_ctx_clean_custom(struct dmctx *ctx, int custom)
free_all_list_fault_param(ctx);
DMFREE(ctx->addobj_instance);
if (custom == CTX_INIT_ALL) {
if (uci_ctx) uci_free_context(uci_ctx);
uci_ctx = NULL;
if (uci_varstate_ctx) uci_free_context(uci_varstate_ctx);
uci_varstate_ctx = NULL;
DMUCI_EXIT(bbfdm);
dmuci_end();
dmubus_free();
dmcleanmem();
}

416
dmoperate.c
View file

@ -33,7 +33,7 @@ struct op_cmd *dynamic_operate = NULL;
bool is_str_eq(const char *s1, const char *s2)
{
if(0==strcmp(s1, s2))
if (0==strcmp(s1, s2))
return true;
return false;
@ -89,7 +89,7 @@ static bool bbf_set_value(char *path, char *value)
fault = dm_entry_param_method(&dm_ctx, CMD_SET_VALUE, path, value, NULL);
if(!fault) {
if (!fault) {
fault = dm_entry_apply(&dm_ctx, CMD_SET_VALUE, "", NULL);
}
@ -113,7 +113,7 @@ static char *bbf_get_value_by_id(char *id)
char *value = NULL;
bbf_init(&dm_ctx, id);
if(bbf_get(CMD_GET_VALUE, id, &dm_ctx)) {
if (bbf_get(CMD_GET_VALUE, id, &dm_ctx)) {
list_for_each_entry(n, &dm_ctx.list_parameter, list) {
value = dmstrdup(n->data);
break;
@ -141,10 +141,9 @@ static char *get_param_val_from_op_cmd(char *op_cmd, const char *param)
return val;
}
// Operate function definitions
static opr_ret_t reboot_device(struct dmctx *dmctx, char *path, json_object *input)
{
if(0 == dmubus_call_set(SYSTEM_UBUS_PATH, "reboot", UBUS_ARGS{}, 0))
if (0 == dmubus_call_set(SYSTEM_UBUS_PATH, "reboot", UBUS_ARGS{}, 0))
return SUCCESS;
else
return FAIL;
@ -152,7 +151,7 @@ static opr_ret_t reboot_device(struct dmctx *dmctx, char *path, json_object *inp
static opr_ret_t factory_reset(struct dmctx *dmctx, char *path, json_object *input)
{
if(0 == dmcmd_no_wait("/sbin/defaultreset", 0))
if (0 == dmcmd_no_wait("/sbin/defaultreset", 0))
return SUCCESS;
else
return FAIL;
@ -166,19 +165,19 @@ static opr_ret_t network_interface_reset(struct dmctx *dmctx, char *path, json_o
snprintf(cmd + strlen(cmd), NAME_MAX - strlen(cmd), "%s", ".");
char *zone = NULL;
zone = get_param_val_from_op_cmd(path, "Name");
if(zone) {
if (zone) {
strcat(cmd, zone);
dmfree(zone);
} else {
return FAIL;
}
if(0 == dmubus_call_set(cmd, "down", UBUS_ARGS{}, 0))
if (0 == dmubus_call_set(cmd, "down", UBUS_ARGS{}, 0))
status = true;
if(0 == dmubus_call_set(cmd, "up", UBUS_ARGS{}, 0))
if (0 == dmubus_call_set(cmd, "up", UBUS_ARGS{}, 0))
status &= true;
if(status)
if (status)
return SUCCESS;
else
return FAIL;
@ -186,7 +185,7 @@ static opr_ret_t network_interface_reset(struct dmctx *dmctx, char *path, json_o
static opr_ret_t wireless_reset(struct dmctx *dmctx, char *path, json_object *input)
{
if(0 == dmcmd_no_wait("/sbin/wifi", 2, "reload", "&"))
if (0 == dmcmd_no_wait("/sbin/wifi", 2, "reload", "&"))
return SUCCESS;
else
return FAIL;
@ -233,7 +232,7 @@ static opr_ret_t ap_security_reset(struct dmctx *dmctx, char *path, json_object
static opr_ret_t dhcp_client_renew(struct dmctx *dmctx, char *path, json_object *input)
{
if(SUCCESS == bbf_set_value(path, "true"))
if (SUCCESS == bbf_set_value(path, "true"))
return SUCCESS;
else
return FAIL;
@ -249,7 +248,7 @@ static opr_ret_t vendor_conf_backup(struct dmctx *dmctx, char *path, json_object
return FAIL;
fserver.url = dmjson_get_value(input, 1, "URL");
if(fserver.url[0] == '\0')
if (fserver.url[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
fserver.user = dmjson_get_value(input, 1, "Username");
@ -267,7 +266,7 @@ static opr_ret_t vendor_conf_restore(struct dmctx *dmctx, char *path, json_objec
char *file_size = NULL;
fserver.url = dmjson_get_value(input, 1, "URL");
if(fserver.url[0] == '\0')
if (fserver.url[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
fserver.user = dmjson_get_value(input, 1, "Username");
@ -346,7 +345,7 @@ static opr_ret_t ip_diagnostics_ipping(struct dmctx *dmctx, char *path, json_obj
struct ipping_diagnostics ipping = {0};
ipping.host = dmjson_get_value(input, 1, "Host");
if(ipping.host[0] == '\0')
if (ipping.host[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
ipping.interface = dmjson_get_value(input, 1, "Interface");
ipping.proto = dmjson_get_value(input, 1, "ProtocolVersion");
@ -355,48 +354,39 @@ static opr_ret_t ip_diagnostics_ipping(struct dmctx *dmctx, char *path, json_obj
ipping.datablocksize = dmjson_get_value(input, 1, "DataBlockSize");
ipping.dscp = dmjson_get_value(input, 1, "DSCP");
set_param_diagnostics("ippingdiagnostic", "Host", ipping.host);
set_param_diagnostics("ippingdiagnostic", "interface", ipping.interface);
set_param_diagnostics("ippingdiagnostic", "ProtocolVersion", ipping.proto);
set_param_diagnostics("ippingdiagnostic", "NumberOfRepetitions", ipping.nbofrepetition);
set_param_diagnostics("ippingdiagnostic", "Timeout", ipping.timeout);
set_param_diagnostics("ippingdiagnostic", "DataBlockSize", ipping.datablocksize);
set_param_diagnostics("ippingdiagnostic", "DSCP", ipping.dscp);
set_diagnostics_option("ipping", "Host", ipping.host);
set_diagnostics_option("ipping", "interface", ipping.interface);
set_diagnostics_option("ipping", "ProtocolVersion", ipping.proto);
set_diagnostics_option("ipping", "NumberOfRepetitions", ipping.nbofrepetition);
set_diagnostics_option("ipping", "Timeout", ipping.timeout);
set_diagnostics_option("ipping", "DataBlockSize", ipping.datablocksize);
set_diagnostics_option("ipping", "DSCP", ipping.dscp);
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 3, IPPING_PATH, "run", "usp");
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
ipping.success_count = get_param_diagnostics("ippingdiagnostic", "SuccessCount");
ipping.failure_count = get_param_diagnostics("ippingdiagnostic", "FailureCount");
ipping.average_response_time = get_param_diagnostics("ippingdiagnostic", "AverageResponseTime");
ipping.minimum_response_time = get_param_diagnostics("ippingdiagnostic", "MinimumResponseTime");
ipping.maximum_response_time = get_param_diagnostics("ippingdiagnostic", "MaximumResponseTime");
ipping.average_response_time_detailed = get_param_diagnostics("ippingdiagnostic", "AverageResponseTimeDetailed");
ipping.minimum_response_time_detailed = get_param_diagnostics("ippingdiagnostic", "MinimumResponseTimeDetailed");
ipping.maximum_response_time_detailed = get_param_diagnostics("ippingdiagnostic", "MaximumResponseTimeDetailed");
ipping.success_count = get_diagnostics_option("ipping", "SuccessCount");
ipping.failure_count = get_diagnostics_option("ipping", "FailureCount");
ipping.average_response_time = get_diagnostics_option("ipping", "AverageResponseTime");
ipping.minimum_response_time = get_diagnostics_option("ipping", "MinimumResponseTime");
ipping.maximum_response_time = get_diagnostics_option("ipping", "MaximumResponseTime");
ipping.average_response_time_detailed = get_diagnostics_option("ipping", "AverageResponseTimeDetailed");
ipping.minimum_response_time_detailed = get_diagnostics_option("ipping", "MinimumResponseTimeDetailed");
ipping.maximum_response_time_detailed = get_diagnostics_option("ipping", "MaximumResponseTimeDetailed");
char *param_success_count = dmstrdup("SuccessCount");
char *param_failure_count = dmstrdup("FailureCount");
char *param_average_response_time = dmstrdup("AverageResponseTime");
char *param_minimum_response_time = dmstrdup("MinimumResponseTime");
char *param_maximum_response_time = dmstrdup("MaximumResponseTime");
char *param_average_response_time_detailed = dmstrdup("AverageResponseTimeDetailed");
char *param_minimum_response_time_detailed = dmstrdup("MinimumResponseTimeDetailed");
char *param_maximum_response_time_detailed = dmstrdup("MaximumResponseTimeDetailed");
add_list_paramameter(dmctx, param_success_count, ipping.success_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_failure_count, ipping.failure_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_average_response_time, ipping.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_minimum_response_time, ipping.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_maximum_response_time, ipping.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_average_response_time_detailed, ipping.average_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_minimum_response_time_detailed, ipping.minimum_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_maximum_response_time_detailed, ipping.maximum_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("SuccessCount"), ipping.success_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("FailureCount"), ipping.failure_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("AverageResponseTime"), ipping.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MinimumResponseTime"), ipping.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MaximumResponseTime"), ipping.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("AverageResponseTimeDetailed"), ipping.average_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MinimumResponseTimeDetailed"), ipping.minimum_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MaximumResponseTimeDetailed"), ipping.maximum_response_time_detailed, DMT_TYPE[DMT_UNINT], NULL, 0);
return SUCCESS;
}
@ -409,7 +399,7 @@ static opr_ret_t ip_diagnostics_traceroute(struct dmctx *dmctx, char *path, json
int i = 1;
traceroute.host = dmjson_get_value(input, 1, "Host");
if(traceroute.host[0] == '\0')
if (traceroute.host[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
traceroute.interface = dmjson_get_value(input, 1, "Interface");
traceroute.proto = dmjson_get_value(input, 1, "ProtocolVersion");
@ -419,29 +409,27 @@ static opr_ret_t ip_diagnostics_traceroute(struct dmctx *dmctx, char *path, json
traceroute.dscp = dmjson_get_value(input, 1, "DSCP");
traceroute.maxhops = dmjson_get_value(input, 1, "MaxHopCount");
set_param_diagnostics("traceroutediagnostic", "Host", traceroute.host);
set_param_diagnostics("traceroutediagnostic", "interface", traceroute.interface);
set_param_diagnostics("traceroutediagnostic", "ProtocolVersion", traceroute.proto);
set_param_diagnostics("traceroutediagnostic", "NumberOfTries", traceroute.nboftries);
set_param_diagnostics("traceroutediagnostic", "Timeout", traceroute.timeout);
set_param_diagnostics("traceroutediagnostic", "DataBlockSize", traceroute.datablocksize);
set_param_diagnostics("traceroutediagnostic", "DSCP", traceroute.dscp);
set_param_diagnostics("traceroutediagnostic", "MaxHops", traceroute.maxhops);
set_diagnostics_option("traceroute", "Host", traceroute.host);
set_diagnostics_option("traceroute", "interface", traceroute.interface);
set_diagnostics_option("traceroute", "ProtocolVersion", traceroute.proto);
set_diagnostics_option("traceroute", "NumberOfTries", traceroute.nboftries);
set_diagnostics_option("traceroute", "Timeout", traceroute.timeout);
set_diagnostics_option("traceroute", "DataBlockSize", traceroute.datablocksize);
set_diagnostics_option("traceroute", "DSCP", traceroute.dscp);
set_diagnostics_option("traceroute", "MaxHops", traceroute.maxhops);
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 3, TRACEROUTE_PATH, "run", "usp");
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
traceroute.response_time = get_param_diagnostics("traceroutediagnostic", "ResponseTime");
char *param_response_time = dmstrdup("ResponseTime");
add_list_paramameter(dmctx, param_response_time, traceroute.response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
traceroute.response_time = get_diagnostics_option("traceroute", "ResponseTime");
add_list_paramameter(dmctx, dmstrdup("ResponseTime"), traceroute.response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
uci_foreach_sections_state("cwmp", "RouteHops", s)
{
uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "RouteHops", s) {
dmasprintf(&host, "RouteHops.%d.Host", i);
dmasprintf(&host_address, "RouteHops.%d.HostAddress", i);
dmasprintf(&errorcode, "RouteHops.%d.ErrorCode", i);
@ -466,7 +454,7 @@ static opr_ret_t ip_diagnostics_download(struct dmctx *dmctx, char *path, json_o
struct download_diagnostics download = {0};
download.download_url = dmjson_get_value(input, 1, "DownloadURL");
if(download.download_url[0] == '\0')
if (download.download_url[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
download.interface = dmjson_get_value(input, 1, "Interface");
download.dscp = dmjson_get_value(input, 1, "DSCP");
@ -475,55 +463,42 @@ static opr_ret_t ip_diagnostics_download(struct dmctx *dmctx, char *path, json_o
download.num_of_connections = dmjson_get_value(input, 1, "NumberOfConnections");
download.enable_per_connection_results = dmjson_get_value(input, 1, "EnablePerConnectionResults");
set_param_diagnostics("downloaddiagnostic", "url", download.download_url);
set_param_diagnostics("downloaddiagnostic", "device", download.interface);
set_param_diagnostics("downloaddiagnostic", "DSCP", download.dscp);
set_param_diagnostics("downloaddiagnostic", "ethernetpriority", download.ethernet_priority);
set_param_diagnostics("downloaddiagnostic", "ProtocolVersion", download.proto);
set_param_diagnostics("downloaddiagnostic", "NumberOfConnections", download.num_of_connections);
set_param_diagnostics("downloaddiagnostic", "EnablePerConnection", download.enable_per_connection_results);
set_diagnostics_option("download", "url", download.download_url);
set_diagnostics_option("download", "device", download.interface);
set_diagnostics_option("download", "DSCP", download.dscp);
set_diagnostics_option("download", "ethernetpriority", download.ethernet_priority);
set_diagnostics_option("download", "ProtocolVersion", download.proto);
set_diagnostics_option("download", "NumberOfConnections", download.num_of_connections);
set_diagnostics_option("download", "EnablePerConnection", download.enable_per_connection_results);
if(start_upload_download_diagnostic(DOWNLOAD_DIAGNOSTIC) == -1)
if (start_upload_download_diagnostic(DOWNLOAD_DIAGNOSTIC) == -1)
return FAIL;
download.romtime = get_param_diagnostics("downloaddiagnostic", "ROMtime");
download.bomtime = get_param_diagnostics("downloaddiagnostic", "BOMtime");
download.eomtime = get_param_diagnostics("downloaddiagnostic", "EOMtime");
download.test_bytes_received = get_param_diagnostics("downloaddiagnostic", "TestBytesReceived");
download.total_bytes_received = get_param_diagnostics("downloaddiagnostic", "TotalBytesReceived");
download.total_bytes_sent = get_param_diagnostics("downloaddiagnostic", "TotalBytesSent");
download.test_bytes_received_under_full_loading = get_param_diagnostics("downloaddiagnostic", "TestBytesReceived");
download.total_bytes_received_under_full_loading = get_param_diagnostics("downloaddiagnostic", "TotalBytesReceived");
download.total_bytes_sent_under_full_loading = get_param_diagnostics("downloaddiagnostic", "TotalBytesSent");
download.period_of_full_loading = get_param_diagnostics("downloaddiagnostic", "PeriodOfFullLoading");
download.tcp_open_request_time = get_param_diagnostics("downloaddiagnostic", "TCPOpenRequestTimes");
download.tcp_open_response_time = get_param_diagnostics("downloaddiagnostic", "TCPOpenResponseTime");
download.romtime = get_diagnostics_option("download", "ROMtime");
download.bomtime = get_diagnostics_option("download", "BOMtime");
download.eomtime = get_diagnostics_option("download", "EOMtime");
download.test_bytes_received = get_diagnostics_option("download", "TestBytesReceived");
download.total_bytes_received = get_diagnostics_option("download", "TotalBytesReceived");
download.total_bytes_sent = get_diagnostics_option("download", "TotalBytesSent");
download.test_bytes_received_under_full_loading = get_diagnostics_option("download", "TestBytesReceived");
download.total_bytes_received_under_full_loading = get_diagnostics_option("download", "TotalBytesReceived");
download.total_bytes_sent_under_full_loading = get_diagnostics_option("download", "TotalBytesSent");
download.period_of_full_loading = get_diagnostics_option("download", "PeriodOfFullLoading");
download.tcp_open_request_time = get_diagnostics_option("download", "TCPOpenRequestTimes");
download.tcp_open_response_time = get_diagnostics_option("download", "TCPOpenResponseTime");
char *param_rom_time = dmstrdup("ROMTime");
char *param_bom_time = dmstrdup("BOMTime");
char *param_eom_time = dmstrdup("EOMTime");
char *param_test_bytes_received = dmstrdup("TestBytesReceived");
char *param_total_bytes_received = dmstrdup("TotalBytesReceived");
char *param_total_bytes_sent = dmstrdup("TotalBytesSent");
char *param_test_bytes_received_under_full_loading = dmstrdup("TestBytesReceivedUnderFullLoading");
char *param_total_bytes_received_under_full_loading = dmstrdup("TotalBytesReceivedUnderFullLoading");
char *param_total_bytes_sent_under_full_loading = dmstrdup("TotalBytesSentUnderFullLoading");
char *param_period_of_full_loading = dmstrdup("PeriodOfFullLoading");
char *param_tcp_open_request_time = dmstrdup("TCPOpenRequestTime");
char *param_tcp_open_response_time = dmstrdup("TCPOpenResponseTime");
add_list_paramameter(dmctx, param_rom_time, download.romtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_bom_time, download.bomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_eom_time, download.eomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_test_bytes_received, download.test_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_received, download.total_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_sent, download.total_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_test_bytes_received_under_full_loading, download.test_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_received_under_full_loading, download.total_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_sent_under_full_loading, download.total_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_period_of_full_loading, download.period_of_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_tcp_open_request_time, download.tcp_open_request_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_tcp_open_response_time, download.tcp_open_response_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("ROMTime"), download.romtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("BOMTime"), download.bomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("EOMTime"), download.eomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TestBytesReceived"), download.test_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesReceived"), download.total_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesSent"), download.total_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TestBytesReceivedUnderFullLoading"), download.test_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesReceivedUnderFullLoading"), download.total_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesSentUnderFullLoading"), download.total_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("PeriodOfFullLoading"), download.period_of_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TCPOpenRequestTime"), download.tcp_open_request_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TCPOpenResponseTime"), download.tcp_open_response_time, DMT_TYPE[DMT_TIME], NULL, 0);
return SUCCESS;
}
@ -533,10 +508,10 @@ static opr_ret_t ip_diagnostics_upload(struct dmctx *dmctx, char *path, json_obj
struct upload_diagnostics upload = {0};
upload.upload_url = dmjson_get_value(input, 1, "UploadURL");
if(upload.upload_url[0] == '\0')
if (upload.upload_url[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
upload.test_file_length = dmjson_get_value(input, 1, "TestFileLength");
if(upload.test_file_length[0] == '\0')
if (upload.test_file_length[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
upload.interface = dmjson_get_value(input, 1, "Interface");
upload.dscp = dmjson_get_value(input, 1, "DSCP");
@ -545,56 +520,43 @@ static opr_ret_t ip_diagnostics_upload(struct dmctx *dmctx, char *path, json_obj
upload.num_of_connections = dmjson_get_value(input, 1, "NumberOfConnections");
upload.enable_per_connection_results = dmjson_get_value(input, 1, "EnablePerConnectionResults");
set_param_diagnostics("uploaddiagnostic", "url", upload.upload_url);
set_param_diagnostics("uploaddiagnostic", "TestFileLength", upload.test_file_length);
set_param_diagnostics("uploaddiagnostic", "device", upload.interface);
set_param_diagnostics("uploaddiagnostic", "DSCP", upload.dscp);
set_param_diagnostics("uploaddiagnostic", "ethernetpriority", upload.ethernet_priority);
set_param_diagnostics("uploaddiagnostic", "ProtocolVersion", upload.proto);
set_param_diagnostics("uploaddiagnostic", "NumberOfConnections", upload.num_of_connections);
set_param_diagnostics("uploaddiagnostic", "EnablePerConnection", upload.enable_per_connection_results);
set_diagnostics_option("upload", "url", upload.upload_url);
set_diagnostics_option("upload", "TestFileLength", upload.test_file_length);
set_diagnostics_option("upload", "device", upload.interface);
set_diagnostics_option("upload", "DSCP", upload.dscp);
set_diagnostics_option("upload", "ethernetpriority", upload.ethernet_priority);
set_diagnostics_option("upload", "ProtocolVersion", upload.proto);
set_diagnostics_option("upload", "NumberOfConnections", upload.num_of_connections);
set_diagnostics_option("upload", "EnablePerConnection", upload.enable_per_connection_results);
if(start_upload_download_diagnostic(UPLOAD_DIAGNOSTIC) == -1)
if (start_upload_download_diagnostic(UPLOAD_DIAGNOSTIC) == -1)
return FAIL;
upload.romtime = get_param_diagnostics("uploaddiagnostic", "ROMtime");
upload.bomtime = get_param_diagnostics("uploaddiagnostic", "BOMtime");
upload.eomtime = get_param_diagnostics("uploaddiagnostic", "EOMtime");
upload.test_bytes_sent = get_param_diagnostics("uploaddiagnostic", "TestBytesSent");
upload.total_bytes_received = get_param_diagnostics("uploaddiagnostic", "TotalBytesReceived");
upload.total_bytes_sent = get_param_diagnostics("uploaddiagnostic", "TotalBytesSent");
upload.test_bytes_sent_under_full_loading = get_param_diagnostics("uploaddiagnostic", "TestBytesSent");
upload.total_bytes_received_under_full_loading = get_param_diagnostics("uploaddiagnostic", "TotalBytesReceived");
upload.total_bytes_sent_under_full_loading = get_param_diagnostics("uploaddiagnostic", "TotalBytesSent");
upload.period_of_full_loading = get_param_diagnostics("uploaddiagnostic", "PeriodOfFullLoading");
upload.tcp_open_request_time = get_param_diagnostics("uploaddiagnostic", "TCPOpenRequestTimes");
upload.tcp_open_response_time = get_param_diagnostics("uploaddiagnostic", "TCPOpenResponseTime");
upload.romtime = get_diagnostics_option("upload", "ROMtime");
upload.bomtime = get_diagnostics_option("upload", "BOMtime");
upload.eomtime = get_diagnostics_option("upload", "EOMtime");
upload.test_bytes_sent = get_diagnostics_option("upload", "TestBytesSent");
upload.total_bytes_received = get_diagnostics_option("upload", "TotalBytesReceived");
upload.total_bytes_sent = get_diagnostics_option("upload", "TotalBytesSent");
upload.test_bytes_sent_under_full_loading = get_diagnostics_option("upload", "TestBytesSent");
upload.total_bytes_received_under_full_loading = get_diagnostics_option("upload", "TotalBytesReceived");
upload.total_bytes_sent_under_full_loading = get_diagnostics_option("upload", "TotalBytesSent");
upload.period_of_full_loading = get_diagnostics_option("upload", "PeriodOfFullLoading");
upload.tcp_open_request_time = get_diagnostics_option("upload", "TCPOpenRequestTimes");
upload.tcp_open_response_time = get_diagnostics_option("upload", "TCPOpenResponseTime");
char *param_rom_time = dmstrdup("ROMTime");
char *param_bom_time = dmstrdup("BOMTime");
char *param_eom_time = dmstrdup("EOMTime");
char *param_test_bytes_sent = dmstrdup("TestBytesSent");
char *param_total_bytes_received = dmstrdup("TotalBytesReceived");
char *param_total_bytes_sent = dmstrdup("TotalBytesSent");
char *param_test_bytes_sent_under_full_loading = dmstrdup("TestBytesSentUnderFullLoading");
char *param_total_bytes_received_under_full_loading = dmstrdup("TotalBytesReceivedUnderFullLoading");
char *param_total_bytes_sent_under_full_loading = dmstrdup("TotalBytesSentUnderFullLoading");
char *param_period_of_full_loading = dmstrdup("PeriodOfFullLoading");
char *param_tcp_open_request_time = dmstrdup("TCPOpenRequestTime");
char *param_tcp_open_response_time = dmstrdup("TCPOpenResponseTime");
add_list_paramameter(dmctx, param_rom_time, upload.romtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_bom_time, upload.bomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_eom_time, upload.eomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_test_bytes_sent, upload.test_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_received, upload.total_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_sent, upload.total_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_test_bytes_sent_under_full_loading, upload.test_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_received_under_full_loading, upload.total_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_total_bytes_sent_under_full_loading, upload.total_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_period_of_full_loading, upload.period_of_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_tcp_open_request_time, upload.tcp_open_request_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, param_tcp_open_response_time, upload.tcp_open_response_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("ROMTime"), upload.romtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("BOMTime"), upload.bomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("EOMTime"), upload.eomtime, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TestBytesSent"), upload.test_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesReceived"), upload.total_bytes_received, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesSent"), upload.total_bytes_sent, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TestBytesSentUnderFullLoading"), upload.test_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesReceivedUnderFullLoading"), upload.total_bytes_received_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TotalBytesSentUnderFullLoading"), upload.total_bytes_sent_under_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("PeriodOfFullLoading"), upload.period_of_full_loading, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TCPOpenRequestTime"), upload.tcp_open_request_time, DMT_TYPE[DMT_TIME], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("TCPOpenResponseTime"), upload.tcp_open_response_time, DMT_TYPE[DMT_TIME], NULL, 0);
return SUCCESS;
}
@ -604,10 +566,10 @@ static opr_ret_t ip_diagnostics_udpecho(struct dmctx *dmctx, char *path, json_ob
struct udpecho_diagnostics udpecho = {0};
udpecho.host = dmjson_get_value(input, 1, "Host");
if(udpecho.host[0] == '\0')
if (udpecho.host[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
udpecho.port = dmjson_get_value(input, 1, "Port");
if(udpecho.port[0] == '\0')
if (udpecho.port[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
udpecho.interface = dmjson_get_value(input, 1, "Interface");
@ -618,41 +580,35 @@ static opr_ret_t ip_diagnostics_udpecho(struct dmctx *dmctx, char *path, json_ob
udpecho.dscp = dmjson_get_value(input, 1, "DSCP");
udpecho.inter_transmission_time = dmjson_get_value(input, 1, "InterTransmissionTime");
set_param_diagnostics("udpechodiagnostic", "Host", udpecho.host);
set_param_diagnostics("udpechodiagnostic", "port", udpecho.port);
set_param_diagnostics("udpechodiagnostic", "interface", udpecho.interface);
set_param_diagnostics("udpechodiagnostic", "ProtocolVersion", udpecho.proto);
set_param_diagnostics("udpechodiagnostic", "NumberOfRepetitions", udpecho.nbofrepetition);
set_param_diagnostics("udpechodiagnostic", "Timeout", udpecho.timeout);
set_param_diagnostics("udpechodiagnostic", "DataBlockSize", udpecho.datablocksize);
set_param_diagnostics("udpechodiagnostic", "DSCP", udpecho.dscp);
set_param_diagnostics("udpechodiagnostic", "InterTransmissionTime", udpecho.inter_transmission_time);
set_diagnostics_option("udpechodiag", "Host", udpecho.host);
set_diagnostics_option("udpechodiag", "port", udpecho.port);
set_diagnostics_option("udpechodiag", "interface", udpecho.interface);
set_diagnostics_option("udpechodiag", "ProtocolVersion", udpecho.proto);
set_diagnostics_option("udpechodiag", "NumberOfRepetitions", udpecho.nbofrepetition);
set_diagnostics_option("udpechodiag", "Timeout", udpecho.timeout);
set_diagnostics_option("udpechodiag", "DataBlockSize", udpecho.datablocksize);
set_diagnostics_option("udpechodiag", "DSCP", udpecho.dscp);
set_diagnostics_option("udpechodiag", "InterTransmissionTime", udpecho.inter_transmission_time);
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 3, UDPECHO_PATH, "run", "usp");
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
udpecho.success_count = get_param_diagnostics("udpechodiagnostic", "SuccessCount");
udpecho.failure_count = get_param_diagnostics("udpechodiagnostic", "FailureCount");
udpecho.average_response_time = get_param_diagnostics("udpechodiagnostic", "AverageResponseTime");
udpecho.minimum_response_time = get_param_diagnostics("udpechodiagnostic", "MinimumResponseTime");
udpecho.maximum_response_time = get_param_diagnostics("udpechodiagnostic", "MaximumResponseTime");
udpecho.success_count = get_diagnostics_option("udpechodiag", "SuccessCount");
udpecho.failure_count = get_diagnostics_option("udpechodiag", "FailureCount");
udpecho.average_response_time = get_diagnostics_option("udpechodiag", "AverageResponseTime");
udpecho.minimum_response_time = get_diagnostics_option("udpechodiag", "MinimumResponseTime");
udpecho.maximum_response_time = get_diagnostics_option("udpechodiag", "MaximumResponseTime");
char *param_success_count = dmstrdup("SuccessCount");
char *param_failure_count = dmstrdup("FailureCount");
char *param_average_response_time = dmstrdup("AverageResponseTime");
char *param_minimum_response_time = dmstrdup("MinimumResponseTime");
char *param_maximum_response_time = dmstrdup("MaximumResponseTime");
add_list_paramameter(dmctx, param_success_count, udpecho.success_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_failure_count, udpecho.failure_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_average_response_time, udpecho.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_minimum_response_time, udpecho.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_maximum_response_time, udpecho.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("SuccessCount"), udpecho.success_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("FailureCount"), udpecho.failure_count, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("AverageResponseTime"), udpecho.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MinimumResponseTime"), udpecho.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MaximumResponseTime"), udpecho.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
return SUCCESS;
}
@ -662,12 +618,12 @@ static opr_ret_t ip_diagnostics_serverselection(struct dmctx *dmctx, char *path,
struct serverselection_diagnostics serverselection = {0};
serverselection.hostlist = dmjson_get_value(input, 1, "HostList");
if(serverselection.hostlist[0] == '\0')
if (serverselection.hostlist[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
serverselection.port = dmjson_get_value(input, 1, "Port");
serverselection.proto = dmjson_get_value(input, 1, "Protocol");
if (strcmp(serverselection.proto, "ICMP")) {
if(serverselection.port[0] == '\0')
if (serverselection.port[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
}
serverselection.protocol_version = dmjson_get_value(input, 1, "ProtocolVersion");
@ -675,36 +631,31 @@ static opr_ret_t ip_diagnostics_serverselection(struct dmctx *dmctx, char *path,
serverselection.nbofrepetition = dmjson_get_value(input, 1, "NumberOfRepetitions");
serverselection.timeout = dmjson_get_value(input, 1, "Timeout");
set_param_diagnostics("serverselectiondiagnostic", "HostList", serverselection.hostlist);
set_param_diagnostics("serverselectiondiagnostic", "interface", serverselection.interface);
set_param_diagnostics("serverselectiondiagnostic", "ProtocolVersion", serverselection.protocol_version);
set_param_diagnostics("serverselectiondiagnostic", "NumberOfRepetitions", serverselection.nbofrepetition);
set_param_diagnostics("serverselectiondiagnostic", "port", serverselection.port);
set_param_diagnostics("serverselectiondiagnostic", "Protocol", serverselection.proto);
set_param_diagnostics("serverselectiondiagnostic", "Timeout", serverselection.timeout);
set_diagnostics_option("serverselection", "HostList", serverselection.hostlist);
set_diagnostics_option("serverselection", "interface", serverselection.interface);
set_diagnostics_option("serverselection", "ProtocolVersion", serverselection.protocol_version);
set_diagnostics_option("serverselection", "NumberOfRepetitions", serverselection.nbofrepetition);
set_diagnostics_option("serverselection", "port", serverselection.port);
set_diagnostics_option("serverselection", "Protocol", serverselection.proto);
set_diagnostics_option("serverselection", "Timeout", serverselection.timeout);
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 3, SERVERSELECTION_PATH, "run", "usp");
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
serverselection.fasthost = get_param_diagnostics("serverselectiondiagnostic", "FastestHost");
serverselection.average_response_time = get_param_diagnostics("serverselectiondiagnostic", "AverageResponseTime");
serverselection.minimum_response_time = get_param_diagnostics("serverselectiondiagnostic", "MinimumResponseTime");
serverselection.maximum_response_time = get_param_diagnostics("serverselectiondiagnostic", "MaximumResponseTime");
serverselection.fasthost = get_diagnostics_option("serverselection", "FastestHost");
serverselection.average_response_time = get_diagnostics_option("serverselection", "AverageResponseTime");
serverselection.minimum_response_time = get_diagnostics_option("serverselection", "MinimumResponseTime");
serverselection.maximum_response_time = get_diagnostics_option("serverselection", "MaximumResponseTime");
char *param_fastest_host = dmstrdup("FastestHost");
char *param_average_response_time = dmstrdup("AverageResponseTime");
char *param_minimum_response_time = dmstrdup("MinimumResponseTime");
char *param_maximum_response_time = dmstrdup("MaximumResponseTime");
add_list_paramameter(dmctx, param_fastest_host, serverselection.fasthost, DMT_TYPE[DMT_STRING], NULL, 0);
add_list_paramameter(dmctx, param_average_response_time, serverselection.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_minimum_response_time, serverselection.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, param_maximum_response_time, serverselection.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("FastestHost"), serverselection.fasthost, DMT_TYPE[DMT_STRING], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("AverageResponseTime"), serverselection.average_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MinimumResponseTime"), serverselection.minimum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
add_list_paramameter(dmctx, dmstrdup("MaximumResponseTime"), serverselection.maximum_response_time, DMT_TYPE[DMT_UNINT], NULL, 0);
return SUCCESS;
}
@ -717,33 +668,32 @@ static opr_ret_t ip_diagnostics_nslookup(struct dmctx *dmctx, char *path, json_o
int i = 1;
nslookup.hostname = dmjson_get_value(input, 1, "HostName");
if(nslookup.hostname[0] == '\0')
if (nslookup.hostname[0] == '\0')
return UBUS_INVALID_ARGUMENTS;
nslookup.interface = dmjson_get_value(input, 1, "Interface");
nslookup.dnsserver = dmjson_get_value(input, 1, "DNSServer");
nslookup.timeout = dmjson_get_value(input, 1, "Timeout");
nslookup.nbofrepetition = dmjson_get_value(input, 1, "NumberOfRepetitions");
set_param_diagnostics("nslookupdiagnostic", "HostName", nslookup.hostname);
set_param_diagnostics("nslookupdiagnostic", "interface", nslookup.interface);
set_param_diagnostics("nslookupdiagnostic", "DNSServer", nslookup.dnsserver);
set_param_diagnostics("nslookupdiagnostic", "Timeout", nslookup.timeout);
set_param_diagnostics("nslookupdiagnostic", "NumberOfRepetitions", nslookup.nbofrepetition);
set_diagnostics_option("nslookup", "HostName", nslookup.hostname);
set_diagnostics_option("nslookup", "interface", nslookup.interface);
set_diagnostics_option("nslookup", "DNSServer", nslookup.dnsserver);
set_diagnostics_option("nslookup", "Timeout", nslookup.timeout);
set_diagnostics_option("nslookup", "NumberOfRepetitions", nslookup.nbofrepetition);
//Free uci_varstate_ctx
end_uci_varstate_ctx();
// Commit and Free uci_ctx_bbfdm
commit_and_free_uci_ctx_bbfdm(DMMAP_DIAGNOSTIGS);
dmcmd("/bin/sh", 3, NSLOOKUP_PATH, "run", "usp");
//Allocate uci_varstate_ctx
init_uci_varstate_ctx();
// Allocate uci_ctx_bbfdm
alloc_uci_ctx_bbfdm();
nslookup.success_count = get_param_diagnostics("nslookupdiagnostic", "SuccessCount");
nslookup.success_count = get_diagnostics_option("nslookup", "SuccessCount");
char *param_success_count = dmstrdup("SuccessCount");
add_list_paramameter(dmctx, param_success_count, nslookup.success_count, DMT_TYPE[DMT_UNINT], NULL, 0);
uci_foreach_sections_state("cwmp", "NSLookupResult", s)
{
uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "NSLookupResult", s) {
dmasprintf(&status, "Result.%d.Status", i);
dmasprintf(&answertype, "Result.%d.AnswerType", i);
dmasprintf(&hostname, "Result.%d.HostNameReturned", i);

2
dmtree/tr064/upnp_configuration.c
View file

@ -281,7 +281,7 @@ int upnp_configuration_ipinterface_createinstance(char *refparam, struct dmctx *
dmstrappendstr(p, "ip_interface_");
dmstrappendstr(p, ib);
dmstrappendend(p);
dmuci_add_section_and_rename("network", "interface", &iface_sec, &value);
dmuci_add_section("network", "interface", &iface_sec, &value);
dmuci_set_value("network", ip_name, "", "interface");
dmuci_set_value("network", ip_name, "proto", "dhcp");
*instance = update_instance(iface_instance, 4, iface_sec, "upnp_ip_iface_instance", "network", "interface");

2
dmtree/tr064/upnp_deviceinfo.c
View file

@ -240,7 +240,7 @@ int upnp_deviceinfo_networkinterface_createinstance(char *refparam, struct dmctx
dmstrappendstr(p, ib);
dmstrappendend(p);
snprintf(ib, sizeof(ib), "%d", iface_instance ? atoi(iface_instance)+1 : 1);
dmuci_add_section_and_rename("network", "interface", &iface_sec, &value);
dmuci_add_section("network", "interface", &iface_sec, &value);
dmuci_set_value("network", ip_name, "", "interface");
dmuci_set_value("network", ip_name, "proto", "dhcp");
*instance = update_instance(iface_instance, 4, iface_sec, "upnp_iface_int_instance", "network", "interface");

4
dmtree/tr104/servicesvoiceservice.c
View file

@ -125,7 +125,7 @@ static int addObjServicesVoiceServiceVoIPProfile(char *refparam, struct dmctx *c
check_create_dmmap_package("dmmap_asterisk");
inst = get_last_instance_bbfdm("dmmap_asterisk", "sip_service_provider", "clientinstance");
dmuci_add_section_and_rename("asterisk", "sip_service_provider", &s, &value);
dmuci_add_section("asterisk", "sip_service_provider", &s, &value);
dmuci_add_section_bbfdm("dmmap_asterisk", "sip_service_provider", &dmmap, &v);
dmuci_set_value_by_section(dmmap, "section_name", section_name(s));
@ -174,7 +174,7 @@ static int addObjServicesVoiceServiceCodecProfile(char *refparam, struct dmctx *
check_create_dmmap_package("dmmap_asterisk");
inst = get_last_instance_bbfdm("dmmap_asterisk", "codec_profile", "codecprofileinstance");
dmuci_add_section_and_rename("asterisk", "codec_profile", &s, &value);
dmuci_add_section("asterisk", "codec_profile", &s, &value);
dmuci_add_section_bbfdm("dmmap_asterisk", "codec_profile", &dmmap, &v);
dmuci_set_value_by_section(dmmap, "section_name", section_name(s));

2
dmtree/tr104/servicesvoiceservicecallcontrol.c
View file

@ -218,7 +218,7 @@ static int addObjServicesVoiceServiceCallControlCallingFeaturesSetSCREJ(char *re
check_create_dmmap_package("dmmap_asterisk");
inst = get_last_instance_bbfdm("dmmap_asterisk", "call_filter_rule_incoming", "screjinstance");
dmuci_add_section_and_rename("asterisk", "call_filter_rule_incoming", &s, &value);
dmuci_add_section("asterisk", "call_filter_rule_incoming", &s, &value);
dmuci_add_section_bbfdm("dmmap_asterisk", "call_filter_rule_incoming", &dmmap, &v);
dmuci_set_value_by_section(dmmap, "section_name", section_name(s));

731
dmtree/tr143/diagnostics.c
View file

File diff suppressed because it is too large Load diff

10
dmtree/tr181/deviceinfo.c
View file

@ -342,7 +342,7 @@ static int browseVcfInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_da
uci_path_foreach_sections(bbfdm, DMMAP, "vcf", s) {
dmuci_get_value_by_section_string(s, "name", &name);
if(del_sec) {
DMUCI_DELETE_BY_SECTION(bbfdm, del_sec, NULL, NULL);
dmuci_delete_by_section_bbfdm(del_sec, NULL, NULL);
del_sec = NULL;
}
if (check_file_dir(name) == 0) {
@ -356,8 +356,10 @@ static int browseVcfInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_da
if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)s, inst) == DM_STOP)
break;
}
if(del_sec)
DMUCI_DELETE_BY_SECTION(bbfdm, del_sec, NULL, NULL);
dmuci_delete_by_section_bbfdm(del_sec, NULL, NULL);
return 0;
}
@ -379,8 +381,8 @@ static int browseVlfInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_da
if (!dm_sec) {
update_section_list(DMMAP,"vlf", NULL, i++, NULL, "log_file", log_file, "log_size", log_size);
} else {
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dm_sec, "log_file", log_file);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dm_sec, "log_size", log_size);
dmuci_set_value_by_section_bbfdm(dm_sec, "log_file", log_file);
dmuci_set_value_by_section_bbfdm(dm_sec, "log_size", log_size);
}
}
uci_path_foreach_sections(bbfdm, "dmmap", "vlf", dm_sec) {

58
dmtree/tr181/dhcpv4.c
View file

@ -107,7 +107,7 @@ int set_section_order(char *package, char *dmpackage, char* sect_type, struct uc
dmuci_get_value_by_section_string(dmmap_sect, "order", &v);
if (strlen(v) > 0 && strcmp(v, order) == 0)
return 0;
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "order", order);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "order", order);
if (conf == NULL) {
dmuci_get_value_by_section_string(dmmap_sect, "section_name", &sect_name);
get_config_section_of_dmmap_section(package, sect_type, sect_name, &s);
@ -365,8 +365,8 @@ static int addObjDHCPv4ClientSentOption(char *refparam, struct dmctx *ctx, void
instancepara = get_last_instance_lev2_bbfdm_dmmap_opt("dmmap_dhcp_client", "send_option", "bbf_dhcpv4_sentopt_instance", "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_add_section_bbfdm("dmmap_dhcp_client", "send_option", &dmmap_sect, &value);
if(dhcp_client_args->dhcp_client_conf != NULL)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", "0");
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", "0");
browse_args.option = "section_name";
browse_args.value = section_name(dhcp_client_args->dhcp_client_conf);
@ -414,8 +414,8 @@ static int addObjDHCPv4ClientReqOption(char *refparam, struct dmctx *ctx, void *
instancepara = get_last_instance_lev2_bbfdm_dmmap_opt("dmmap_dhcp_client", "req_option", "bbf_dhcpv4_sentopt_instance", "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_add_section_bbfdm("dmmap_dhcp_client", "req_option", &dmmap_sect, &value);
if(dhcp_client_args->dhcp_client_conf != NULL)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", "0");
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", "0");
browse_args.option = "section_name";
browse_args.value = section_name(dhcp_client_args->dhcp_client_conf);
@ -461,8 +461,8 @@ static int addObjDHCPv4ServerPoolOption(char *refparam, struct dmctx *ctx, void
instancepara = get_last_instance_lev2_bbfdm_dmmap_opt("dmmap_dhcp", "servpool_option", "bbf_dhcpv4_servpool_option_instance", "section_name", section_name(dhcp_arg->dhcp_sec));
dmuci_add_section_bbfdm("dmmap_dhcp", "servpool_option", &dmmap_sect, &value);
if(dhcp_arg->dhcp_sec != NULL)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_arg->dhcp_sec));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", "0");
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_arg->dhcp_sec));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", "0");
browse_args.option = "section_name";
browse_args.value = section_name(dhcp_arg->dhcp_sec);
@ -588,7 +588,7 @@ static int set_server_pool_alias(char *refparam, struct dmctx *ctx, void *data,
return 0;
case VALUESET:
get_dmmap_section_of_config_section("dmmap_dhcp", "dhcp", section_name(((struct dhcp_args *)data)->dhcp_sec), &dmmap_sect);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "dhcp_alias", value);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "dhcp_alias", value);
return 0;
}
return 0;
@ -991,7 +991,7 @@ static int set_dhcp_reserved_addresses(char *refparam, struct dmctx *ctx, void *
if (n_ip < n_min || n_ip > n_max)
continue;
dmuci_add_section_and_rename("dhcp", "host", &dhcp_section, &val);
dmuci_add_section("dhcp", "host", &dhcp_section, &val);
dmuci_set_value_by_section(dhcp_section, "dhcp", ((struct dhcp_args *)data)->interface);
dmuci_set_value_by_section(dhcp_section, "ip", pch);
}
@ -1548,7 +1548,7 @@ static int set_DHCPv4Client_Interface(char *refparam, struct dmctx *ctx, void *d
case VALUESET:
append_dot_to_string(interface, value, sizeof(interface));
adm_entry_get_linker_value(ctx, interface, &linker);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_args *)data)->dhcp_client_dm, "section_name", linker);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_args *)data)->dhcp_client_dm, "section_name", linker);
break;
}
return 0;
@ -1795,7 +1795,7 @@ static int set_DHCPv4ClientSentOption_Alias(char *refparam, struct dmctx *ctx, v
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_sentopt_alias", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_sentopt_alias", value);
break;
}
return 0;
@ -1834,7 +1834,7 @@ static int set_DHCPv4ClientSentOption_Tag(char *refparam, struct dmctx *ctx, voi
dmasprintf(&opttagvalue, "%s:%s", value, ((struct dhcp_client_option_args *)data)->value && strlen(((struct dhcp_client_option_args *)data)->value)>0 ? ((struct dhcp_client_option_args *)data)->value:"0");
add_elt_to_str_list(&v, opttagvalue);
dmuci_set_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "sendopts", v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
break;
}
return 0;
@ -1862,7 +1862,7 @@ static int set_DHCPv4ClientSentOption_Value(char *refparam, struct dmctx *ctx, v
dmasprintf(&opttagvalue, "%s:%s", ((struct dhcp_client_option_args *)data)->option_tag, value);
add_elt_to_str_list(&v, opttagvalue);
dmuci_set_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "sendopts", v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "option_value", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "option_value", value);
break;
}
return 0;
@ -1929,7 +1929,7 @@ static int set_DHCPv4ClientReqOption_Alias(char *refparam, struct dmctx *ctx, vo
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_reqtopt_alias", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_reqtopt_alias", value);
break;
}
return 0;
@ -1965,7 +1965,7 @@ static int set_DHCPv4ClientReqOption_Tag(char *refparam, struct dmctx *ctx, void
remove_elt_from_str_list(&v, ((struct dhcp_client_option_args *)data)->option_tag);
add_elt_to_str_list(&v, value);
dmuci_set_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "reqopts", v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
break;
}
return 0;
@ -2060,7 +2060,7 @@ static int set_DHCPv4ServerPoolOption_Alias(char *refparam, struct dmctx *ctx, v
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_servpool_option_alias", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "bbf_dhcpv4_servpool_option_alias", value);
break;
}
return 0;
@ -2099,7 +2099,7 @@ static int set_DHCPv4ServerPoolOption_Tag(char *refparam, struct dmctx *ctx, voi
dmuci_get_value_by_section_list(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", &dhcp_option_list);
dmuci_del_list_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", oldopttagvalue);
dmuci_add_list_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", opttagvalue);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "option_tag", value);
break;
}
return 0;
@ -2138,7 +2138,7 @@ static int set_DHCPv4ServerPoolOption_Value(char *refparam, struct dmctx *ctx, v
dmuci_get_value_by_section_list(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", &dhcp_option_list);
dmuci_del_list_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", oldopttagvalue);
dmuci_add_list_value_by_section(((struct dhcp_client_option_args *)data)->client_sect, "dhcp_option", opttagvalue);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_option_args *)data)->opt_sect, "option_value", value);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_option_args *)data)->opt_sect, "option_value", value);
break;
}
return 0;
@ -2247,7 +2247,7 @@ static int set_DHCPv4RelayForwarding_Interface(char *refparam, struct dmctx *ctx
case VALUESET:
append_dot_to_string(interface, value, sizeof(interface));
adm_entry_get_linker_value(ctx, interface, &linker);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcp_client_args *)data)->dhcp_client_dm, "section_name", linker);
dmuci_set_value_by_section_bbfdm(((struct dhcp_client_args *)data)->dhcp_client_dm, "section_name", linker);
break;
}
return 0;
@ -2706,7 +2706,7 @@ static int browseDHCPv4ClientInst(struct dmctx *dmctx, DMNODE *parent_node, void
if (ipv4addr[0] == '\0' && ipv6addr[0] == '\0' && strcmp(proto, "dhcp") != 0 && strcmp(proto, "dhcpv6") != 0 && strcmp(ip_inst, "") == 0 && strcmp(type, "bridge") != 0) {
p->config_section=NULL;
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "section_name", "");
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "section_name", "");
}
}
@ -2750,8 +2750,8 @@ static int browseDHCPv4ClientSentOptionInst(struct dmctx *dmctx, DMNODE *parent_
if (sentopts[i]) buf = strsplit(sentopts[i], ":", &lgh2);
if ((dmmap_sect = get_dup_section_in_dmmap_eq("dmmap_dhcp_client", "send_option", section_name(dhcp_client_args->dhcp_client_conf), "option_tag", buf[0])) == NULL) {
dmuci_add_section_bbfdm("dmmap_dhcp_client", "send_option", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", buf[0]);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", buf[0]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
}
optionvalue = dmstrdup(buf[1]);
if (lgh2 > 2) {
@ -2764,7 +2764,7 @@ static int browseDHCPv4ClientSentOptionInst(struct dmctx *dmctx, DMNODE *parent_
tmp = NULL;
}
}
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_value", optionvalue);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_value", optionvalue);
}
uci_path_foreach_option_eq(bbfdm, "dmmap_dhcp_client", "send_option", "section_name", dhcp_client_args->dhcp_client_conf?section_name(dhcp_client_args->dhcp_client_conf):"", dmmap_sect) {
@ -2805,8 +2805,8 @@ static int browseDHCPv4ClientReqOptionInst(struct dmctx *dmctx, DMNODE *parent_n
for (i = 0; i < length; i++) {
if ((dmmap_sect = get_dup_section_in_dmmap_eq("dmmap_dhcp_client", "req_option", section_name(dhcp_client_args->dhcp_client_conf), "option_tag", reqtopts[i])) == NULL) {
dmuci_add_section_bbfdm("dmmap_dhcp_client", "req_option", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", reqtopts[i]);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", reqtopts[i]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_client_args->dhcp_client_conf));
}
}
@ -2848,8 +2848,8 @@ static int browseDHCPv4ServerPoolOptionInst(struct dmctx *dmctx, DMNODE *parent_
tagvalue = strsplit(e->name, ",", &length);
if ((dmmap_sect = get_dup_section_in_dmmap_eq("dmmap_dhcp", "servpool_option", section_name(curr_dhcp_args->dhcp_sec), "option_tag", tagvalue[0])) == NULL) {
dmuci_add_section_bbfdm("dmmap_dhcp", "servpool_option", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", tagvalue[0]);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(curr_dhcp_args->dhcp_sec));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", tagvalue[0]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(curr_dhcp_args->dhcp_sec));
}
optionvalue = dmstrdup(tagvalue[1]);
if (length > 2) {
@ -2862,7 +2862,7 @@ static int browseDHCPv4ServerPoolOptionInst(struct dmctx *dmctx, DMNODE *parent_
tmp = NULL;
}
}
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_value", optionvalue);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_value", optionvalue);
}
}
uci_path_foreach_option_eq(bbfdm, "dmmap_dhcp", "servpool_option", "section_name", section_name(curr_dhcp_args->dhcp_sec), dmmap_sect) {
@ -2958,7 +2958,7 @@ static int browseDHCPv4RelayForwardingInst(struct dmctx *dmctx, DMNODE *parent_n
dmuci_get_value_by_section_string(p->config_section, "ip_int_instance", &ip_inst);
if (ipv4addr[0] == '\0' && ipv6addr[0] == '\0' && strcmp(ip_inst, "") == 0 && strcmp(type, "bridge") != 0 && strcmp(proto, "relay") != 0) {
p->config_section = NULL;
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "section_name", "");
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "section_name", "");
}
}

22
dmtree/tr181/dhcpv6.c
View file

@ -79,7 +79,7 @@ static int set_section_dhcp6_order(char *package, char *dmpackage, char* sect_ty
dmuci_get_value_by_section_string(dmmap_sect, "order", &v);
if(strlen(v) > 0 && strcmp(v, order) == 0)
return 0;
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "order", order);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "order", order);
if (conf == NULL) {
dmuci_get_value_by_section_string(dmmap_sect, "section_name", &sect_name);
get_config_section_of_dmmap_section(package, sect_type, sect_name, &s);
@ -221,8 +221,8 @@ static int browseDHCPv6ServerPoolOptionInst(struct dmctx *dmctx, DMNODE *parent_
tagvalue= strsplit(e->name, ",", &length);
if ((dmmap_sect = get_dup_section_in_dmmap_eq("dmmap_dhcpv6", "servpool_option", section_name(curr_dhcp_args->dhcp_sec), "option_tag", tagvalue[0])) == NULL) {
dmuci_add_section_bbfdm("dmmap_dhcpv6", "servpool_option", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", tagvalue[0]);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(curr_dhcp_args->dhcp_sec));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", tagvalue[0]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(curr_dhcp_args->dhcp_sec));
}
optionvalue=dmstrdup(length>1?tagvalue[1]:"");
if (length > 2) {
@ -235,7 +235,7 @@ static int browseDHCPv6ServerPoolOptionInst(struct dmctx *dmctx, DMNODE *parent_
tmp= NULL;
}
}
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_value", optionvalue);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_value", optionvalue);
}
}
uci_path_foreach_option_eq(bbfdm, "dmmap_dhcpv6", "servpool_option", "section_name", section_name(curr_dhcp_args->dhcp_sec), dmmap_sect) {
@ -441,8 +441,8 @@ static int addObjDHCPv6ServerPoolOption(char *refparam, struct dmctx *ctx, void
instancepara = get_last_instance_lev2_bbfdm_dmmap_opt("dmmap_dhcpv6", "servpool_option", "bbf_dhcpv6_servpool_option_instance", "section_name", section_name(dhcp_arg->dhcp_sec));
dmuci_add_section_bbfdm("dmmap_dhcpv6", "servpool_option", &dmmap_sect, &value);
if (dhcp_arg->dhcp_sec != NULL)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(dhcp_arg->dhcp_sec));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "option_tag", "0");
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(dhcp_arg->dhcp_sec));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "option_tag", "0");
browse_args.option = "section_name";
browse_args.value = section_name(dhcp_arg->dhcp_sec);
@ -591,7 +591,7 @@ static int set_DHCPv6Client_Interface(char *refparam, struct dmctx *ctx, void *d
case VALUESET:
append_dot_to_string(interface, value, sizeof(interface));
adm_entry_get_linker_value(ctx, interface, &linker);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcpv6_client_args *)data)->dhcp_client_dm, "section_name", linker);
dmuci_set_value_by_section_bbfdm(((struct dhcpv6_client_args *)data)->dhcp_client_dm, "section_name", linker);
break;
}
return 0;
@ -864,7 +864,7 @@ static int set_DHCPv6ServerPool_Alias(char *refparam, struct dmctx *ctx, void *d
return 0;
case VALUESET:
get_dmmap_section_of_config_section("dmmap_dhcpv6", "dhcp", section_name(((struct dhcpv6_args *)data)->dhcp_sec), &dmmap_sect);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "dhcpv6_serv_pool_alias", value);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "dhcpv6_serv_pool_alias", value);
return 0;
}
return 0;
@ -1306,7 +1306,7 @@ static int set_DHCPv6ServerPoolOption_Alias(char *refparam, struct dmctx *ctx, v
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcpv6_client_option_args *)data)->opt_sect, "bbf_dhcpv6_servpool_option_alias", value);
dmuci_set_value_by_section_bbfdm(((struct dhcpv6_client_option_args *)data)->opt_sect, "bbf_dhcpv6_servpool_option_alias", value);
break;
}
return 0;
@ -1347,7 +1347,7 @@ static int set_DHCPv6ServerPoolOption_Tag(char *refparam, struct dmctx *ctx, voi
dmuci_get_value_by_section_list(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", &dhcp_option_list);
dmuci_del_list_value_by_section(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", oldopttagvalue);
dmuci_add_list_value_by_section(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", opttagvalue);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcpv6_client_option_args *)data)->opt_sect, "option_tag", value);
dmuci_set_value_by_section_bbfdm(((struct dhcpv6_client_option_args *)data)->opt_sect, "option_tag", value);
break;
}
return 0;
@ -1387,7 +1387,7 @@ static int set_DHCPv6ServerPoolOption_Value(char *refparam, struct dmctx *ctx, v
dmuci_get_value_by_section_list(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", &dhcp_option_list);
dmuci_del_list_value_by_section(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", oldopttagvalue);
dmuci_add_list_value_by_section(((struct dhcpv6_client_option_args *)data)->client_sect, "dhcp_option", opttagvalue);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ((struct dhcpv6_client_option_args *)data)->opt_sect, "option_value", value);
dmuci_set_value_by_section_bbfdm(((struct dhcpv6_client_option_args *)data)->opt_sect, "option_value", value);
break;
}
return 0;

81
dmtree/tr181/dns.c
View file

@ -9,18 +9,9 @@
*/
#include "dmentry.h"
#include "dns.h"
#include "dmdiagnostics.h"
#include "dmbbfcommon.h"
static inline char *nslookup_get(char *option, char *def)
{
char *tmp;
dmuci_get_varstate_string("cwmp", "@nslookupdiagnostic[0]", option, &tmp);
if (tmp && tmp[0] == '\0')
return dmstrdup(def);
else
return tmp;
}
#include "dns.h"
static unsigned char is_dns_server_in_dmmap(char *chk_ip, char *chk_interface)
{
@ -150,10 +141,10 @@ static int browseResultInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev
struct uci_section *s = NULL;
char *inst, *max_inst = NULL;
uci_foreach_sections_state("cwmp", "NSLookupResult", s) {
uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "NSLookupResult", s) {
inst = handle_update_instance(1, dmctx, &max_inst, update_instance_alias, 5,
s, "nslookup_res_instance", "nslookup_res_alias", "cwmp", "NSLookupResult");
s, "nslookup_res_instance", "nslookup_res_alias", DMMAP_DIAGNOSTIGS, "NSLookupResult");
if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)s, inst) == DM_STOP)
break;
@ -445,43 +436,43 @@ static int get_forwarding_type(char *refparam, struct dmctx *ctx, void *data, ch
static int get_nslookupdiagnostics_diagnostics_state(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
*value = nslookup_get("DiagnosticState", "None");
*value = get_diagnostics_option_fallback_def("nslookup", "DiagnosticState", "None");
return 0;
}
static int get_nslookupdiagnostics_interface(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
dmuci_get_varstate_string("cwmp", "@nslookupdiagnostic[0]", "interface", value);
*value = get_diagnostics_option("nslookup", "interface");
return 0;
}
static int get_nslookupdiagnostics_host_name(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
dmuci_get_varstate_string("cwmp", "@nslookupdiagnostic[0]", "HostName", value);
*value = get_diagnostics_option("nslookup", "HostName");
return 0;
}
static int get_nslookupdiagnostics_d_n_s_server(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
dmuci_get_varstate_string("cwmp", "@nslookupdiagnostic[0]", "DNSServer", value);
*value = get_diagnostics_option("nslookup", "DNSServer");
return 0;
}
static int get_nslookupdiagnostics_timeout(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
*value = nslookup_get("Timeout", "5000");
*value = get_diagnostics_option_fallback_def("nslookup", "Timeout", "5000");
return 0;
}
static int get_nslookupdiagnostics_number_of_repetitions(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
*value = nslookup_get("NumberOfRepetitions", "1");
*value = get_diagnostics_option_fallback_def("nslookup", "NumberOfRepetitions", "1");
return 0;
}
static int get_nslookupdiagnostics_success_count(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
*value = nslookup_get("SuccessCount", "0");
*value = get_diagnostics_option_fallback_def("nslookup", "SuccessCount", "0");
return 0;
}
@ -490,7 +481,7 @@ static int get_nslookupdiagnostics_result_number_of_entries(char *refparam, stru
struct uci_section *s = NULL;
int cnt = 0;
uci_foreach_sections_state("cwmp", "NSLookupResult", s) {
uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "NSLookupResult", s) {
cnt++;
}
dmasprintf(value, "%d", cnt); // MEM WILL BE FREED IN DMMEMCLEAN
@ -805,9 +796,6 @@ static int set_forwarding_interface(char *refparam, struct dmctx *ctx, void *dat
static int set_nslookupdiagnostics_diagnostics_state(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_string(value, -1, -1, DiagnosticsState, 5, NULL, 0))
@ -816,10 +804,7 @@ static int set_nslookupdiagnostics_diagnostics_state(char *refparam, struct dmct
case VALUESET:
if (strcmp(value, "Requested") == 0) {
NSLOOKUP_STOP
curr_section = (struct uci_section *)dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "DiagnosticState", value);
set_diagnostics_option("nslookup", "DiagnosticState", value);
cwmp_set_end_session(END_SESSION_NSLOOKUP_DIAGNOSTIC);
}
return 0;
@ -829,9 +814,6 @@ static int set_nslookupdiagnostics_diagnostics_state(char *refparam, struct dmct
static int set_nslookupdiagnostics_interface(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_string(value, -1, 256, NULL, 0, NULL, 0))
@ -839,10 +821,7 @@ static int set_nslookupdiagnostics_interface(char *refparam, struct dmctx *ctx,
return 0;
case VALUESET:
NSLOOKUP_STOP
curr_section = dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "interface", value);
set_diagnostics_option("nslookup", "interface", value);
return 0;
}
return 0;
@ -850,9 +829,6 @@ static int set_nslookupdiagnostics_interface(char *refparam, struct dmctx *ctx,
static int set_nslookupdiagnostics_host_name(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_string(value, -1, 256, NULL, 0, NULL, 0))
@ -860,10 +836,7 @@ static int set_nslookupdiagnostics_host_name(char *refparam, struct dmctx *ctx,
return 0;
case VALUESET:
NSLOOKUP_STOP
curr_section = dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "HostName", value);
set_diagnostics_option("nslookup", "HostName", value);
return 0;
}
return 0;
@ -871,9 +844,6 @@ static int set_nslookupdiagnostics_host_name(char *refparam, struct dmctx *ctx,
static int set_nslookupdiagnostics_d_n_s_server(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_string(value, -1, 256, NULL, 0, NULL, 0))
@ -881,10 +851,7 @@ static int set_nslookupdiagnostics_d_n_s_server(char *refparam, struct dmctx *ct
return 0;
case VALUESET:
NSLOOKUP_STOP
curr_section = dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "DNSServer", value);
set_diagnostics_option("nslookup", "DNSServer", value);
return 0;
}
return 0;
@ -892,9 +859,6 @@ static int set_nslookupdiagnostics_d_n_s_server(char *refparam, struct dmctx *ct
static int set_nslookupdiagnostics_timeout(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_unsignedInt(value, RANGE_ARGS{{NULL,NULL}}, 1))
@ -902,10 +866,7 @@ static int set_nslookupdiagnostics_timeout(char *refparam, struct dmctx *ctx, vo
return 0;
case VALUESET:
NSLOOKUP_STOP
curr_section = dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "Timeout", value);
set_diagnostics_option("nslookup", "Timeout", value);
return 0;
}
return 0;
@ -913,9 +874,6 @@ static int set_nslookupdiagnostics_timeout(char *refparam, struct dmctx *ctx, vo
static int set_nslookupdiagnostics_number_of_repetitions(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
{
char *tmp;
struct uci_section *curr_section = NULL;
switch (action) {
case VALUECHECK:
if (dm_validate_unsignedInt(value, RANGE_ARGS{{NULL,NULL}}, 1))
@ -923,10 +881,7 @@ static int set_nslookupdiagnostics_number_of_repetitions(char *refparam, struct
return 0;
case VALUESET:
NSLOOKUP_STOP
curr_section = dmuci_walk_state_section("cwmp", "nslookupdiagnostic", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "nslookupdiagnostic", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@nslookupdiagnostic[0]", "NumberOfRepetitions", value);
set_diagnostics_option("nslookup", "NumberOfRepetitions", value);
return 0;
}
return 0;

12
dmtree/tr181/dsl.c
View file

@ -73,9 +73,9 @@ static struct uci_section *update_create_dmmap_dsl_line(char *curr_id)
}
if (!s) {
dmasprintf(&instance, "%d", atoi(curr_id)+1);
DMUCI_ADD_SECTION(bbfdm, "dmmap", "dsl_line", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "id", curr_id);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "dsl_line_instance", instance);
dmuci_add_section_bbfdm("dmmap", "dsl_line", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "id", curr_id);
dmuci_set_value_by_section_bbfdm(s, "dsl_line_instance", instance);
dmfree(instance);
}
return s;
@ -91,9 +91,9 @@ static struct uci_section *update_create_dmmap_dsl_channel(char *curr_id)
}
if (!s) {
dmasprintf(&instance, "%d", atoi(curr_id)+1);
DMUCI_ADD_SECTION(bbfdm, "dmmap", "dsl_channel", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "id", curr_id);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "dsl_channel_instance", instance);
dmuci_add_section_bbfdm("dmmap", "dsl_channel", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "id", curr_id);
dmuci_set_value_by_section_bbfdm(s, "dsl_channel_instance", instance);
dmfree(instance);
}
return s;

6
dmtree/tr181/firewall.c
View file

@ -701,7 +701,7 @@ static int set_level_name(char *refparam, struct dmctx *ctx, void *data, char *i
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, (struct uci_section *)data, "name", value);
dmuci_set_value_by_section_bbfdm((struct uci_section *)data, "name", value);
break;
}
return 0;
@ -715,7 +715,7 @@ static int set_level_description(char *refparam, struct dmctx *ctx, void *data,
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, (struct uci_section *)data, "description", value);
dmuci_set_value_by_section_bbfdm((struct uci_section *)data, "description", value);
break;
}
return 0;
@ -814,7 +814,7 @@ static int set_chain_name(char *refparam, struct dmctx *ctx, void *data, char *i
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, (struct uci_section *)data, "name", value);
dmuci_set_value_by_section_bbfdm((struct uci_section *)data, "name", value);
break;
}
return 0;

2
dmtree/tr181/ieee1905.c
View file

@ -278,7 +278,7 @@ static int addObjIEEE1905ALForwardingTableForwardingRule(char *refparam, struct
check_create_dmmap_package("dmmap_forwarding_rule");
inst = get_last_instance_bbfdm("dmmap_forwarding_rule", "forwarding_rule", "forwardingruleinstance");
dmuci_add_section_and_rename("ieee1905", "forwarding_rule", &s, &value);
dmuci_add_section("ieee1905", "forwarding_rule", &s, &value);
dmuci_add_section_bbfdm("dmmap_forwarding_rule", "forwarding_rule", &dmmap, &v);
dmuci_set_value_by_section(dmmap, "section_name", section_name(s));

26
dmtree/tr181/ip.c
View file

@ -556,7 +556,7 @@ static struct uci_section *create_firewall_zone_config(char *iface)
struct uci_section *s;
char *value, *name;
dmuci_add_section_and_rename("firewall", "zone", &s, &value);
dmuci_add_section("firewall", "zone", &s, &value);
dmasprintf(&name, "fwl_%s", iface);
dmuci_set_value_by_section(s, "name", name);
dmuci_set_value_by_section(s, "input", "DROP");
@ -1544,9 +1544,9 @@ static int add_ipv6(char *refparam, struct dmctx *ctx, void *data, char **instan
dmasprintf(&curr_inst, "%d", atoi(inst)+1);
dmuci_set_value_by_section(((struct ipv6_args *)data)->ip_sec, "ip6addr", "::");
dmuci_set_value_by_section(((struct ipv6_args *)data)->ip_sec, "proto", "static");
DMUCI_ADD_SECTION(bbfdm, "dmmap_network", "ipv6", &ss, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ss, "section_name", section_name(((struct ipv6_args *)data)->ip_sec));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ss, "ipv6_instance", curr_inst);
dmuci_add_section_bbfdm("dmmap_network", "ipv6", &ss, &name);
dmuci_set_value_by_section_bbfdm(ss, "section_name", section_name(((struct ipv6_args *)data)->ip_sec));
dmuci_set_value_by_section_bbfdm(ss, "ipv6_instance", curr_inst);
}
return 0;
}
@ -1586,9 +1586,9 @@ static int add_ipv6_prefix(char *refparam, struct dmctx *ctx, void *data, char *
dmasprintf(&curr_inst, "%d", atoi(inst)+1);
dmuci_set_value_by_section(((struct ip_args *)data)->ip_sec, "ip6prefix", "::");
dmuci_set_value_by_section(((struct ipv6prefix_args *)data)->ip_sec, "proto", "static");
DMUCI_ADD_SECTION(bbfdm, "dmmap_network", "ipv6prefix", &ss, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ss, "section_name", section_name(((struct ipv6prefix_args *)data)->ip_sec));
DMUCI_SET_VALUE_BY_SECTION(bbfdm, ss, "ipv6prefix_instance", curr_inst);
dmuci_add_section_bbfdm("dmmap_network", "ipv6prefix", &ss, &name);
dmuci_set_value_by_section_bbfdm(ss, "section_name", section_name(((struct ipv6prefix_args *)data)->ip_sec));
dmuci_set_value_by_section_bbfdm(ss, "ipv6prefix_instance", curr_inst);
}
return 0;
}
@ -1704,9 +1704,9 @@ static struct uci_section *update_dmmap_network_ipv6(char *curr_inst, char *sect
return s;
}
if (!s) {
DMUCI_ADD_SECTION(bbfdm, "dmmap_network", "ipv6", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "section_name", section_name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "ipv6_instance", curr_inst);
dmuci_add_section_bbfdm("dmmap_network", "ipv6", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "section_name", section_name);
dmuci_set_value_by_section_bbfdm(s, "ipv6_instance", curr_inst);
}
return s;
}
@ -1790,9 +1790,9 @@ static struct uci_section *update_dmmap_network_ipv6prefix(char *curr_inst, char
return s;
}
if (!s) {
DMUCI_ADD_SECTION(bbfdm, "dmmap_network", "ipv6prefix", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "section_name", section_name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "ipv6prefix_instance", curr_inst);
dmuci_add_section_bbfdm("dmmap_network", "ipv6prefix", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "section_name", section_name);
dmuci_set_value_by_section_bbfdm(s, "ipv6prefix_instance", curr_inst);
}
return s;
}

6
dmtree/tr181/managementserver.c
View file

@ -20,7 +20,7 @@ static int get_management_server_url(char *refparam, struct dmctx *ctx, void *da
dmuci_get_option_value_string("cwmp", "acs", "dhcp_discovery", &dhcp);
dmuci_get_option_value_string("cwmp", "acs", "url", &url);
dmuci_get_varstate_string("cwmp", "acs", "dhcp_url", &provisioning_value);
varstate_get_value_string("cwmp", "acs", "dhcp_url", &provisioning_value);
if ( ((dhcp && strcmp(dhcp, "enable") == 0 ) || ((url == NULL) || (url[0] == '\0'))) && ((provisioning_value != NULL) && (provisioning_value[0] != '\0')) )
*value = provisioning_value;
@ -444,7 +444,7 @@ static int set_instance_mode(char *refparam, struct dmctx *ctx, void *data, char
/*#Device.ManagementServer.UDPConnectionRequestAddress!UCI:stun/stun,stun/crudp_address*/
static int get_upd_cr_address(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
{
dmuci_get_varstate_string("stun", "stun", "crudp_address", value);
varstate_get_value_string("stun", "stun", "crudp_address", value);
return 0;
}
@ -606,7 +606,7 @@ static int get_nat_detected(char *refparam, struct dmctx *ctx, void *data, char
dmuci_get_option_value_string("stun", "stun", "enable", &v);
if (*v == '1') { //stun is enabled
dmuci_get_varstate_string("stun", "stun", "nat_detected", &v);
varstate_get_value_string("stun", "stun", "nat_detected", &v);
*value = (*v == '1') ? "true" : "false";
} else
*value = "false";

4
dmtree/tr181/nat.c
View file

@ -25,7 +25,7 @@ static int add_NAT_InterfaceSetting(char *refparam, struct dmctx *ctx, void *dat
check_create_dmmap_package("dmmap_firewall");
inst = get_last_instance_bbfdm("dmmap_firewall", "zone", "interface_setting_instance");
snprintf(name, sizeof(name), "iface_set_%d", inst ? (atoi(inst)+1) : 1);
dmuci_add_section_and_rename("firewall", "zone", &s, &value);
dmuci_add_section("firewall", "zone", &s, &value);
dmuci_set_value_by_section(s, "input", "REJECT");
dmuci_set_value_by_section(s, "output", "ACCEPT");
dmuci_set_value_by_section(s, "forward", "REJECT");
@ -80,7 +80,7 @@ static int add_NAT_PortMapping(char *refparam, struct dmctx *ctx, void *data, ch
check_create_dmmap_package("dmmap_firewall");
inst = get_last_instance_bbfdm("dmmap_firewall", "redirect", "port_mapping_instance");
snprintf(name, sizeof(name), "port_map_%d", inst ? (atoi(inst)+1) : 1);
dmuci_add_section_and_rename("firewall", "redirect", &s, &value);
dmuci_add_section("firewall", "redirect", &s, &value);
dmuci_set_value_by_section(s, "name", name);
dmuci_set_value_by_section(s, "target", "DNAT");
dmuci_set_value_by_section(s, "enabled", "0");

16
dmtree/tr181/qos-iopsyswrt.c
View file

@ -38,18 +38,18 @@ int os_browseQoSClassificationInst(struct dmctx *dmctx, DMNODE *parent_node, voi
//checking if src_ip is an ip-prefix or ip address and synchronizing accordingly
ret = strstr(value, "/");
if (ret)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "src_mask", value);
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "src_mask", value);
else
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "src_ip", value);
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "src_ip", value);
//synchronizing option dest_ip of uci classify section to dest_mask/dest_ip of dmmap's classify section
dmuci_get_value_by_section_string(p->config_section, "dest_ip", &value);
//checking if src_ip is an ip-prefix or ip address and synchronizing accordingly
ret = strstr(value, "/");
if (ret)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "dest_mask", value);
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "dest_mask", value);
else
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dmmap_section, "dest_ip", value);
dmuci_set_value_by_section_bbfdm(p->dmmap_section, "dest_ip", value);
if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)p->config_section, inst) == DM_STOP)
break;
@ -151,7 +151,7 @@ int os_addObjQoSClassification(char *refparam, struct dmctx *ctx, void *data, ch
check_create_dmmap_package("dmmap_qos");
inst = get_last_instance_bbfdm("dmmap_qos", "classify", "classify_instance");
dmuci_add_section_and_rename("qos", "classify", &s, &value);
dmuci_add_section("qos", "classify", &s, &value);
//adding Classification object's parameter entries with default values
dmuci_set_value_by_section(s, "enable", "0");
@ -898,7 +898,7 @@ int os_set_QoSClassification_Alias(char *refparam, struct dmctx *ctx, void *data
break;
case VALUESET:
get_dmmap_section_of_config_section("dmmap_qos", "classify", section_name((struct uci_section *)data), &dmmap_section);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_section, "classifyalias", value);
dmuci_set_value_by_section_bbfdm(dmmap_section, "classifyalias", value);
break;
}
return 0;
@ -3031,7 +3031,7 @@ int os_set_QoSQueue_Alias(char *refparam, struct dmctx *ctx, void *data, char *i
break;
case VALUESET:
get_dmmap_section_of_config_section("dmmap_qos", "queue", section_name((struct uci_section *)data), &dmmap_section);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_section, "queuealias", value);
dmuci_set_value_by_section_bbfdm(dmmap_section, "queuealias", value);
break;
}
return 0;
@ -3464,7 +3464,7 @@ int os_set_QoSShaper_Alias(char *refparam, struct dmctx *ctx, void *data, char *
break;
case VALUESET:
get_dmmap_section_of_config_section("dmmap_qos", "shaper", section_name((struct uci_section *)data), &dmmap_section);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_section, "shaperalias", value);
dmuci_set_value_by_section_bbfdm(dmmap_section, "shaperalias", value);
break;
}
return 0;

34
dmtree/tr181/routing.c
View file

@ -316,14 +316,14 @@ static int dmmap_synchronizeRoutingRouterIPv4Forwarding(struct dmctx *dmctx, DMN
}
last_inst = get_forwarding_last_inst();
dmasprintf(&instance, "%d", last_inst+1);
DMUCI_ADD_SECTION(bbfdm, "dmmap_route_forwarding", "route_dynamic", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "target", proute.destination);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "netmask", proute.mask);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "metric", proute.metric);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "gateway", proute.gateway);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "device", proute.iface);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "interface", iface);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "routeinstance", instance);
dmuci_add_section_bbfdm("dmmap_route_forwarding", "route_dynamic", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "target", proute.destination);
dmuci_set_value_by_section_bbfdm(s, "netmask", proute.mask);
dmuci_set_value_by_section_bbfdm(s, "metric", proute.metric);
dmuci_set_value_by_section_bbfdm(s, "gateway", proute.gateway);
dmuci_set_value_by_section_bbfdm(s, "device", proute.iface);
dmuci_set_value_by_section_bbfdm(s, "interface", iface);
dmuci_set_value_by_section_bbfdm(s, "routeinstance", instance);
dmfree(instance);
}
fclose(fp);
@ -414,14 +414,14 @@ static int dmmap_synchronizeRoutingRouterIPv6Forwarding(struct dmctx *dmctx, DMN
}
last_inst = get_forwarding6_last_inst();
dmasprintf(&instance, "%d", last_inst+1);
DMUCI_ADD_SECTION(bbfdm, "dmmap_route_forwarding", "route6_dynamic", &s, &name);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "target", ipstr);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "gateway", gwstr);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "interface", iface);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "device", dev);
dmuci_add_section_bbfdm("dmmap_route_forwarding", "route6_dynamic", &s, &name);
dmuci_set_value_by_section_bbfdm(s, "target", ipstr);
dmuci_set_value_by_section_bbfdm(s, "gateway", gwstr);
dmuci_set_value_by_section_bbfdm(s, "interface", iface);
dmuci_set_value_by_section_bbfdm(s, "device", dev);
snprintf(buf, sizeof(buf), "%u", metric);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "metric", buf);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "route6instance", instance);
dmuci_set_value_by_section_bbfdm(s, "metric", buf);
dmuci_set_value_by_section_bbfdm(s, "route6instance", instance);
dmfree(instance);
}
fclose(fp);
@ -1102,7 +1102,7 @@ static int add_ipv4forwarding(char *refparam, struct dmctx *ctx, void *data, cha
check_create_dmmap_package("dmmap_route_forwarding");
last_inst = get_forwarding_last_inst();
snprintf(instance, sizeof(instance), "%d", last_inst);
dmuci_add_section_and_rename("network", "route", &s, &value);
dmuci_add_section("network", "route", &s, &value);
dmuci_set_value_by_section(s, "metric", "0");
dmuci_set_value_by_section(s, "interface", "lan");
@ -1142,7 +1142,7 @@ static int add_ipv6Forwarding(char *refparam, struct dmctx *ctx, void *data, cha
check_create_dmmap_package("dmmap_route_forwarding");
last_inst = get_forwarding6_last_inst();
snprintf(instance, sizeof(instance), "%d", last_inst);
dmuci_add_section_and_rename("network", "route6", &s, &value);
dmuci_add_section("network", "route6", &s, &value);
dmuci_set_value_by_section(s, "metric", "0");
dmuci_set_value_by_section(s, "interface", "lan");

4
dmtree/tr181/security.c
View file

@ -231,7 +231,7 @@ static int browseSecurityCertificateInst(struct dmctx *dmctx, DMNODE *parent_nod
}
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_security", "security_certificate", "path", certifcates_paths[i])) == NULL) {
dmuci_add_section_bbfdm("dmmap_security", "security_certificate", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "path", certifcates_paths[i]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "path", certifcates_paths[i]);
}
init_certificate(certifcates_paths[i], cert, dmmap_sect, &certificateprofile);
@ -253,7 +253,7 @@ static int browseSecurityCertificateInst(struct dmctx *dmctx, DMNODE *parent_nod
continue;
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_security", "security_certificate", "path", certifcates_paths[i])) == NULL) {
dmuci_add_section_bbfdm("dmmap_security", "security_certificate", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "path", certifcates_paths[i]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "path", certifcates_paths[i]);
}
init_certificate(certifcates_paths[i], cacert, dmmap_sect, &certificateprofile);

12
dmtree/tr181/upnp.c
View file

@ -134,7 +134,7 @@ static int browseUPnPDiscoveryRootDeviceInst(struct dmctx *dmctx, DMNODE *parent
dmasprintf(&upnp_dev.urn, "%s", urn[1]);
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_root_device", "uuid", uuid[1])) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_root_device", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "uuid", uuid[1]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "uuid", uuid[1]);
}
upnp_dev.dmmap_sect = dmmap_sect;
@ -183,7 +183,7 @@ static int browseUPnPDiscoveryDeviceInst(struct dmctx *dmctx, DMNODE *parent_nod
dmasprintf(&upnp_dev.urn, "%s", lengthurn>0?urn[1]:"");
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_device", "uuid", uuid[1])) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_device", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "uuid", uuid[1]);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "uuid", uuid[1]);
}
upnp_dev.dmmap_sect = dmmap_sect;
@ -232,7 +232,7 @@ static int browseUPnPDiscoveryServiceInst(struct dmctx *dmctx, DMNODE *parent_no
dmasprintf(&upnp_dev.urn, "%s", lengthurn>0?urn[1]:"");
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_service", "usn", usn)) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_service", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "usn", usn);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "usn", usn);
}
upnp_dev.dmmap_sect = dmmap_sect;
@ -270,7 +270,7 @@ static int browseUPnPDescriptionDeviceDescriptionInst(struct dmctx *dmctx, DMNOD
dmasprintf(&upnp_desc.desc_url, "%s", descurl?descurl:"");
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_description", "descurl", descurl)) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_description", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "descurl", descurl);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "descurl", descurl);
}
upnp_desc.dmmap_sect = dmmap_sect;
@ -318,7 +318,7 @@ static int browseUPnPDescriptionDeviceInstanceInst(struct dmctx *dmctx, DMNODE *
dmasprintf(&upnp_dev_inst.upc, "%s", dmjson_get_value(device_inst, 1, "UPC"));
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_device_inst", "udn", dmjson_get_value(device_inst, 1, "UDN"))) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_device_inst", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "udn", dmjson_get_value(device_inst, 1, "UDN"));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "udn", dmjson_get_value(device_inst, 1, "UDN"));
}
upnp_dev_inst.dmmap_sect = dmmap_sect;
@ -360,7 +360,7 @@ static int browseUPnPDescriptionServiceInstanceInst(struct dmctx *dmctx, DMNODE
dmasprintf(&upnp_services_inst.eventsuburl, "%s", dmjson_get_value(service_inst, 1, "eventSubURL"));
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_upnp", "upnp_service_inst", "serviceid", dmjson_get_value(service_inst, 1, "serviceId"))) == NULL) {
dmuci_add_section_bbfdm("dmmap_upnp", "upnp_service_inst", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "serviceid", dmjson_get_value(service_inst, 1, "serviceId"));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "serviceid", dmjson_get_value(service_inst, 1, "serviceId"));
}
upnp_services_inst.dmmap_sect = dmmap_sect;

12
dmtree/tr181/usb.c
View file

@ -156,7 +156,7 @@ static int browseUSBInterfaceInst(struct dmctx *dmctx, DMNODE *parent_node, void
dmasprintf(&iface_path, "%s/%s", netfolderpath, iface_name);
if (p->dm)
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dm, "usb_iface_path", iface_path);
dmuci_set_value_by_section_bbfdm(p->dm, "usb_iface_path", iface_path);
dmasprintf(&statistics_path, "%s/statistics", iface_path);
init_usb_interface(p->dm, iface_name, iface_path, statistics_path, port_link, &iface);
@ -271,7 +271,7 @@ static int synchronize_usb_devices_with_dmmap_opt_recursively(char *sysfsrep, ch
dmasprintf(&sysfs_rep_path, "%s/%s", sysfsrep, ent->d_name);
if ((dmmap_sect = get_dup_section_in_dmmap_opt(dmmap_package, dmmap_section, opt_name, sysfs_rep_path)) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, dmmap_section, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, opt_name, sysfs_rep_path);
dmuci_set_value_by_section_bbfdm(dmmap_sect, opt_name, sysfs_rep_path);
}
dmuci_get_value_by_section_string(dmmap_sect, inst_opt, &instance);
/*
@ -321,7 +321,7 @@ static int browseUSBUSBHostsHostDeviceInst(struct dmctx *dmctx, DMNODE *parent_n
init_usb_port(p->dm, p->sysfs_folder_name, p->sysfs_folder_path, &port);
if (p->dm && prev_port->dmsect ) {
dmuci_get_value_by_section_string(prev_port->dmsect, "usb_host_instance", &parent_host_instance);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, p->dm, "usb_host_device_parent_host_instance", parent_host_instance);
dmuci_set_value_by_section_bbfdm(p->dm, "usb_host_device_parent_host_instance", parent_host_instance);
}
port.dmsect= prev_port->dmsect;
instance = handle_update_instance(2, dmctx, &instnbr, update_instance_alias, 5,
@ -348,7 +348,7 @@ static int browseUSBUSBHostsHostDeviceConfigurationInst(struct dmctx *dmctx, DMN
s = is_dmmap_section_exist("dmmap_usb", "usb_device_conf");
if (!s)
dmuci_add_section_bbfdm("dmmap_usb", "usb_device_conf", &s, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "usb_parent_device", usb_dev->folder_path);
dmuci_set_value_by_section_bbfdm(s, "usb_parent_device", usb_dev->folder_path);
init_usb_port(s, usb_dev->folder_name, usb_dev->folder_path, &port);
@ -380,7 +380,7 @@ static int browseUSBUSBHostsHostDeviceConfigurationInterfaceInst(struct dmctx *d
dmasprintf(&sysfs_rep_path, "%s/%s", usb_dev->folder_path, ent->d_name);
if ((dmmap_sect = get_dup_section_in_dmmap_opt("dmmap_usb", "usb_device_conf_interface", "port_link", sysfs_rep_path)) == NULL) {
dmuci_add_section_bbfdm("dmmap_usb", "usb_device_conf_interface", &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "port_link", sysfs_rep_path);
dmuci_set_value_by_section_bbfdm(dmmap_sect, "port_link", sysfs_rep_path);
}
init_usb_port(dmmap_sect, ent->d_name, sysfs_rep_path, &port);
@ -516,7 +516,7 @@ static int set_USBInterface_Alias(char *refparam, struct dmctx *ctx, void *data,
return FAULT_9007;
break;
case VALUESET:
DMUCI_SET_VALUE_BY_SECTION(bbfdm, usbiface->dm_usb_iface, "usb_iface_alias", value);
dmuci_set_value_by_section_bbfdm(usbiface->dm_usb_iface, "usb_iface_alias", value);
break;
}
return 0;

2
dmtree/tr181/userinterface.c
View file

@ -20,7 +20,7 @@ static void add_default_rule(char *port, char *enable, char *owsd)
struct uci_section *ss;
char *ret;
dmuci_add_section_and_rename("firewall", "rule", &ss, &ret);
dmuci_add_section("firewall", "rule", &ss, &ret);
dmuci_set_value_by_section(ss, "name", "juci-remote-access");
dmuci_set_value_by_section(ss, "src", "wan");
dmuci_set_value_by_section(ss, "proto", "tcp");

2
dmtree/tr181/wifi.c
View file

@ -2243,7 +2243,7 @@ static int browseWiFiEndPointProfileInst(struct dmctx *dmctx, DMNODE *parent_nod
s = is_dmmap_section_exist_eq("dmmap_wireless", "ep_profile", "ep_key", ep_instance);
if(!s)
dmuci_add_section_bbfdm("dmmap_wireless", "ep_profile", &s, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, "ep_key", ep_instance);
dmuci_set_value_by_section_bbfdm(s, "ep_key", ep_instance);
handle_update_instance(2, dmctx, &max_inst, update_instance_alias, 5,
s, "ep_profile_instance", "ep_profile_alias", "dmmap_wireless", "wifi-iface");

33
dynamic_parameters/library/example/example.c
View file

@ -39,25 +39,37 @@ static int execute_bbk_speedtest()
dmubus_call("bbk", "start", UBUS_ARGS{}, 0, &res);
if (res) {
dmuci_set_varstate_value("cwmp", "@bbkspeedtest[0]", "DiagnosticState", "Complete");
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", "DiagnosticState", "Complete");
latency = dmjson_get_value(res, 1, "latency");
if (latency != NULL && strlen(latency) > 0)
dmuci_set_varstate_value("cwmp", "@bbkspeedtest[0]", "Latency", latency);
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", "Latency", latency);
download = dmjson_get_value(res, 1, "download");
if (download != NULL && strlen(latency) > 0)
dmuci_set_varstate_value("cwmp", "@bbkspeedtest[0]", "Download", download);
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", "Download", download);
upload=dmjson_get_value(res, 1, "upload");
if (upload != NULL && strlen(upload) > 0)
dmuci_set_varstate_value("cwmp", "@bbkspeedtest[0]", "Upload", upload);
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", "Upload", upload);
}
return 0;
}
static inline char *bbk_speedtest_get(char *option, char *def)
static char *bbk_speedtest_get(char *option, char *default_value)
{
char *tmp;
dmuci_get_varstate_string("cwmp", "@bbkspeedtest[0]", option, &tmp);
return tmp[0] == '\0' ? dmstrdup(def) : tmp;
char *value;
dmuci_get_option_value_string_bbfdm("dmmap_diagnostics", "bbkspeedtest", option, &value);
return (*value != '\0') ? value : default_value;
}
void bbk_speedtest_set(char *option, char *value)
{
struct uci_section *section = NULL;
check_create_dmmap_package("dmmap_diagnostics");
section = dmuci_walk_section_bbfdm("dmmap_diagnostics", "bbkspeedtest", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!section)
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", "", "bbkspeedtest");
dmuci_set_value_bbfdm("dmmap_diagnostics", "bbkspeedtest", option, value);
}
static int getdynamic_IPDiagnosticsX_IOPSYS_EU_BBKSpeedTest_DiagnosticsState(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
@ -76,10 +88,7 @@ static int setdynamic_IPDiagnosticsX_IOPSYS_EU_BBKSpeedTest_DiagnosticsState(cha
break;
case VALUESET:
if (strcmp(value, "Requested") == 0) {
curr_section = dmuci_walk_state_section("cwmp", "bbkspeedtest", NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION);
if (!curr_section)
dmuci_add_state_section("cwmp", "bbkspeedtest", &curr_section, &tmp);
dmuci_set_varstate_value("cwmp", "@bbkspeedtest[0]", "DiagnosticState", value);
bbk_speedtest_set("DiagnosticState", value);
execute_bbk_speedtest();
}
break;

2
json/generate_source_code.py
View file

@ -405,7 +405,7 @@ def cprintAddDelObj( faddobj, fdelobj, name, mappingobj, dmobject ):
print >> fp, ""
print >> fp, " check_create_dmmap_package(\"%s\");" % dmmapfile
print >> fp, " inst = get_last_instance_bbfdm(\"%s\", \"%s\", \"%s\");" % (dmmapfile, sectiontype, name+"instance")
print >> fp, " dmuci_add_section_and_rename(\"%s\", \"%s\", &s, &value);" % (file, sectiontype)
print >> fp, " dmuci_add_section(\"%s\", \"%s\", &s, &value);" % (file, sectiontype)
print >> fp, " //dmuci_set_value_by_section(s, \"option\", \"value\");"
print >> fp, ""
print >> fp, " dmuci_add_section_bbfdm(\"%s\", \"%s\", &dmmap, &v);" % (dmmapfile, sectiontype)

6
libbbf_api/dmbbf.h
View file

@ -465,7 +465,7 @@ enum dmt_type_enum {
DMT_HEXBIN,
};
enum amd_version_enum{
enum amd_version_enum {
AMD_1 = 1,
AMD_2,
AMD_3,
@ -473,12 +473,12 @@ enum amd_version_enum{
AMD_5,
};
enum dm_type_enum{
enum dm_type_enum {
DM_CWMP,
DM_UPNP,
};
enum bbfdm_type_enum{
enum bbfdm_type_enum {
BBFDM_BOTH,
BBFDM_CWMP,
BBFDM_USP,

38
libbbf_api/dmcommon.c
View file

@ -432,10 +432,16 @@ void update_section_list(char *config, char *section, char *option, int number,
}
}
while (i < number) {
DMUCI_ADD_SECTION(bbfdm, config, section, &s, &add_value);
if (option)DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, option, filter);
if (option1)DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, option1, val1);
if (option2)DMUCI_SET_VALUE_BY_SECTION(bbfdm, s, option2, val2);
dmuci_add_section_bbfdm(config, section, &s, &add_value);
if (option)
dmuci_set_value_by_section_bbfdm(s, option, filter);
if (option1)
dmuci_set_value_by_section_bbfdm(s, option1, val1);
if (option2)
dmuci_set_value_by_section_bbfdm(s, option2, val2);
i++;
}
} else {
@ -449,10 +455,16 @@ void update_section_list(char *config, char *section, char *option, int number,
}
}
while (i < number) {
dmuci_add_section_and_rename(config, section, &s, &add_value);
if (option)dmuci_set_value_by_section(s, option, filter);
if (option1)dmuci_set_value_by_section(s, option1, val1);
if (option2)dmuci_set_value_by_section(s, option2, val2);
dmuci_add_section(config, section, &s, &add_value);
if (option)
dmuci_set_value_by_section(s, option, filter);
if (option1)
dmuci_set_value_by_section(s, option1, val1);
if (option2)
dmuci_set_value_by_section(s, option2, val2);
i++;
}
}
@ -621,7 +633,7 @@ void synchronize_specific_config_sections_with_dmmap(char *package, char *sectio
*/
if ((dmmap_sect = get_dup_section_in_dmmap(dmmap_package, section_type, section_name(s))) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, section_type, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(s));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(s));
}
/*
@ -653,7 +665,7 @@ void synchronize_specific_config_sections_with_dmmap_eq(char *package, char *sec
*/
if ((dmmap_sect = get_dup_section_in_dmmap(dmmap_package, section_type, section_name(s))) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, section_type, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(s));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(s));
}
/*
@ -685,7 +697,7 @@ void synchronize_specific_config_sections_with_dmmap_eq_no_delete(char *package,
*/
if ((dmmap_sect = get_dup_section_in_dmmap(dmmap_package, section_type, section_name(s))) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, section_type, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(s));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(s));
}
}
@ -711,7 +723,7 @@ void synchronize_specific_config_sections_with_dmmap_cont(char *package, char *s
*/
if ((dmmap_sect = get_dup_section_in_dmmap(dmmap_package, section_type, section_name(s))) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, section_type, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, "section_name", section_name(s));
dmuci_set_value_by_section_bbfdm(dmmap_sect, "section_name", section_name(s));
}
/*
@ -763,7 +775,7 @@ int synchronize_system_folders_with_dmmap_opt(char *sysfsrep, char *dmmap_packag
dmasprintf(&sysfs_rep_path, "%s/%s", sysfsrep, ent->d_name);
if ((dmmap_sect = get_dup_section_in_dmmap_opt(dmmap_package, dmmap_section, opt_name, sysfs_rep_path)) == NULL) {
dmuci_add_section_bbfdm(dmmap_package, dmmap_section, &dmmap_sect, &v);
DMUCI_SET_VALUE_BY_SECTION(bbfdm, dmmap_sect, opt_name, sysfs_rep_path);
dmuci_set_value_by_section_bbfdm(dmmap_sect, opt_name, sysfs_rep_path);
}
dmuci_get_value_by_section_string(dmmap_sect, inst_opt, &instance);

2
libbbf_api/dmjson.c
View file

@ -302,6 +302,6 @@ void bbf_api_dmjson_get_string(char *jkey, char **jval)
struct json_object *get_obj = json_object_object_get(dmjson_jobj, jkey);
if (get_obj) {
*jval = json_object_get_string(get_obj);
*jval = (char *)json_object_get_string(get_obj);
}
}

353
libbbf_api/dmuci.c
View file

@ -16,45 +16,42 @@
#include "dmuci.h"
#include "dmmem.h"
struct uci_context *uci_ctx;
struct uci_context *uci_varstate_ctx;
static struct uci_context *uci_ctx;
static struct uci_context *uci_varstate_ctx;
static char *db_config = NULL;
NEW_UCI_PATH(bbfdm, BBFDM_CONFIG, BBFDM_SAVEDIR)
struct uci_section *dmuci_walk_state_section (char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk)
{
struct uci_section *s = NULL;
struct uci_element *e;
struct uci_list *list_section;
struct uci_ptr ptr = {0};
uci_add_delta_path(uci_varstate_ctx, uci_varstate_ctx->savedir);
uci_set_savedir(uci_varstate_ctx, VARSTATE_CONFIG);
if (walk == GET_FIRST_SECTION) {
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, NULL, NULL, NULL) != UCI_OK) {
goto end;
}
list_section = &(ptr.p)->sections;
e = list_to_element(list_section->next);
} else {
list_section = &prev_section->package->sections;
e = list_to_element(prev_section->e.list.next);
}
while (&e->list != list_section) {
s = uci_to_section(e);
if (strcmp(s->type, stype) == 0) {
switch(cmp) {
case CMP_SECTION:
goto end;
default:
break;
}
}
e = list_to_element(e->list.next);
s = NULL;
}
end:
return s;
int dmuci_init(void)
{
uci_ctx = uci_alloc_context();
if (!uci_ctx)
return -1;
uci_varstate_ctx = uci_alloc_context();
if (!uci_varstate_ctx)
return -1;
dmuci_init_bbfdm();
db_config = (folder_exists(LIB_DB_CONFIG)) ? LIB_DB_CONFIG : ETC_DB_CONFIG;
return 0;
}
int dmuci_end(void)
{
if (uci_ctx)
uci_free_context(uci_ctx);
uci_ctx = NULL;
if (uci_varstate_ctx)
uci_free_context(uci_varstate_ctx);
uci_varstate_ctx = NULL;
dmuci_exit_bbfdm();
return 0;
}
char *dmuci_list_to_string(struct uci_list *list, char *delimitor)
@ -62,6 +59,7 @@ char *dmuci_list_to_string(struct uci_list *list, char *delimitor)
struct uci_element *e = NULL;
char val[512] = {0};
int del_len = strlen(delimitor);
if (list) {
uci_foreach_element(list, e) {
int len = strlen(val);
@ -77,6 +75,18 @@ char *dmuci_list_to_string(struct uci_list *list, char *delimitor)
}
}
void uci_add_list_to_list(struct uci_list *addlist, struct uci_list *list)
{
struct uci_element *e, *elt;
uci_foreach_element(addlist, e) {
elt = dmcalloc(1, sizeof(struct uci_element));
elt->list= e->list;
elt->name= e->name;
uci_list_add(list, &elt->list);
}
}
static inline bool check_section_name(const char *str, bool name)
{
if (!*str)
@ -91,7 +101,7 @@ static inline bool check_section_name(const char *str, bool name)
return true;
}
void add_list_package_change(struct list_head *clist, char *package)
static void add_list_package_change(struct list_head *clist, char *package)
{
struct package_change *pc;
list_for_each_entry(pc, clist, list) {
@ -150,9 +160,10 @@ lookup:
}
/**** UCI GET *****/
int dmuci_get_section_type(char *package, char *section,char **value)
int dmuci_get_section_type(char *package, char *section, char **value)
{
struct uci_ptr ptr = {0};
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, NULL, NULL)) {
*value = "";
return -1;
@ -169,6 +180,7 @@ int dmuci_get_section_type(char *package, char *section,char **value)
int dmuci_get_option_value_string(char *package, char *section, char *option, char **value)
{
struct uci_ptr ptr = {0};
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL)) {
*value = "";
return -1;
@ -203,9 +215,10 @@ int dmuci_get_option_value_list(char *package, char *section, char *option, stru
char *pch = NULL, *spch = NULL, *dup;
*value = NULL;
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL)) {
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL))
return -1;
}
if (ptr.o) {
switch(ptr.o->type) {
case UCI_TYPE_LIST:
@ -235,7 +248,7 @@ int dmuci_get_option_value_list(char *package, char *section, char *option, stru
return 0;
}
struct uci_option *dmuci_get_option_ptr(char *cfg_path, char *package, char *section, char *option)
static struct uci_option *dmuci_get_option_ptr(char *cfg_path, char *package, char *section, char *option)
{
struct uci_option *o = NULL;
struct uci_element *e;
@ -244,9 +257,10 @@ struct uci_option *dmuci_get_option_ptr(char *cfg_path, char *package, char *sec
oconfdir = uci_ctx->confdir;
uci_ctx->confdir = cfg_path;
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL)) {
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL))
goto end;
}
e = ptr.last;
switch(e->type) {
case UCI_TYPE_OPTION:
@ -260,87 +274,16 @@ end:
return o;
}
void get_db_config_path(void)
{
db_config = (folder_exists(LIB_DB_CONFIG)) ? LIB_DB_CONFIG : ETC_DB_CONFIG;
}
int db_get_value_string(char *package, char *section, char *option, char **value)
{
struct uci_option *o;
o = dmuci_get_option_ptr((db_config) ? db_config : LIB_DB_CONFIG, package, section, option);
if (o) {
*value = o->v.string ? dmstrdup(o->v.string) : ""; // MEM WILL BE FREED IN DMMEMCLEAN
} else {
*value = "";
return -1;
}
return 0;
}
int db_get_value_list(char *package, char *section, char *option, struct uci_list **value)
{
struct uci_option *o;
*value = NULL;
o = dmuci_get_option_ptr((db_config) ? db_config : LIB_DB_CONFIG, package, section, option);
if (o) {
*value = &o->v.list;
} else {
return -1;
}
return 0;
}
int dmuci_get_varstate_string(char *package, char *section, char *option, char **value)
{
struct uci_ptr ptr = {0};
uci_add_delta_path(uci_varstate_ctx, uci_varstate_ctx->savedir);
uci_set_savedir(uci_varstate_ctx, VARSTATE_CONFIG);
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, section, option, NULL)) {
*value = "";
return -1;
}
if (ptr.o && ptr.o->v.string) {
*value = ptr.o->v.string;
} else {
*value = "";
return -1;
}
return 0;
}
int dmuci_get_varstate_list(char *package, char *section, char *option, struct uci_list **value)
{
struct uci_ptr ptr = {0};
*value = NULL;
uci_add_delta_path(uci_varstate_ctx, uci_varstate_ctx->savedir);
uci_set_savedir(uci_varstate_ctx, VARSTATE_CONFIG);
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, section, option, NULL)) {
return -1;
}
if (ptr.o) {
*value = &ptr.o->v.list;
} else {
return -1;
}
return 0;
}
/**** UCI Commit *****/
int dmuci_commit_package(char *package)
{
struct uci_ptr ptr = {0};
if (uci_lookup_ptr(uci_ctx, &ptr, package, true) != UCI_OK) {
if (uci_lookup_ptr(uci_ctx, &ptr, package, true) != UCI_OK)
return -1;
}
if (uci_commit(uci_ctx, &ptr.p, false) != UCI_OK) {
if (uci_commit(uci_ctx, &ptr.p, false) != UCI_OK)
return -1;
}
return 0;
}
@ -353,37 +296,39 @@ int dmuci_commit(void)
int rc = 0;
if ((uci_list_configs(uci_ctx, &configs) != UCI_OK) || !configs) {
return -1;
rc = -1;
goto end;
}
for (p = configs; *p; p++) {
for (p = configs; *p; p++)
dmuci_commit_package(*p);
}
if(uci_ctx_bbfdm) {
if (uci_ctx_bbfdm) {
if ((uci_list_configs(uci_ctx_bbfdm, &bbfdm_configs) != UCI_OK) || !bbfdm_configs) {
rc = -1;
goto out;
}
for (p = bbfdm_configs; *p; p++) {
DMUCI_COMMIT_PACKAGE(bbfdm, *p);
}
for (p = bbfdm_configs; *p; p++)
dmuci_commit_package_bbfdm(*p);
free(bbfdm_configs);
}
out:
free(configs);
free(bbfdm_configs);
end:
return rc;
}
/**** UCI REVERT *****/
int dmuci_revert_package(char *package)
static int dmuci_revert_package(char *package)
{
struct uci_ptr ptr = {0};
if (uci_lookup_ptr(uci_ctx, &ptr, package, true) != UCI_OK) {
if (uci_lookup_ptr(uci_ctx, &ptr, package, true) != UCI_OK)
return -1;
}
if (uci_revert(uci_ctx, &ptr) != UCI_OK) {
if (uci_revert(uci_ctx, &ptr) != UCI_OK)
return -1;
}
return 0;
}
@ -393,12 +338,12 @@ int dmuci_revert(void)
char **configs = NULL;
char **p;
if ((uci_list_configs(uci_ctx, &configs) != UCI_OK) || !configs) {
if ((uci_list_configs(uci_ctx, &configs) != UCI_OK) || !configs)
return -1;
}
for (p = configs; *p; p++) {
for (p = configs; *p; p++)
dmuci_revert_package(*p);
}
free(configs);
return 0;
}
@ -408,18 +353,22 @@ int dmuci_change_packages(struct list_head *clist)
{
char **configs = NULL;
char **p;
if ((uci_list_configs(uci_ctx, &configs) != UCI_OK) || !configs) {
if ((uci_list_configs(uci_ctx, &configs) != UCI_OK) || !configs)
return -1;
}
for (p = configs; *p; p++) {
struct uci_ptr ptr = {0};
if (uci_lookup_ptr(uci_ctx, &ptr, *p, true) != UCI_OK) {
if (uci_lookup_ptr(uci_ctx, &ptr, *p, true) != UCI_OK)
continue;
}
if (uci_list_empty(&ptr.p->delta))
continue;
add_list_package_change(clist, *p);
}
free(configs);
return 0;
}
@ -429,36 +378,15 @@ char *dmuci_set_value(char *package, char *section, char *option, char *value)
{
struct uci_ptr ptr = {0};
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, value)) {
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, value))
return "";
}
if (uci_set(uci_ctx, &ptr) != UCI_OK) {
if (uci_set(uci_ctx, &ptr) != UCI_OK)
return "";
}
if (ptr.o) {
if (ptr.o)
return dmstrdup(ptr.o->v.string); // MEM WILL BE FREED IN DMMEMCLEAN
}
return "";
}
char *dmuci_set_varstate_value(char *package, char *section, char *option, char *value)
{
struct uci_ptr ptr = {0};
uci_add_delta_path(uci_varstate_ctx, uci_varstate_ctx->savedir);
uci_set_savedir(uci_varstate_ctx, VARSTATE_CONFIG);
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, section, option, value)) {
return "";
}
if (uci_set(uci_varstate_ctx, &ptr) != UCI_OK) {
return "";
}
uci_save(uci_varstate_ctx, ptr.p);
if (ptr.o) {
return dmstrdup(ptr.o->v.string); // MEM WILL BE FREED IN DMMEMCLEAN
}
return "";
}
@ -491,7 +419,7 @@ int dmuci_del_list_value(char *package, char *section, char *option, char *value
}
/****** UCI ADD *******/
char * dmuci_add_section(char *package, char *stype, struct uci_section **s, char **value)
char *dmuci_add_section(char *package, char *stype, struct uci_section **s, char **value)
{
struct uci_ptr ptr = {0};
char *val = "";
@ -506,32 +434,6 @@ char * dmuci_add_section(char *package, char *stype, struct uci_section **s, cha
return val;
}
char * dmuci_add_section_and_rename(char *package, char *stype, struct uci_section **s, char **value)
{
char *name = dmuci_add_section(package, stype, s, value);
dmuci_rename_section_by_section(*s, name);
return name;
}
int dmuci_add_state_section(char *package, char *stype, struct uci_section **s, char **value)
{
struct uci_ptr ptr = {0};
*s = NULL;
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, NULL, NULL, NULL)) {
*value = "";
return -1;
}
if (uci_add_section(uci_varstate_ctx, ptr.p, stype, s) != UCI_OK) {
*value = "";
return -1;
}
*value = dmstrdup((*s)->e.name); // MEM WILL BE FREED IN DMMEMCLEAN
uci_save(uci_varstate_ctx, ptr.p);
return 0;
}
/**** UCI DELETE *****/
int dmuci_delete(char *package, char *section, char *option, char *value)
{
@ -539,6 +441,7 @@ int dmuci_delete(char *package, char *section, char *option, char *value)
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, option, NULL))
return -1;
if (uci_delete(uci_ctx, &ptr) != UCI_OK)
return -1;
@ -552,6 +455,7 @@ int dmuci_rename_section(char *package, char *section, char *value)
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, section, NULL, value))
return -1;
if (uci_rename(uci_ctx, &ptr) != UCI_OK)
return -1;
@ -559,7 +463,7 @@ int dmuci_rename_section(char *package, char *section, char *value)
}
/**** UCI LOOKUP by section pointer ****/
int dmuci_lookup_ptr_by_section(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_section *s, char *option, char *value)
static int dmuci_lookup_ptr_by_section(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_section *s, char *option, char *value)
{
if (s == NULL || s->package == NULL)
return -1;
@ -584,9 +488,9 @@ int dmuci_lookup_ptr_by_section(struct uci_context *ctx, struct uci_ptr *ptr, st
ptr->option = option;
lookup:
if (uci_lookup_ptr(ctx, ptr, NULL, true) != UCI_OK || !UCI_LOOKUP_COMPLETE) {
if (uci_lookup_ptr(ctx, ptr, NULL, true) != UCI_OK || !UCI_LOOKUP_COMPLETE)
return -1;
}
return 0;
}
@ -680,9 +584,9 @@ char *dmuci_set_value_by_section(struct uci_section *s, char *option, char *valu
if (uci_set(uci_ctx, &up) != UCI_OK)
return "";
if (up.o) {
if (up.o)
return dmstrdup(up.o->v.string); // MEM WILL BE FREED IN DMMEMCLEAN
}
return "";
}
@ -766,9 +670,9 @@ struct uci_section *dmuci_walk_section (char *package, char *stype, void *arg1,
struct uci_ptr ptr = {0};
if (walk == GET_FIRST_SECTION) {
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, NULL, NULL, NULL) != UCI_OK) {
if (dmuci_lookup_ptr(uci_ctx, &ptr, package, NULL, NULL, NULL) != UCI_OK)
goto end;
}
list_section = &(ptr.p)->sections;
e = list_to_element(list_section->next);
} else {
@ -829,27 +733,55 @@ end:
return s;
}
void uci_add_list_to_list(struct uci_list *addlist, struct uci_list *list)
/**** UCI GET db config *****/
int db_get_value_string(char *package, char *section, char *option, char **value)
{
struct uci_element *e, *elt;
struct uci_option *o;
uci_foreach_element(addlist, e) {
elt = dmcalloc(1, sizeof(struct uci_element));
elt->list= e->list;
elt->name= e->name;
uci_list_add(list, &elt->list);
o = dmuci_get_option_ptr((db_config) ? db_config : LIB_DB_CONFIG, package, section, option);
if (o) {
*value = o->v.string ? dmstrdup(o->v.string) : ""; // MEM WILL BE FREED IN DMMEMCLEAN
} else {
*value = "";
return -1;
}
return 0;
}
void init_uci_varstate_ctx(void)
/**** UCI GET /var/state *****/
int varstate_get_value_string(char *package, char *section, char *option, char **value)
{
uci_varstate_ctx = uci_alloc_context();
struct uci_ptr ptr = {0};
uci_add_delta_path(uci_varstate_ctx, uci_varstate_ctx->savedir);
uci_set_savedir(uci_varstate_ctx, VARSTATE_CONFIG);
if (dmuci_lookup_ptr(uci_varstate_ctx, &ptr, package, section, option, NULL)) {
*value = "";
return -1;
}
if (ptr.o && ptr.o->v.string) {
*value = ptr.o->v.string;
} else {
*value = "";
return -1;
}
return 0;
}
void end_uci_varstate_ctx(void)
void alloc_uci_ctx_bbfdm(void)
{
if (uci_varstate_ctx) uci_free_context(uci_varstate_ctx);
uci_varstate_ctx = NULL;
if (!uci_ctx_bbfdm)
uci_ctx_bbfdm = uci_alloc_context();
}
void commit_and_free_uci_ctx_bbfdm(char *dmmap_config)
{
dmuci_commit_package_bbfdm(dmmap_config);
if (uci_ctx_bbfdm)
uci_free_context(uci_ctx_bbfdm);
uci_ctx_bbfdm = NULL;
}
char *bbf_uci_get_value(char *path, char *package, char *section, char *option)
@ -898,7 +830,8 @@ char *bbf_uci_set_value(char *path, char *package, char *section, char *option,
val = dmstrdup(ptr.o->v.string);
end:
if (path && strcmp(path, BBFDM_CONFIG) == 0) uci_ctx = save_uci_ctx;;
if (path && strcmp(path, BBFDM_CONFIG) == 0)
uci_ctx = save_uci_ctx;
return val;
}

125
libbbf_api/dmuci.h
View file

@ -31,9 +31,6 @@
#define BBFDM_SAVEDIR "/tmp/.bbfdm"
#define UCI_CONFIG_DIR "/etc/config/"
extern struct uci_context *uci_ctx;
extern struct uci_context *uci_varstate_ctx;
enum dm_uci_cmp {
CMP_SECTION,
CMP_OPTION_EQUAL,
@ -124,11 +121,6 @@ struct package_change
section != NULL; \
section = dmuci_walk_section(package, stype, arg, NULL, CMP_FILTER_FUNC, func, section, GET_NEXT_SECTION))
#define uci_foreach_sections_state(package, stype, section) \
for (section = dmuci_walk_state_section(package, stype, NULL, NULL, CMP_SECTION, NULL, NULL, GET_FIRST_SECTION); \
section != NULL; \
section = dmuci_walk_state_section(package, stype, NULL, NULL, CMP_SECTION, NULL, section, GET_NEXT_SECTION))
#define section_name(s) (s)->e.name
static inline void uci_list_insert(struct uci_list *list, struct uci_list *ptr)
@ -149,59 +141,6 @@ static inline void uci_list_init(struct uci_list *ptr)
ptr->prev = ptr;
ptr->next = ptr;
}
char *dmuci_list_to_string(struct uci_list *list, char *delimitor);
void add_list_package_change(struct list_head *clist, char *package);
void free_all_list_package_change(struct list_head *clist);
int dmuci_lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *package, char *section, char *option, char *value);
int dmuci_get_section_type(char *package, char *section,char **value);
int dmuci_get_option_value_string(char *package, char *section, char *option, char **value);
char *dmuci_get_option_value_fallback_def(char *package, char *section, char *option, char *default_value);
int dmuci_get_option_value_list(char *package, char *section, char *option, struct uci_list **value);
struct uci_option *dmuci_get_option_ptr(char *cfg_path, char *package, char *section, char *option);
void get_db_config_path(void);
int db_get_value_string(char *package, char *section, char *option, char **value);
int db_get_value_list(char *package, char *section, char *option, struct uci_list **value);
int dmuci_get_varstate_string(char *package, char *section, char *option, char **value);
int dmuci_get_varstate_list(char *package, char *section, char *option, struct uci_list **value);
int dmuci_commit_package(char *package);
int dmuci_commit(void);
int dmuci_revert_package(char *package);
int dmuci_revert(void);
int dmuci_change_packages(struct list_head *clist);
char *dmuci_set_value(char *package, char *section, char *option, char *value);
int dmuci_add_list_value(char *package, char *section, char *option, char *value);
int dmuci_del_list_value(char *package, char *section, char *option, char *value);
char * dmuci_add_section(char *package, char *stype, struct uci_section **s, char **value);
char * dmuci_add_section_and_rename(char *package, char *stype, struct uci_section **s, char **value);
int dmuci_delete(char *package, char *section, char *option, char *value);
int dmuci_lookup_ptr_by_section(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_section *s, char *option, char *value);
int dmuci_get_value_by_section_string(struct uci_section *s, char *option, char **value);
char *dmuci_get_value_by_section_fallback_def(struct uci_section *s, char *option, char *default_value);
int dmuci_get_value_by_section_list(struct uci_section *s, char *option, struct uci_list **value);
char *dmuci_set_value_by_section(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section_unnamed(struct uci_section *s, char *option, char *value);
int dmuci_add_list_value_by_section(struct uci_section *s, char *option, char *value);
int dmuci_del_list_value_by_section(struct uci_section *s, char *option, char *value);
struct uci_section *dmuci_walk_section(char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk);
struct uci_section *dmuci_walk_state_section(char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk);
struct uci_section *dmuci_walk_section_bbfdm(char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk);
char *dmuci_set_value_by_section_bbfdm(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section_unnamed_bbfdm(struct uci_section *s, char *option, char *value);
char * dmuci_add_section_bbfdm(char *package, char *stype, struct uci_section **s, char **value);
int dmuci_delete_bbfdm(char *package, char *section, char *option, char *value);
int dmuci_add_state_section(char *package, char *stype, struct uci_section **s, char **value);
char *dmuci_set_varstate_value(char *package, char *section, char *option, char *value);
char *dmuci_set_value_bbfdm(char *package, char *section, char *option, char *value);
int dmuci_delete_by_section_bbfdm(struct uci_section *s, char *option, char *value);
int dmuci_rename_section_by_section(struct uci_section *s, char *value);
int dmuci_exit_bbfdm(void);
int dmuci_init_bbfdm(void);
void init_uci_varstate_ctx(void);
void end_uci_varstate_ctx(void);
void uci_add_list_to_list(struct uci_list *addlist, struct uci_list *list);
char *bbf_uci_get_value(char *path, char *package, char *section, char *option);
char *bbf_uci_set_value(char *path, char *package, char *section, char *option, char *value);
#define NEW_UCI_PATH(UCI_PATH, CPATH, DPATH) \
struct uci_context *uci_ctx_##UCI_PATH; \
@ -342,19 +281,55 @@ int dmuci_commit_package_##UCI_PATH(char *package) \
return res; \
}\
#define DMUCI_GET_SECTION_TYPE(UCI_PATH, package, section, value) dmuci_get_section_type_##UCI_PATH(package, section, value)
#define DMUCI_GET_OPTION_VALUE_STRING(UCI_PATH, package, section, option, value) dmuci_get_option_value_string_##UCI_PATH(package, section, option, value)
#define DMUCI_GET_OPTION_VALUE_LIST(UCI_PATH, package, section, option, value) dmuci_get_option_value_list_##UCI_PATH(package, section, option, value)
#define DMUCI_SET_VALUE(UCI_PATH, package, section, option, value) dmuci_set_value_##UCI_PATH(package, section, option, value)
#define DMUCI_ADD_LIST_VALUE(UCI_PATH, package, section, option, value) dmuci_add_list_value_##UCI_PATH(package, section, option, value)
#define DMUCI_DEL_LIST_VALUE(UCI_PATH, package, section, option, value) dmuci_del_list_value_##UCI_PATH(package, section, option, value)
#define DMUCI_ADD_SECTION(UCI_PATH, package, stype, s, value) dmuci_add_section_##UCI_PATH(package, stype, s, value)
#define DMUCI_DEL_SECTION(UCI_PATH, package, section, option, value) dmuci_delete_##UCI_PATH(package, section, option, value)
#define DMUCI_SET_VALUE_BY_SECTION(UCI_PATH, s, option, value) dmuci_set_value_by_section_##UCI_PATH(s, option, value)
#define DMUCI_DELETE_BY_SECTION(UCI_PATH, s, option, value) dmuci_delete_by_section_##UCI_PATH(s, option, value)
#define DMUCI_WALK_SECTION(UCI_PATH, package, stype, arg1, arg2, cmp , filter, value), struct uci_section *prev_section, int walk)\) dmuci_walk_section_##UCI_PATH(package, stype, arg1, arg2, cmp , filter, value)
#define DMUCI_COMMIT_PACKAGE(UCI_PATH, package) dmuci_commit_package_##UCI_PATH(package)
#define DMUCI_INIT(UCI_PATH) dmuci_init_##UCI_PATH()
#define DMUCI_EXIT(UCI_PATH) dmuci_exit_##UCI_PATH()
int dmuci_init(void);
int dmuci_end(void);
char *dmuci_list_to_string(struct uci_list *list, char *delimitor);
void uci_add_list_to_list(struct uci_list *addlist, struct uci_list *list);
void free_all_list_package_change(struct list_head *clist);
int dmuci_lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *package, char *section, char *option, char *value);
int dmuci_commit(void);
int dmuci_revert(void);
int dmuci_change_packages(struct list_head *clist);
int dmuci_get_section_type(char *package, char *section, char **value);
int dmuci_get_option_value_string(char *package, char *section, char *option, char **value);
char *dmuci_get_option_value_fallback_def(char *package, char *section, char *option, char *default_value);
int dmuci_get_option_value_list(char *package, char *section, char *option, struct uci_list **value);
char *dmuci_set_value(char *package, char *section, char *option, char *value);
int dmuci_add_list_value(char *package, char *section, char *option, char *value);
int dmuci_del_list_value(char *package, char *section, char *option, char *value);
char *dmuci_add_section(char *package, char *stype, struct uci_section **s, char **value);
int dmuci_delete(char *package, char *section, char *option, char *value);
int dmuci_get_value_by_section_string(struct uci_section *s, char *option, char **value);
char *dmuci_get_value_by_section_fallback_def(struct uci_section *s, char *option, char *default_value);
int dmuci_get_value_by_section_list(struct uci_section *s, char *option, struct uci_list **value);
char *dmuci_set_value_by_section(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section_unnamed(struct uci_section *s, char *option, char *value);
int dmuci_add_list_value_by_section(struct uci_section *s, char *option, char *value);
int dmuci_del_list_value_by_section(struct uci_section *s, char *option, char *value);
int dmuci_rename_section_by_section(struct uci_section *s, char *value);
struct uci_section *dmuci_walk_section(char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk);
int dmuci_commit_package(char *package);
int dmuci_get_option_value_string_bbfdm(char *package, char *section, char *option, char **value);
char *dmuci_set_value_bbfdm(char *package, char *section, char *option, char *value);
char *dmuci_set_value_by_section_bbfdm(struct uci_section *s, char *option, char *value);
char * dmuci_add_section_bbfdm(char *package, char *stype, struct uci_section **s, char **value);
int dmuci_delete_bbfdm(char *package, char *section, char *option, char *value);
int dmuci_delete_by_section_unnamed_bbfdm(struct uci_section *s, char *option, char *value);
int dmuci_delete_by_section_bbfdm(struct uci_section *s, char *option, char *value);
int dmuci_commit_package_bbfdm(char *package);
struct uci_section *dmuci_walk_section_bbfdm(char *package, char *stype, void *arg1, void *arg2, int cmp , int (*filter)(struct uci_section *s, void *value), struct uci_section *prev_section, int walk);
void alloc_uci_ctx_bbfdm(void);
void commit_and_free_uci_ctx_bbfdm(char *dmmap_config);
int db_get_value_string(char *package, char *section, char *option, char **value);
int varstate_get_value_string(char *package, char *section, char *option, char **value);
char *bbf_uci_get_value(char *path, char *package, char *section, char *option);
char *bbf_uci_set_value(char *path, char *package, char *section, char *option, char *value);
#endif

50
scripts/functions/download_launch
View file

@ -3,19 +3,17 @@
# Author: IMEN Bhiri <imen.bhiri@pivasoftware.com>
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_ADD_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state add"
UCI_DELETE_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state delete"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
UCI_ADD_BBFDM="/sbin/uci -q -c /etc/bbfdm add"
UCI_DELETE_BBFDM="/sbin/uci -c /etc/bbfdm delete"
CAPTURE_FILE="/tmp/download_dump"
DOWNLOAD_DIAGNOSTIC_FILE="/tmp/bbfdm_download_diagnostic"
DOWNLOAD_DIAGNOSTIC_LOG_FILE="/tmp/bbfdm_download_diagnostic_log"
CONNECTION_TIMEOUT=10
download_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
@ -23,9 +21,9 @@ download_launch() {
local tx_bytes_before rx_bytes_before time1 tx_bytes_after rx_bytes_after time2 res rh ba stc periodtime
local url=$2
local interface=$3
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState`" != "Requested" ] && return
[ "$url" = "" ] && { $UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Error_InitConnectionFailed; return; }
local proto=`download_get cwmp.@downloaddiagnostic[0].ProtocolVersion Any`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.download.DiagnosticState`" != "Requested" ] && return
[ "$url" = "" ] && { $UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Error_InitConnectionFailed; return; }
local proto=`download_get dmmap_diagnostics.download.ProtocolVersion Any`
# Disable acceleration on Broadcom devices to capture all packets with tcpdump
[ -e /usr/sbin/fcctl ] && { fcctl disable >/dev/null 2>&1; fcctl flush >/dev/null 2>&1; }
tcpdump -i $interface tcp -w ${CAPTURE_FILE} > /dev/null 2>&1 &
@ -42,28 +40,28 @@ download_launch() {
tx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.tx_bytes`
rx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.rx_bytes`
rh=`cat ${DOWNLOAD_DIAGNOSTIC_LOG_FILE} | grep "resolve host"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Error_CannotResolveHostName; kill $PID 2> /dev/null; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Error_CannotResolveHostName; kill $PID 2> /dev/null; return; }
ba=`echo "$res" | grep "bad address"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Error_InitConnectionFailed; kill $PID 2> /dev/null; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Error_InitConnectionFailed; kill $PID 2> /dev/null; return; }
stc=`cat ${DOWNLOAD_DIAGNOSTIC_LOG_FILE} | grep "404 Not Found"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Error_NoResponse; kill $PID 2> /dev/null; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Error_NoResponse; kill $PID 2> /dev/null; return; }
stc=`cat ${DOWNLOAD_DIAGNOSTIC_LOG_FILE} | grep "100%"`
[ -z "$stc" ] && { $UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Error_TransferFailed; kill $PID 2> /dev/null; return; }
[ -z "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Error_TransferFailed; kill $PID 2> /dev/null; return; }
fi
tx_bytes=$((tx_bytes_after-tx_bytes_before))
rx_bytes=$((rx_bytes_after-rx_bytes_before))
periodtime=$(($((time2-time1))*1000000))
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].TotalBytesReceived=$rx_bytes
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].TotalBytesSent=$tx_bytes
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].PeriodOfFullLoading=$periodtime
local perconnection=`$UCI_GET_VARSTATE cwmp.@downloaddiagnostic[0].EnablePerConnection`
$UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.download.TotalBytesReceived=$rx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.download.TotalBytesSent=$tx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.download.PeriodOfFullLoading=$periodtime
local perconnection=`$UCI_GET_BBFDM dmmap_diagnostics.download.EnablePerConnection`
if ([ "$perconnection" == "true" ] || [ "$perconnection" == "1" ]); then
$UCI_ADD_VARSTATE cwmp DownloadPerConnection
$UCI_SET_VARSTATE cwmp.@DownloadPerConnection[0].TotalBytesReceived=$rx_bytes
$UCI_SET_VARSTATE cwmp.@DownloadPerConnection[0].TotalBytesSent=$tx_bytes
$UCI_ADD_BBFDM dmmap_diagnostics DownloadPerConnection
$UCI_SET_BBFDM dmmap_diagnostics.@DownloadPerConnection[0].TotalBytesReceived=$rx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.@DownloadPerConnection[0].TotalBytesSent=$tx_bytes
else
$UCI_DELETE_VARSTATE cwmp.@DownloadPerConnection[0]
$UCI_DELETE_BBFDM dmmap_diagnostics.@DownloadPerConnection[0]
fi
rm ${DOWNLOAD_DIAGNOSTIC_FILE} 2>/dev/null
rm ${DOWNLOAD_DIAGNOSTIC_LOG_FILE} 2>/dev/null
@ -75,11 +73,11 @@ download_launch() {
}
download_stop_diagnostic() {
$UCI_DELETE_VARSTATE cwmp.@DownloadPerConnection[0]
$UCI_DELETE_BBFDM dmmap_diagnostics.@DownloadPerConnection[0]
local pids=`ps | grep download_launch.*run | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=None
fi
local pids=`ps | grep download_launch.*run | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
@ -88,7 +86,7 @@ download_stop_diagnostic() {
kill -9 $kid &>/dev/null
done
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@downloaddiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.download.DiagnosticState=None
fi
}

64
scripts/functions/ipping_launch
View file

@ -3,37 +3,35 @@
# Author: MOHAMED Kallel <mohamed.kallel@pivasoftware.com>
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
ipping_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
ipping_error()
{
local cnt=`ipping_get cwmp.@ippingdiagnostic[0].NumberOfRepetitions 3`
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].SuccessCount=0
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].FailureCount=$cnt
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].AverageResponseTime=0
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MinimumResponseTime=9999
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MaximumResponseTime=0
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].AverageResponseTimeDetailed=0
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MinimumResponseTimeDetailed=999999999
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MaximumResponseTimeDetailed=0
local cnt=`ipping_get dmmap_diagnostics.ipping.NumberOfRepetitions 3`
$UCI_SET_BBFDM dmmap_diagnostics.ipping.SuccessCount=0
$UCI_SET_BBFDM dmmap_diagnostics.ipping.FailureCount=$cnt
$UCI_SET_BBFDM dmmap_diagnostics.ipping.AverageResponseTime=0
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MinimumResponseTime=9999
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MaximumResponseTime=0
$UCI_SET_BBFDM dmmap_diagnostics.ipping.AverageResponseTimeDetailed=0
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MinimumResponseTimeDetailed=999999999
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MaximumResponseTimeDetailed=0
}
ipping_launch() {
local i res ba stc times sc1 success_count failure_count min_time avg_time max_time avg_time_sum min max micros avg_time_det min_time_det max_time_det avg_time_sum_det min_det max_det
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState`" != "Requested" ] && return
local host=`ipping_get cwmp.@ippingdiagnostic[0].Host`
local cnt=`ipping_get cwmp.@ippingdiagnostic[0].NumberOfRepetitions 3`
local dsize=`ipping_get cwmp.@ippingdiagnostic[0].DataBlockSize 64`
local timeout=`ipping_get cwmp.@ippingdiagnostic[0].Timeout 1000`
local proto=`ipping_get cwmp.@ippingdiagnostic[0].ProtocolVersion Any`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.ipping.DiagnosticState`" != "Requested" ] && return
local host=`ipping_get dmmap_diagnostics.ipping.Host`
local cnt=`ipping_get dmmap_diagnostics.ipping.NumberOfRepetitions 3`
local dsize=`ipping_get dmmap_diagnostics.ipping.DataBlockSize 64`
local timeout=`ipping_get dmmap_diagnostics.ipping.Timeout 1000`
local proto=`ipping_get dmmap_diagnostics.ipping.ProtocolVersion Any`
[ "$host" = "" ] && return
timeout=$((timeout/1000))
[ "$timeout" = "0" ] && timeout="1"
@ -53,11 +51,11 @@ ipping_launch() {
[ "$proto" = "IPv4" ] && res=$(ping -q -4 -c 1 -s $dsize -W $timeout $host 2>&1)
[ "$proto" = "IPv6" ] && res=$(ping -q -6 -c 1 -s $dsize -W $timeout $host 2>&1)
ba=`echo "$res" | grep "bad address"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_CannotResolveHostName; ipping_error; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.ipping.DiagnosticState=Error_CannotResolveHostName; ipping_error; return; }
ba=`echo "$res" | grep "unknown host"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_CannotResolveHostName; ipping_error; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.ipping.DiagnosticState=Error_CannotResolveHostName; ipping_error; return; }
stc=`echo "$res" | grep "received"`
[ -z "$stc" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_Other; ipping_error; return; }
[ -z "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.ipping.DiagnosticState=Error_Other; ipping_error; return; }
times=`echo "$res" | grep "min/avg/max"`
[ -z "$times" ] && continue
sc1=`echo $stc | awk '{print $4}'`
@ -91,15 +89,15 @@ ipping_launch() {
max_time=$(awk "BEGIN{print int($max / 1000)}")
min_time_det=$min_det
max_time_det=$max_det
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].SuccessCount=$success_count
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].FailureCount=$failure_count
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].AverageResponseTime=$avg_time
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MinimumResponseTime=$min_time
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MaximumResponseTime=$max_time
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].AverageResponseTimeDetailed=$avg_time_det
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MinimumResponseTimeDetailed=$min_time_det
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].MaximumResponseTimeDetailed=$max_time_det
$UCI_SET_BBFDM dmmap_diagnostics.ipping.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.ipping.SuccessCount=$success_count
$UCI_SET_BBFDM dmmap_diagnostics.ipping.FailureCount=$failure_count
$UCI_SET_BBFDM dmmap_diagnostics.ipping.AverageResponseTime=$avg_time
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MinimumResponseTime=$min_time
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MaximumResponseTime=$max_time
$UCI_SET_BBFDM dmmap_diagnostics.ipping.AverageResponseTimeDetailed=$avg_time_det
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MinimumResponseTimeDetailed=$min_time_det
$UCI_SET_BBFDM dmmap_diagnostics.ipping.MaximumResponseTimeDetailed=$max_time_det
[ "$1" == "cwmp" ] && event_dignostic
}
@ -118,7 +116,7 @@ ipping_stop_diagnostic() {
local pids=`ps | grep ipping_launch | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.ipping.DiagnosticState=None
fi
}

46
scripts/functions/nslookup_launch
View file

@ -2,27 +2,25 @@
# Copyright (C) 2019 iopsys Software Solutions AB
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_ADD_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state add"
UCI_DELETE_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state delete"
UCI_SHOW_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state show"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
UCI_ADD_BBFDM="/sbin/uci -q -c /etc/bbfdm add"
UCI_DELETE_BBFDM="/sbin/uci -q -c /etc/bbfdm delete"
UCI_SHOW_BBFDM="/sbin/uci -q -c /etc/bbfdm show"
LOG_FILE="/tmp/nslookup.log"
nslookup_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
nslookup_launch() {
local i j time1 time2 timeresponse status AnswerType HostNameReturned address dns_server_ip ResponseTime success_count
local address=""
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@nslookupdiagnostic[0].DiagnosticState`" != "Requested" ] && return
local hostname=`nslookup_get cwmp.@nslookupdiagnostic[0].HostName`
local dnsserver=`nslookup_get cwmp.@nslookupdiagnostic[0].DNSServer`
local cnt=`nslookup_get cwmp.@nslookupdiagnostic[0].NumberOfRepetitions 1`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.nslookup.DiagnosticState`" != "Requested" ] && return
local hostname=`nslookup_get dmmap_diagnostics.nslookup.HostName`
local dnsserver=`nslookup_get dmmap_diagnostics.nslookup.DNSServer`
local cnt=`nslookup_get dmmap_diagnostics.nslookup.NumberOfRepetitions 1`
[ "$hostname" = "" ] && return
i=0
j=0
@ -69,27 +67,27 @@ nslookup_launch() {
echo $line | grep 'Non-authoritative' >/dev/null 2>&1 && { AnswerType="NonAuthoritative"; continue; }
if echo $line | grep '++++++++++++++++++++++' >/dev/null 2>&1; then
$UCI_ADD_VARSTATE cwmp NSLookupResult
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].Status=$status
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].AnswerType=$AnswerType
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].HostNameReturned=$HostNameReturned
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].IPAddresses=$address
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].DNSServerIP=$dns_server_ip
$UCI_SET_VARSTATE cwmp.@NSLookupResult[$j].ResponseTime=$ResponseTime
$UCI_ADD_BBFDM dmmap_diagnostics NSLookupResult
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].Status=$status
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].AnswerType=$AnswerType
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].HostNameReturned=$HostNameReturned
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].IPAddresses=$address
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].DNSServerIP=$dns_server_ip
$UCI_SET_BBFDM dmmap_diagnostics.@NSLookupResult[$j].ResponseTime=$ResponseTime
let j++
address=""
fi
done <${LOG_FILE}
rm -f ${LOG_FILE}
$UCI_SET_VARSTATE cwmp.@nslookupdiagnostic[0].SuccessCount=$success_count
[ "$1" == "cwmp" ] && $UCI_SET_VARSTATE cwmp.@nslookupdiagnostic[0].DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.nslookup.SuccessCount=$success_count
[ "$1" == "cwmp" ] && $UCI_SET_BBFDM dmmap_diagnostics.nslookup.DiagnosticState=Complete
[ "$1" == "cwmp" ] && event_dignostic
}
delete_all_results() {
local j
for j in $($UCI_SHOW_VARSTATE cwmp | grep "cwmp.@NSLookupResult.*=NSLookupResult"); do
$UCI_DELETE_VARSTATE cwmp.@NSLookupResult[-1]
for j in $($UCI_SHOW_BBFDM dmmap_diagnostics | grep "dmmap_diagnostics.@NSLookupResult.*=NSLookupResult"); do
$UCI_DELETE_BBFDM dmmap_diagnostics.@NSLookupResult[-1]
done
}
@ -109,7 +107,7 @@ nslookup_stop_diagnostic() {
local pids=`ps | grep nslookup_launch | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@nslookupdiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.nslookup.DiagnosticState=None
fi
}

44
scripts/functions/serverselection_launch
View file

@ -2,26 +2,24 @@
# Copyright (C) 2019 iopsys Software Solutions AB
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
serverselection_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
serverselection_launch() {
local i res ba stc times sc1 success_count min_time avg_time max_time avg_time_sum min max micros
local fasthost avg_time_host min_time_host max_time_host
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState`" != "Requested" ] && return
local hostlist=`serverselection_get cwmp.@serverselectiondiagnostic[0].HostList`
local cnt=`serverselection_get cwmp.@serverselectiondiagnostic[0].NumberOfRepetitions 3`
local timeout=`serverselection_get cwmp.@serverselectiondiagnostic[0].Timeout 1000`
local port=`serverselection_get cwmp.@serverselectiondiagnostic[0].port`
local protoversion=`serverselection_get cwmp.@serverselectiondiagnostic[0].ProtocolVersion Any`
local proto=`serverselection_get cwmp.@serverselectiondiagnostic[0].Protocol ICMP`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState`" != "Requested" ] && return
local hostlist=`serverselection_get dmmap_diagnostics.serverselection.HostList`
local cnt=`serverselection_get dmmap_diagnostics.serverselection.NumberOfRepetitions 3`
local timeout=`serverselection_get dmmap_diagnostics.serverselection.Timeout 1000`
local port=`serverselection_get dmmap_diagnostics.serverselection.port`
local protoversion=`serverselection_get dmmap_diagnostics.serverselection.ProtocolVersion Any`
local proto=`serverselection_get dmmap_diagnostics.serverselection.Protocol ICMP`
[ "$hostlist" = "" ] && return
timeout=$((timeout/1000))
[ "$timeout" = "0" ] && timeout="1"
@ -41,11 +39,11 @@ serverselection_launch() {
[ "$protoversion" = "IPv4" ] && res=$(ping -q -4 -c 1 -W $timeout $host 2>&1)
[ "$protoversion" = "IPv6" ] && res=$(ping -q -6 -c 1 -W $timeout $host 2>&1)
ba=`echo "$res" | grep "bad address"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState=Error_CannotResolveHostName; break; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Error_CannotResolveHostName; break; }
ba=`echo "$res" | grep "unknown host"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState=Error_CannotResolveHostName; break; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Error_CannotResolveHostName; break; }
stc=`echo "$res" | grep "received"`
[ -z "$stc" ] && { $UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState=Error_Other; break; }
[ -z "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Error_Other; break; }
times=`echo "$res" | grep "min/avg/max"`
[ -z "$times" ] && break
sc1=`echo $stc | awk '{print $4}'`
@ -73,9 +71,9 @@ serverselection_launch() {
[ "$protoversion" = "IPv4" ] && res=$(nping -4 -c 1 --udp --dest-port $port --data-length 24 $host 2>&1)
[ "$protoversion" = "IPv6" ] && res=$(nping -6 -c 1 --udp --dest-port $port --data-length 24 $host 2>&1)
ba=`echo "$res" | grep "RCVD"`
[ -z "$ba" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_CannotResolveHostName; return; }
[ -z "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Error_CannotResolveHostName; return; }
stc=`echo "$res" | grep "RCVD" | grep "unreachable"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_Other; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Error_Other; return; }
times=`echo "$res" | grep "rtt"`
[ -z "$times" ] && continue
sc1=`echo "$res" | grep "Rcvd" | awk -F': ' '{print $3}' | awk -F'(' '{ print $1 }'`
@ -103,11 +101,11 @@ serverselection_launch() {
max=0
i=0
done
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].FastestHost=$fasthost
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].AverageResponseTime=$avg_time_host
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].MinimumResponseTime=$min_time_host
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].MaximumResponseTime=$max_time_host
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.FastestHost=$fasthost
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.AverageResponseTime=$avg_time_host
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.MinimumResponseTime=$min_time_host
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.MaximumResponseTime=$max_time_host
[ "$1" == "cwmp" ] && event_dignostic
}
@ -126,7 +124,7 @@ serverselection_stop_diagnostic() {
local pids=`ps | grep serverselection_launch | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@serverselectiondiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.serverselection.DiagnosticState=None
fi
}

46
scripts/functions/traceroute_launch
View file

@ -2,26 +2,26 @@
# Copyright (C) 2019 iopsys Software Solutions AB
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_ADD_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state add"
UCI_DELETE_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state delete"
UCI_SHOW_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state show"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
UCI_ADD_BBFDM="/sbin/uci -q -c /etc/bbfdm add"
UCI_DELETE_BBFDM="/sbin/uci -q -c /etc/bbfdm delete"
UCI_SHOW_BBFDM="/sbin/uci -q -c /etc/bbfdm show"
traceroute_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
traceroute_launch() {
local i res host ip time=0
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@traceroutediagnostic[0].DiagnosticState`" != "Requested" ] && return
local host=`traceroute_get cwmp.@traceroutediagnostic[0].Host`
local cnt=`traceroute_get cwmp.@traceroutediagnostic[0].NumberOfTries 3`
local dsize=`traceroute_get cwmp.@traceroutediagnostic[0].DataBlockSize 38`
local timeout=`traceroute_get cwmp.@traceroutediagnostic[0].Timeout 5000`
local maxhop=`traceroute_get cwmp.@traceroutediagnostic[0].MaxHops 30`
local proto=`traceroute_get cwmp.@traceroutediagnostic[0].ProtocolVersion Any`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.traceroute.DiagnosticState`" != "Requested" ] && return
local host=`traceroute_get dmmap_diagnostics.traceroute.Host`
local cnt=`traceroute_get dmmap_diagnostics.traceroute.NumberOfTries 3`
local dsize=`traceroute_get dmmap_diagnostics.traceroute.DataBlockSize 38`
local timeout=`traceroute_get dmmap_diagnostics.traceroute.Timeout 5000`
local maxhop=`traceroute_get dmmap_diagnostics.traceroute.MaxHops 30`
local proto=`traceroute_get dmmap_diagnostics.traceroute.ProtocolVersion Any`
[ "$host" = "" ] && return
timeout=$((timeout/1000))
[ "$timeout" = "0" ] && timeout = "1"
@ -37,24 +37,24 @@ traceroute_launch() {
[ "$i" = "-1" ] && continue;
ip=${ip#(}; ip=${ip%)}
time=${time%.*}
$UCI_ADD_VARSTATE cwmp RouteHops
$UCI_SET_VARSTATE cwmp.@RouteHops[$i].host=$host
$UCI_SET_VARSTATE cwmp.@RouteHops[$i].ip=$ip
$UCI_SET_VARSTATE cwmp.@RouteHops[$i].time=$time
$UCI_ADD_BBFDM dmmap_diagnostics RouteHops
$UCI_SET_BBFDM dmmap_diagnostics.@RouteHops[$i].host=$host
$UCI_SET_BBFDM dmmap_diagnostics.@RouteHops[$i].ip=$ip
$UCI_SET_BBFDM dmmap_diagnostics.@RouteHops[$i].time=$time
done < /tmp/traceres
rm -f /tmp/traceres
let i++
[ "$1" == "cwmp" ] && $UCI_SET_VARSTATE cwmp.@traceroutediagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@traceroutediagnostic[0].NumberOfHops=$i
$UCI_SET_VARSTATE cwmp.@traceroutediagnostic[0].ResponseTime=$($UCI_GET_VARSTATE cwmp.@RouteHops[-1].time)
[ "$1" == "cwmp" ] && $UCI_SET_BBFDM dmmap_diagnostics.traceroute.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.traceroute.NumberOfHops=$i
$UCI_SET_BBFDM dmmap_diagnostics.traceroute.ResponseTime=$($UCI_GET_BBFDM dmmap_diagnostics.@RouteHops[-1].time)
[ "$1" == "cwmp" ] && event_diagnostic
}
delete_all_route_hops() {
local j
for j in $($UCI_SHOW_VARSTATE cwmp | grep "cwmp.@RouteHops.*=RouteHops"); do
$UCI_DELETE_VARSTATE cwmp.@RouteHops[-1]
for j in $($UCI_SHOW_BBFDM dmmap_diagnostics | grep "dmmap_diagnostics.@RouteHops.*=RouteHops"); do
$UCI_DELETE_BBFDM dmmap_diagnostics.@RouteHops[-1]
done
}
@ -75,7 +75,7 @@ traceroute_stop() {
[ -z "$pids" ] && pids=`ps | grep traceroute_launch | grep -v grep | grep -v stop | awk '{print $2}'`
if [ -n "$pids" ]; then
kill -9 $pids 2>/dev/null
$UCI_SET_VARSTATE cwmp.@traceroutediagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.traceroute.DiagnosticState=None
fi
}

42
scripts/functions/udpecho_launch
View file

@ -2,26 +2,24 @@
# Copyright (C) 2019 iopsys Software Solutions AB
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
udpecho_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
udpecho_launch() {
local i res ba stc times sc1 success_count failure_count min_time avg_time max_time avg_time_sum min max micros
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@udpechodiagnostic[0].DiagnosticState`" != "Requested" ] && return
local host=`udpecho_get cwmp.@udpechodiagnostic[0].Host`
local port=`udpecho_get cwmp.@udpechodiagnostic[0].port`
local cnt=`udpecho_get cwmp.@udpechodiagnostic[0].NumberOfRepetitions 1`
local dsize=`udpecho_get cwmp.@udpechodiagnostic[0].DataBlockSize 24`
local dscp=`udpecho_get cwmp.@udpechodiagnostic[0].DSCP 0`
local proto=`udpecho_get cwmp.@udpechodiagnostic[0].ProtocolVersion Any`
local inter_time=`udpecho_get cwmp.@udpechodiagnostic[0].InterTransmissionTime 1000`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.udpechodiag.DiagnosticState`" != "Requested" ] && return
local host=`udpecho_get dmmap_diagnostics.udpechodiag.Host`
local port=`udpecho_get dmmap_diagnostics.udpechodiag.port`
local cnt=`udpecho_get dmmap_diagnostics.udpechodiag.NumberOfRepetitions 1`
local dsize=`udpecho_get dmmap_diagnostics.udpechodiag.DataBlockSize 24`
local dscp=`udpecho_get dmmap_diagnostics.udpechodiag.DSCP 0`
local proto=`udpecho_get dmmap_diagnostics.udpechodiag.ProtocolVersion Any`
local inter_time=`udpecho_get dmmap_diagnostics.udpechodiag.InterTransmissionTime 1000`
local tos=$((dscp<<2))
inter_time=$((inter_time/1000))
[ "$inter_time" = "0" ] && inter_time="1"
@ -40,9 +38,9 @@ udpecho_launch() {
[ "$proto" = "IPv4" ] && res=$(nping -4 -c 1 --tos $tos --udp --dest-port $port --data-length $dsize $host 2>&1)
[ "$proto" = "IPv6" ] && res=$(nping -6 -c 1 --tos $tos --udp --dest-port $port --data-length $dsize $host 2>&1)
ba=`echo "$res" | grep "RCVD"`
[ -z "$ba" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_CannotResolveHostName; return; }
[ -z "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.DiagnosticState=Error_CannotResolveHostName; return; }
stc=`echo "$res" | grep "RCVD" | grep "unreachable"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@ippingdiagnostic[0].DiagnosticState=Error_Other; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.DiagnosticState=Error_Other; return; }
times=`echo "$res" | grep "rtt"`
[ -z "$times" ] && continue
sc1=`echo "$res" | grep "Rcvd" | awk -F': ' '{print $3}' | awk -F'(' '{ print $1 }'`
@ -66,12 +64,12 @@ udpecho_launch() {
[ $success_count -gt 0 ] && avg_time=$((avg_time_sum/success_count)) || avg_time=0
min_time=$min
max_time=$max
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].SuccessCount=$success_count
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].FailureCount=$failure_count
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].AverageResponseTime=$avg_time
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].MinimumResponseTime=$min_time
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].MaximumResponseTime=$max_time
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.SuccessCount=$success_count
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.FailureCount=$failure_count
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.AverageResponseTime=$avg_time
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.MinimumResponseTime=$min_time
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.MaximumResponseTime=$max_time
[ "$1" == "cwmp" ] && event_dignostic
}
@ -90,7 +88,7 @@ udpecho_stop_diagnostic() {
local pids=`ps | grep udpecho_launch | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@udpechodiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.udpechodiag.DiagnosticState=None
fi
}

60
scripts/functions/upload_launch
View file

@ -3,18 +3,16 @@
# Author: IMEN Bhiri <imen.bhiri@pivasoftware.com>
# Author: AMIN Ben Ramdhane <amin.benramdhane@pivasoftware.com>
UCI_CONFIG_DIR="/etc/config/"
UCI_GET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state get"
UCI_SET_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state set"
UCI_ADD_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state add"
UCI_DELETE_VARSTATE="/sbin/uci -q ${UCI_CONFIG_DIR:+-c $UCI_CONFIG_DIR} -P /var/state delete"
UCI_GET_BBFDM="/sbin/uci -q -c /etc/bbfdm get"
UCI_SET_BBFDM="/sbin/uci -q -c /etc/bbfdm set"
UCI_ADD_BBFDM="/sbin/uci -q -c /etc/bbfdm add"
UCI_DELETE_BBFDM="/sbin/uci -q -c /etc/bbfdm delete"
CAPTURE_FILE="/tmp/upload_dump"
UPLOAD_DIAGNOSTIC_FILE="/tmp/bbfdm_upload_diagnostic"
CONNECTION_TIMEOUT=20
upload_get() {
local val=`$UCI_GET_VARSTATE $1`
local val=`$UCI_GET_BBFDM $1`
echo ${val:-$2}
}
@ -23,9 +21,9 @@ upload_launch() {
local url=$2
local interface=$3
local size=$4
[ "$1" == "cwmp" ] && [ "`$UCI_GET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState`" != "Requested" ] && return
[ "$url" = "" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_InitConnectionFailed; return; }
local proto=`upload_get cwmp.@uploaddiagnostic[0].ProtocolVersion Any`
[ "$1" == "cwmp" ] && [ "`$UCI_GET_BBFDM dmmap_diagnostics.upload.DiagnosticState`" != "Requested" ] && return
[ "$url" = "" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_InitConnectionFailed; return; }
local proto=`upload_get dmmap_diagnostics.upload.ProtocolVersion Any`
# Disable acceleration on Broadcom devices to capture all packets with tcpdump
[ -e /usr/sbin/fcctl ] && { fcctl disable >/dev/null 2>&1; fcctl flush >/dev/null 2>&1; }
tcpdump -i $interface tcp -w ${CAPTURE_FILE} > /dev/null 2>&1 &
@ -43,11 +41,11 @@ upload_launch() {
tx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.tx_bytes`
rx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.rx_bytes`
ba=`echo "$res" | grep "bad address"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_InitConnectionFailed; kill $PID &> /dev/null; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_InitConnectionFailed; kill $PID &> /dev/null; return; }
stc=`echo "$res" | grep "404 Not Found"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_NoResponse; kill $PID &> /dev/null; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_NoResponse; kill $PID &> /dev/null; return; }
stc=`echo "$res" |sed -n 3p|awk '{print $13}'`
[ "$stc" != "100" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_TransferFailed; kill $PID &> /dev/null; return; }
[ "$stc" != "100" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_TransferFailed; kill $PID &> /dev/null; return; }
elif [ ${url:0:6} = ftp:// ]; then
#add user and pass if they exist
substr="@"
@ -64,30 +62,30 @@ upload_launch() {
tx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.tx_bytes`
rx_bytes_after=`ubus call network.device status "{'name':'$interface'}" | jsonfilter -e @.statistics.rx_bytes`
ba=`echo "$res" | grep "Couldn't resolve host"`
[ -n "$ba" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_InitConnectionFailed; kill $PID 2> /dev/null; return; }
[ -n "$ba" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_InitConnectionFailed; kill $PID 2> /dev/null; return; }
stc=`echo "$res" | grep "Access denied"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_LoginFailed; kill $PID 2> /dev/null; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_LoginFailed; kill $PID 2> /dev/null; return; }
stc=`echo "$res" | grep "Failed FTP upload"`
[ -n "$stc" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_NoResponse; kill $PID 2> /dev/null; return; }
[ -n "$stc" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_NoResponse; kill $PID 2> /dev/null; return; }
stc=`echo "$res" |tail -n 1 |awk '{print $(NF-11)}'`
[ "$stc" != "100" ] && { $UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Error_TransferFailed; kill $PID 2> /dev/null; return; }
[ "$stc" != "100" ] && { $UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Error_TransferFailed; kill $PID 2> /dev/null; return; }
fi
tx_bytes=$((tx_bytes_after-tx_bytes_before))
rx_bytes=$((rx_bytes_after-rx_bytes_before))
periodtime=$(($((time2-time1))*1000000))
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=Complete
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].TestBytesSent=$size
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].TotalBytesReceived=$rx_bytes
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].TotalBytesSent=$tx_bytes
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].PeriodOfFullLoading=$periodtime
local perconnection=`$UCI_GET_VARSTATE cwmp.@uploaddiagnostic[0].EnablePerConnection`
$UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=Complete
$UCI_SET_BBFDM dmmap_diagnostics.upload.TestBytesSent=$size
$UCI_SET_BBFDM dmmap_diagnostics.upload.TotalBytesReceived=$rx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.upload.TotalBytesSent=$tx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.upload.PeriodOfFullLoading=$periodtime
local perconnection=`$UCI_GET_BBFDM dmmap_diagnostics.upload.EnablePerConnection`
if ([ "$perconnection" == "true" ] || [ "$perconnection" == "1" ]); then
$UCI_ADD_VARSTATE cwmp UploadPerConnection
$UCI_SET_VARSTATE cwmp.@UploadPerConnection[0].TestBytesSent=$size
$UCI_SET_VARSTATE cwmp.@UploadPerConnection[0].TotalBytesReceived=$rx_bytes
$UCI_SET_VARSTATE cwmp.@UploadPerConnection[0].TotalBytesSent=$tx_bytes
$UCI_ADD_BBFDM dmmap_diagnostics UploadPerConnection
$UCI_SET_BBFDM dmmap_diagnostics.@UploadPerConnection[0].TestBytesSent=$size
$UCI_SET_BBFDM dmmap_diagnostics.@UploadPerConnection[0].TotalBytesReceived=$rx_bytes
$UCI_SET_BBFDM dmmap_diagnostics.@UploadPerConnection[0].TotalBytesSent=$tx_bytes
else
$UCI_DELETE_VARSTATE cwmp.@UploadPerConnection[0]
$UCI_DELETE_BBFDM dmmap_diagnostics.@UploadPerConnection[0]
fi
rm ${UPLOAD_DIAGNOSTIC_FILE} &>/dev/null
sleep 3
@ -98,11 +96,11 @@ upload_launch() {
}
upload_stop_diagnostic() {
$UCI_DELETE_VARSTATE cwmp.@UploadPerConnection[0]
$UCI_DELETE_BBFDM dmmap_diagnostics.@UploadPerConnection[0]
local pids=`ps | grep upload_launch.*run | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=None
fi
local pids=`ps | grep upload_launch.*run | grep -v grep | awk '{print $1}'`
if [ -n "$pids" ]; then
@ -111,7 +109,7 @@ upload_stop_diagnostic() {
kill -9 $kid &>/dev/null
done
kill -9 $pids &>/dev/null
$UCI_SET_VARSTATE cwmp.@uploaddiagnostic[0].DiagnosticState=None
$UCI_SET_BBFDM dmmap_diagnostics.upload.DiagnosticState=None
fi
}