mirror/icwmp
1
0
Fork 0
mirror of https://dev.iopsys.eu/bbf/icwmp.git synced 2026-01-28 01:27:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove mutex for uci operation

Browse source
This commit is contained in:
Suvendhu Hansa 2023-01-31 13:55:13 +00:00 • committed by Vivek Kumar Dutta
parent 24984b7cd7
commit 9ee5a5a95a
18 changed files with 502 additions and 233 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
backupSession.c
View file

@ -764,10 +764,14 @@ void bkp_session_delete_transfer_complete(struct transfer_complete *ptransfer_co
int save_acs_bkp_config(struct cwmp *cwmp)
{
struct config *conf;
char *url = NULL;
conf = &(cwmp->conf);
bkp_session_simple_insert("acs", "url", conf->acsurl);
global_string_param_read(&conf->acsurl, &url);
bkp_session_simple_insert("acs", "url", url);
bkp_session_save();
FREE(url);
return CWMP_OK;
}

133
common.c
View file

@ -35,6 +35,7 @@ static int nbre_services = 0;
static char *list_services[MAX_NBRE_SERVICES] = { 0 };
LIST_HEAD(cwmp_memory_list);
extern bool g_firewall_restart;
pthread_mutex_t mutex_global_config = PTHREAD_MUTEX_INITIALIZER;
struct cwmp_mem {
struct list_head list;
@ -133,6 +134,121 @@ int global_env_init(int argc, char **argv, struct env *env)
return CWMP_OK;
}
int global_int_param_read(const int *param)
{
int val = 0;
pthread_mutex_lock(&mutex_global_config);
val = *param;
pthread_mutex_unlock(&mutex_global_config);
return val;
}
void global_string_param_read(char **param, char **val)
{
if (param == NULL || *param == NULL || val == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
*val = CWMP_STRDUP(*param);
pthread_mutex_unlock(&mutex_global_config);
}
bool global_bool_param_read(const bool *param)
{
bool val = 0;
pthread_mutex_lock(&mutex_global_config);
val = *param;
pthread_mutex_unlock(&mutex_global_config);
return val;
}
time_t global_time_param_read(const time_t *param)
{
time_t val = 0;
pthread_mutex_lock(&mutex_global_config);
val = *param;
pthread_mutex_unlock(&mutex_global_config);
return val;
}
unsigned int global_uint_param_read(const unsigned int *param)
{
unsigned int val = 0;
pthread_mutex_lock(&mutex_global_config);
val = *param;
pthread_mutex_unlock(&mutex_global_config);
return val;
}
void global_string_param_write(char **param, char *value)
{
if (param == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
if (CWMP_STRLEN(value) == 0) {
FREE(*param);
} else {
*param = CWMP_STRDUP(value);
}
pthread_mutex_unlock(&mutex_global_config);
}
void global_bool_param_write(bool *param, bool value)
{
if (param == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
*param = value;
pthread_mutex_unlock(&mutex_global_config);
}
void global_time_param_write(time_t *param, time_t value)
{
if (param == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
*param = value;
pthread_mutex_unlock(&mutex_global_config);
}
void global_int_param_write(int *param, int value)
{
if (param == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
*param = value;
pthread_mutex_unlock(&mutex_global_config);
}
void global_uint_param_write(unsigned int *param, unsigned int value)
{
if (param == NULL)
return;
pthread_mutex_lock(&mutex_global_config);
*param = value;
pthread_mutex_unlock(&mutex_global_config);
}
void global_string_param_free(char **param)
{
pthread_mutex_lock(&mutex_global_config);
FREE(*param);
pthread_mutex_unlock(&mutex_global_config);
}
/*
* List dm_paramter
*/
@ -752,10 +868,13 @@ void ubus_network_interface_callback(struct ubus_request *req __attribute__((unu
// Only update the interface if its not empty
if (CWMP_STRLEN(l3_device)) {
cwmp_main.conf.interface = strdup(l3_device);
global_string_param_write(&cwmp_main.conf.interface, l3_device);
}
CWMP_LOG(DEBUG, "CWMP IFACE - interface: %s", cwmp_main.conf.interface);
char *intf = NULL;
global_string_param_read(&cwmp_main.conf.interface, &intf);
CWMP_LOG(DEBUG, "CWMP IFACE - interface: %s", intf);
FREE(intf);
}
int get_connection_interface(char *iface)
@ -772,7 +891,7 @@ int get_connection_interface(char *iface)
char ubus_obj[100] = {0};
snprintf(ubus_obj, sizeof(ubus_obj), "network.interface.%s", iface);
FREE(cwmp_main.conf.interface);
global_string_param_free(&cwmp_main.conf.interface);
int e = icwmp_ubus_invoke(ubus_obj, "status", b.head, ubus_network_interface_callback, NULL);
blob_buf_free(&b);
@ -780,9 +899,15 @@ int get_connection_interface(char *iface)
if (e != 0) {
return -1;
}
if (cwmp_main.conf.interface == NULL) {
char *tmp = NULL;
global_string_param_read(&cwmp_main.conf.interface, &tmp);
if (CWMP_STRLEN(tmp) == 0) {
FREE(tmp);
return -1;
}
FREE(tmp);
return CWMP_OK;
}

207
config.c
View file

@ -21,8 +21,6 @@
#include "datamodel_interface.h"
#include "heartbeat.h"
pthread_mutex_t mutex_config_load = PTHREAD_MUTEX_INITIALIZER;
static char* get_value_from_uci_option(struct uci_option *tb) {
if (tb == NULL)
return NULL;
@ -36,6 +34,8 @@ static char* get_value_from_uci_option(struct uci_option *tb) {
static void config_get_cpe_elements(struct config *conf, struct uci_section *s)
{
char *val = NULL;
enum {
UCI_CPE_UBUS_SOCKET_PATH,
UCI_CPE_LOG_FILE_NAME,
@ -64,8 +64,10 @@ static void config_get_cpe_elements(struct config *conf, struct uci_section *s)
struct uci_option *cpe_tb[__MAX_NUM_UCI_CPE_ATTRS] = {0};
uci_parse_section(s, cpe_opts, __MAX_NUM_UCI_CPE_ATTRS, cpe_tb);
conf->ubus_socket = CWMP_STRDUP(get_value_from_uci_option(cpe_tb[UCI_CPE_UBUS_SOCKET_PATH]));
CWMP_LOG(DEBUG, "CWMP CONFIG - ubus socket: %s", conf->ubus_socket ? conf->ubus_socket : "");
global_string_param_write(&conf->ubus_socket, get_value_from_uci_option(cpe_tb[UCI_CPE_UBUS_SOCKET_PATH]));
global_string_param_read(&conf->ubus_socket, &val);
CWMP_LOG(DEBUG, "CWMP CONFIG - ubus socket: %s", val);
FREE(val);
log_set_log_file_name(get_value_from_uci_option(cpe_tb[UCI_CPE_LOG_FILE_NAME]));
@ -79,27 +81,34 @@ static void config_get_cpe_elements(struct config *conf, struct uci_section *s)
log_set_on_syslog(get_value_from_uci_option(cpe_tb[UCI_CPE_ENABLE_SYSLOG]));
conf->amd_version = DEFAULT_AMD_VERSION;
global_int_param_write(&conf->amd_version, DEFAULT_AMD_VERSION);
char *version = get_value_from_uci_option(cpe_tb[UCI_CPE_AMD_VERSION]);
if (version != NULL) {
int a = atoi(version);
if (a >= 1 && a <= 6) {
conf->amd_version = a;
global_int_param_write(&conf->amd_version, a);
}
}
conf->supported_amd_version = conf->amd_version;
CWMP_LOG(DEBUG, "CWMP CONFIG - amendement version: %d", conf->amd_version);
int amd_ver = global_int_param_read(&conf->amd_version);
global_int_param_write(&conf->supported_amd_version, amd_ver);
CWMP_LOG(DEBUG, "CWMP CONFIG - amendement version: %d", amd_ver);
if (cpe_tb[UCI_CPE_DEFAULT_WAN_IFACE]) {
char *default_wan_iface = get_value_from_uci_option(cpe_tb[UCI_CPE_DEFAULT_WAN_IFACE]);
conf->default_wan_iface = strdup(default_wan_iface ? default_wan_iface : "wan");
global_string_param_write(&conf->default_wan_iface, default_wan_iface ? default_wan_iface : "wan");
} else {
conf->default_wan_iface = strdup("wan");
global_string_param_write(&conf->default_wan_iface, "wan");
}
CWMP_LOG(DEBUG, "CWMP CONFIG - default wan interface: %s", conf->default_wan_iface);
global_string_param_read(&conf->default_wan_iface, &val);
CWMP_LOG(DEBUG, "CWMP CONFIG - default wan interface: %s", val);
FREE(val);
}
static void config_get_acs_elements(struct config *conf, struct uci_section *s)
{
char *val = NULL;
enum {
UCI_ACS_IPV6_ENABLE,
UCI_ACS_SSL_CAPATH,
@ -119,17 +128,22 @@ static void config_get_acs_elements(struct config *conf, struct uci_section *s)
memset(acs_tb, 0, sizeof(acs_tb));
uci_parse_section(s, acs_opts, __MAX_NUM_UCI_ACS_ATTRS, acs_tb);
conf->ipv6_enable = uci_str_to_bool(get_value_from_uci_option(acs_tb[UCI_ACS_IPV6_ENABLE]));
CWMP_LOG(DEBUG, "CWMP CONFIG - ipv6 enable: %d", conf->ipv6_enable);
global_bool_param_write(&conf->ipv6_enable, uci_str_to_bool(get_value_from_uci_option(acs_tb[UCI_ACS_IPV6_ENABLE])));
bool v6_enable = global_bool_param_read(&conf->ipv6_enable);
CWMP_LOG(DEBUG, "CWMP CONFIG - ipv6 enable: %d", v6_enable);
conf->acs_ssl_capath = CWMP_STRDUP(get_value_from_uci_option(acs_tb[UCI_ACS_SSL_CAPATH]));
CWMP_LOG(DEBUG, "CWMP CONFIG - acs ssl cpath: %s", conf->acs_ssl_capath ? conf->acs_ssl_capath : "");
global_string_param_write(&conf->acs_ssl_capath, get_value_from_uci_option(acs_tb[UCI_ACS_SSL_CAPATH]));
global_string_param_read(&conf->acs_ssl_capath, &val);
CWMP_LOG(DEBUG, "CWMP CONFIG - acs ssl cpath: %s", val);
FREE(val);
conf->http_disable_100continue = uci_str_to_bool(get_value_from_uci_option(acs_tb[HTTP_DISABLE_100CONTINUE]));
CWMP_LOG(DEBUG, "CWMP CONFIG - http disable 100continue: %d", conf->http_disable_100continue);
global_bool_param_write(&conf->http_disable_100continue, uci_str_to_bool(get_value_from_uci_option(acs_tb[HTTP_DISABLE_100CONTINUE])));
bool http_100_enable = global_bool_param_read(&conf->http_disable_100continue);
CWMP_LOG(DEBUG, "CWMP CONFIG - http disable 100continue: %d", http_100_enable);
conf->insecure_enable = uci_str_to_bool(get_value_from_uci_option(acs_tb[UCI_ACS_INSECURE_ENABLE]));
CWMP_LOG(DEBUG, "CWMP CONFIG - acs insecure enable: %d", conf->insecure_enable);
global_bool_param_write(&conf->insecure_enable, uci_str_to_bool(get_value_from_uci_option(acs_tb[UCI_ACS_INSECURE_ENABLE])));
bool insecure_en = global_bool_param_read(&conf->insecure_enable);
CWMP_LOG(DEBUG, "CWMP CONFIG - acs insecure enable: %d", insecure_en);
}
int get_preinit_config(struct config *conf)
@ -176,7 +190,7 @@ static char* get_alternate_option_value(bool discovery_enable, char *acs_val, ch
int get_global_config(struct config *conf)
{
int error;
char *value = NULL, *value2 = NULL, *value3 = NULL;
char *value = NULL, *value2 = NULL, *value3 = NULL, *temp = NULL;
if ((error = uci_get_value(UCI_CPE_CWMP_ENABLE, &value)) == CWMP_OK) {
if (value != NULL && uci_str_to_bool(value) == false) {
@ -187,11 +201,14 @@ int get_global_config(struct config *conf)
}
FREE(value);
error = get_connection_interface(conf->default_wan_iface);
global_string_param_read(&conf->default_wan_iface, &temp);
error = get_connection_interface(temp);
if (error != CWMP_OK) {
CWMP_LOG(DEBUG, "Failed to get interface [%s] details", conf->default_wan_iface);
CWMP_LOG(DEBUG, "Failed to get interface [%s] details", temp);
FREE(temp);
return error;
}
FREE(temp);
bool discovery_enable = false;
error = uci_get_value(UCI_DHCP_DISCOVERY_PATH, &value);
@ -203,18 +220,22 @@ int get_global_config(struct config *conf)
uci_get_value(UCI_ACS_URL_PATH, &value2);
uci_get_value(UCI_DHCP_ACS_URL, &value3);
FREE(conf->acsurl);
conf->acsurl = CWMP_STRDUP(get_alternate_option_value(discovery_enable, value2, value3));
global_string_param_free(&conf->acsurl);
char *url = get_alternate_option_value(discovery_enable, value2, value3);
global_string_param_write(&conf->acsurl, url);
FREE(value2);
FREE(value3);
if (conf->acsurl == NULL) {
global_string_param_read(&conf->acsurl, &temp);
if (CWMP_STRLEN(url) == 0) {
FREE(temp);
return CWMP_GEN_ERR;
}
FREE(temp);
if ((error = uci_get_value(UCI_ACS_GETRPC, &value)) == CWMP_OK) {
conf->acs_getrpc = uci_str_to_bool(value);
global_bool_param_write(&conf->acs_getrpc, uci_str_to_bool(value));
FREE(value);
} else {
return error;
@ -222,8 +243,8 @@ int get_global_config(struct config *conf)
if ((error = uci_get_value(UCI_ACS_USERID_PATH, &value)) == CWMP_OK) {
if (value != NULL) {
FREE(conf->acs_userid);
conf->acs_userid = strdup(value);
global_string_param_free(&conf->acs_userid);
global_string_param_write(&conf->acs_userid, value);
FREE(value);
}
} else {
@ -232,8 +253,8 @@ int get_global_config(struct config *conf)
if ((error = uci_get_value(UCI_ACS_PASSWD_PATH, &value)) == CWMP_OK) {
if (value != NULL) {
FREE(conf->acs_passwd);
conf->acs_passwd = strdup(value);
global_string_param_free(&conf->acs_passwd);
global_string_param_write(&conf->acs_passwd, value);
FREE(value);
}
} else {
@ -241,31 +262,31 @@ int get_global_config(struct config *conf)
}
if ((error = uci_get_value(UCI_ACS_COMPRESSION, &value)) == CWMP_OK) {
conf->compression = COMP_NONE;
if (conf->amd_version >= AMD_5 && value != NULL) {
global_int_param_write(&conf->compression, COMP_NONE);
if (global_int_param_read(&conf->amd_version) >= AMD_5 && value != NULL) {
if (0 == strcasecmp(value, "gzip")) {
conf->compression = COMP_GZIP;
global_int_param_write(&conf->compression, COMP_GZIP);
} else if (0 == strcasecmp(value, "deflate")) {
conf->compression = COMP_DEFLATE;
global_int_param_write(&conf->compression, COMP_DEFLATE);
} else {
conf->compression = COMP_NONE;
global_int_param_write(&conf->compression, COMP_NONE);
}
}
FREE(value);
} else {
conf->compression = COMP_NONE;
global_int_param_write(&conf->compression, COMP_NONE);
}
conf->retry_min_wait_interval = DEFAULT_RETRY_MINIMUM_WAIT_INTERVAL;
global_int_param_write(&conf->retry_min_wait_interval, DEFAULT_RETRY_MINIMUM_WAIT_INTERVAL);
uci_get_value(UCI_ACS_RETRY_MIN_WAIT_INTERVAL, &value2);
uci_get_value(UCI_DHCP_ACS_RETRY_MIN_WAIT_INTERVAL, &value3);
char *op_interval = get_alternate_option_value(discovery_enable, value2, value3);
if (op_interval != NULL) {
if (conf->amd_version >= AMD_3) {
if (global_int_param_read(&conf->amd_version) >= AMD_3) {
int a = atoi(op_interval);
if (a <= 65535 && a >= 1) {
conf->retry_min_wait_interval = a;
global_int_param_write(&conf->retry_min_wait_interval, a);
}
}
}
@ -273,16 +294,16 @@ int get_global_config(struct config *conf)
FREE(value2);
FREE(value3);
conf->retry_interval_multiplier = DEFAULT_RETRY_INTERVAL_MULTIPLIER;
global_int_param_write(&conf->retry_interval_multiplier, DEFAULT_RETRY_INTERVAL_MULTIPLIER);
uci_get_value(UCI_ACS_RETRY_INTERVAL_MULTIPLIER, &value2);
uci_get_value(UCI_DHCP_ACS_RETRY_INTERVAL_MULTIPLIER, &value3);
char *op_multi = get_alternate_option_value(discovery_enable, value2, value3);
if (op_multi != NULL) {
if (conf->amd_version >= AMD_3) {
if (global_int_param_read(&conf->amd_version) >= AMD_3) {
int a = atoi(op_multi);
if (a <= 65535 && a >= 1000) {
conf->retry_interval_multiplier = a;
global_int_param_write(&conf->retry_interval_multiplier, a);
}
}
}
@ -291,24 +312,24 @@ int get_global_config(struct config *conf)
FREE(value3);
if ((error = uci_get_value(UCI_CPE_USERID_PATH, &value)) == CWMP_OK) {
FREE(conf->cpe_userid);
global_string_param_free(&conf->cpe_userid);
if (value != NULL) {
conf->cpe_userid = strdup(value);
global_string_param_write(&conf->cpe_userid, value);
FREE(value);
} else {
conf->cpe_userid = strdup("");
global_string_param_write(&conf->cpe_userid, "");
}
} else {
return error;
}
if ((error = uci_get_value(UCI_CPE_PASSWD_PATH, &value)) == CWMP_OK) {
FREE(conf->cpe_passwd);
global_string_param_free(&conf->cpe_passwd);
if (value != NULL) {
conf->cpe_passwd = strdup(value);
global_string_param_write(&conf->cpe_passwd, value);
FREE(value);
} else {
conf->cpe_passwd = strdup("");
global_string_param_write(&conf->cpe_passwd, "");
}
} else {
return error;
@ -324,25 +345,25 @@ int get_global_config(struct config *conf)
if (a == 0) {
CWMP_LOG(INFO, "Set the connection request port to the default value: %d", DEFAULT_CONNECTION_REQUEST_PORT);
conf->connection_request_port = DEFAULT_CONNECTION_REQUEST_PORT;
global_int_param_write(&conf->connection_request_port, DEFAULT_CONNECTION_REQUEST_PORT);
} else {
conf->connection_request_port = a;
global_int_param_write(&conf->connection_request_port, a);
}
} else {
return error;
}
if ((error = uci_get_value(UCI_CPE_CRPATH_PATH, &value)) == CWMP_OK) {
FREE(conf->connection_request_path);
global_string_param_free(&conf->connection_request_path);
if (value == NULL)
conf->connection_request_path = strdup("/");
global_string_param_write(&conf->connection_request_path, "/");
else {
if (value[0] == '/')
conf->connection_request_path = strdup(value);
global_string_param_write(&conf->connection_request_path, value);
else {
char cr_path[512];
snprintf(cr_path, sizeof(cr_path), "/%s", value);
conf->connection_request_path = strdup(cr_path);
global_string_param_write(&conf->connection_request_path, cr_path);
}
FREE(value);
}
@ -356,7 +377,7 @@ int get_global_config(struct config *conf)
a = uci_str_to_bool(value);
FREE(value);
}
conf->periodic_notify_enable = a;
global_bool_param_write(&conf->periodic_notify_enable, a);
} else {
return error;
}
@ -371,9 +392,9 @@ int get_global_config(struct config *conf)
if (a == 0) {
CWMP_LOG(INFO, "Set notify period to the default value: %d", DEFAULT_NOTIFY_PERIOD);
conf->periodic_notify_interval = DEFAULT_NOTIFY_PERIOD;
global_int_param_write(&conf->periodic_notify_interval, DEFAULT_NOTIFY_PERIOD);
} else {
conf->periodic_notify_interval = a;
global_int_param_write(&conf->periodic_notify_interval, a);
}
} else {
return error;
@ -381,10 +402,10 @@ int get_global_config(struct config *conf)
if ((error = uci_get_value(UCI_PERIODIC_INFORM_TIME_PATH, &value)) == CWMP_OK) {
if (value != NULL) {
conf->time = convert_datetime_to_timestamp(value);
global_time_param_write(&conf->time, convert_datetime_to_timestamp(value));
FREE(value);
} else {
conf->time = 0;
global_time_param_write(&conf->time, 0);
}
} else {
return error;
@ -392,7 +413,7 @@ int get_global_config(struct config *conf)
char *entropy = generate_random_string(sizeof(unsigned int));
if (entropy != NULL) {
conf->periodic_entropy = (unsigned int)strtoul(entropy, NULL, 16);
global_uint_param_write(&conf->periodic_entropy, (unsigned int)strtoul(entropy, NULL, 16));
free(entropy);
}
@ -405,17 +426,17 @@ int get_global_config(struct config *conf)
}
if (a >= PERIOD_INFORM_MIN) {
conf->period = a;
global_int_param_write(&conf->period, a);
} else {
CWMP_LOG(ERROR, "Period interval of periodic inform should be > %ds. Set to default: %ds", PERIOD_INFORM_MIN, PERIOD_INFORM_DEFAULT);
conf->period = PERIOD_INFORM_DEFAULT;
global_int_param_write(&conf->period, PERIOD_INFORM_DEFAULT);
}
} else {
return error;
}
if ((error = uci_get_value(UCI_PERIODIC_INFORM_ENABLE_PATH, &value)) == CWMP_OK) {
conf->periodic_enable = uci_str_to_bool(value);
global_bool_param_write(&conf->periodic_enable, uci_str_to_bool(value));
FREE(value);
} else {
return error;
@ -424,24 +445,24 @@ int get_global_config(struct config *conf)
if ((error = uci_get_value(UCI_CPE_INSTANCE_MODE, &value)) == CWMP_OK) {
if (value != NULL) {
if (0 == strcmp(value, "InstanceNumber")) {
conf->instance_mode = INSTANCE_MODE_NUMBER;
global_uint_param_write(&conf->instance_mode, INSTANCE_MODE_NUMBER);
} else {
conf->instance_mode = INSTANCE_MODE_ALIAS;
global_uint_param_write(&conf->instance_mode, INSTANCE_MODE_ALIAS);
}
FREE(value);
} else {
conf->instance_mode = DEFAULT_INSTANCE_MODE;
global_uint_param_write(&conf->instance_mode, DEFAULT_INSTANCE_MODE);
}
} else {
return error;
}
if ((error = uci_get_value(UCI_CPE_SESSION_TIMEOUT, &value)) == CWMP_OK) {
conf->session_timeout = DEFAULT_SESSION_TIMEOUT;
global_uint_param_write(&conf->session_timeout, DEFAULT_SESSION_TIMEOUT);
if (value != NULL) {
int a = atoi(value);
if (a >= 1) {
conf->session_timeout = a;
global_uint_param_write(&conf->session_timeout, a);
}
FREE(value);
}
@ -450,19 +471,21 @@ int get_global_config(struct config *conf)
}
if ((error = uci_get_value(LW_NOTIFICATION_ENABLE, &value)) == CWMP_OK) {
conf->lw_notification_enable = uci_str_to_bool(value);
global_bool_param_write(&conf->lw_notification_enable, uci_str_to_bool(value));
FREE(value);
} else {
return error;
}
if ((error = uci_get_value(LW_NOTIFICATION_HOSTNAME, &value)) == CWMP_OK) {
FREE(conf->lw_notification_hostname);
global_string_param_free(&conf->lw_notification_hostname);
if (value != NULL) {
conf->lw_notification_hostname = strdup(value);
global_string_param_write(&conf->lw_notification_hostname, value);
FREE(value);
} else {
conf->lw_notification_hostname = strdup(conf->acsurl ? conf->acsurl : "");
global_string_param_read(&conf->acsurl, &temp);
global_string_param_write(&conf->lw_notification_hostname, temp);
FREE(temp);
}
} else {
return error;
@ -471,10 +494,10 @@ int get_global_config(struct config *conf)
if ((error = uci_get_value(LW_NOTIFICATION_PORT, &value)) == CWMP_OK) {
if (value != NULL) {
int a = atoi(value);
conf->lw_notification_port = a;
global_int_param_write(&conf->lw_notification_port, a);
FREE(value);
} else {
conf->lw_notification_port = DEFAULT_LWN_PORT;
global_int_param_write(&conf->lw_notification_port, DEFAULT_LWN_PORT);
}
} else {
return error;
@ -482,10 +505,10 @@ int get_global_config(struct config *conf)
if (uci_get_value(UCI_CPE_SCHEDULE_REBOOT, &value) == CWMP_OK) {
if (value != NULL) {
conf->schedule_reboot = convert_datetime_to_timestamp(value);
global_time_param_write(&conf->schedule_reboot, convert_datetime_to_timestamp(value));
FREE(value);
} else {
conf->schedule_reboot = 0;
global_time_param_write(&conf->schedule_reboot, 0);
}
} else {
return error;
@ -499,41 +522,41 @@ int get_global_config(struct config *conf)
FREE(value);
}
conf->delay_reboot = delay;
global_int_param_write(&conf->delay_reboot, delay);
} else {
return error;
}
if (uci_get_value(UCI_CPE_FORCED_INFORM_JSON, &value) == CWMP_OK) {
FREE(conf->forced_inform_json_file);
global_string_param_free(&conf->forced_inform_json_file);
if (value != NULL) {
conf->forced_inform_json_file = strdup(value);
global_string_param_write(&conf->forced_inform_json_file, value);
FREE(value);
} else {
conf->forced_inform_json_file = NULL;
global_string_param_write(&conf->forced_inform_json_file, NULL);
}
}
if (uci_get_value(UCI_CPE_BOOT_INFORM_JSON, &value) == CWMP_OK) {
FREE(conf->boot_inform_json_file);
global_string_param_free(&conf->boot_inform_json_file);
if (value != NULL) {
conf->boot_inform_json_file = strdup(value);
global_string_param_write(&conf->boot_inform_json_file, value);
FREE(value);
} else {
conf->boot_inform_json_file = NULL;
global_string_param_write(&conf->boot_inform_json_file, NULL);
}
}
if (uci_get_value(UCI_CPE_JSON_CUSTOM_NOTIFY_FILE, &value) == CWMP_OK) {
FREE(conf->custom_notify_json);
global_string_param_free(&conf->custom_notify_json);
if (value != NULL) {
conf->custom_notify_json = strdup(value);
global_string_param_write(&conf->custom_notify_json, value);
FREE(value);
} else {
conf->custom_notify_json = NULL;
global_string_param_write(&conf->custom_notify_json, NULL);
}
}
if ((error = uci_get_value(UCI_ACS_HEARTBEAT_ENABLE, &value)) == CWMP_OK) {
conf->heart_beat_enable = uci_str_to_bool(value);
global_bool_param_write(&conf->heart_beat_enable, uci_str_to_bool(value));
FREE(value);
} else {
return error;
@ -546,17 +569,17 @@ int get_global_config(struct config *conf)
a = atoi(value);
FREE(value);
}
conf->heartbeat_interval = a;
global_int_param_write(&conf->heartbeat_interval, a);
} else {
return error;
}
if ((error = uci_get_value(UCI_ACS_HEARTBEAT_TIME, &value)) == CWMP_OK) {
if (value != NULL) {
conf->heart_time = convert_datetime_to_timestamp(value);
global_time_param_write(&conf->heart_time, convert_datetime_to_timestamp(value));
FREE(value);
} else {
conf->heart_time = 0;
global_time_param_write(&conf->heart_time, 0);
}
} else {
return error;
@ -568,8 +591,6 @@ int global_conf_init(struct cwmp *cwmp)
{
int error = CWMP_OK;
pthread_mutex_lock(&mutex_config_load);
if ((error = get_global_config(&(cwmp->conf)))) {
cwmp->init_complete = false;
goto end;
@ -580,8 +601,6 @@ int global_conf_init(struct cwmp *cwmp)
launch_reboot_methods(cwmp);
end:
pthread_mutex_unlock(&mutex_config_load);
return error;
}

86
cwmp.c
View file

@ -165,8 +165,8 @@ int cwmp_get_retry_interval(struct cwmp *cwmp, bool heart_beat)
unsigned int retry_count = 0;
double min = 0;
double max = 0;
int m = cwmp->conf.retry_min_wait_interval;
int k = cwmp->conf.retry_interval_multiplier;
int m = global_int_param_read(&cwmp->conf.retry_min_wait_interval);
int k = global_int_param_read(&cwmp->conf.retry_interval_multiplier);
int exp;
if (heart_beat)
exp = heart_beat_retry_count_session;
@ -597,21 +597,28 @@ static void check_exit_timer_expiry(struct uloop_timeout *timeout)
static void *thread_uloop_run(void *v __attribute__((unused)))
{
char *temp = NULL;
uloop_init();
if (netlink_init()) {
CWMP_LOG(ERROR, "netlink initialization failed");
}
if (cwmp_main.conf.ipv6_enable) {
bool v6_enable = global_bool_param_read(&cwmp_main.conf.ipv6_enable);
if (v6_enable) {
if (netlink_init_v6()) {
CWMP_LOG(ERROR, "netlink initialization failed");
}
}
ctx = ubus_connect(cwmp_main.conf.ubus_socket);
if (!ctx)
global_string_param_read(&cwmp_main.conf.ubus_socket, &temp);
ctx = ubus_connect(temp);
if (!ctx) {
FREE(temp);
return NULL;
}
FREE(temp);
ubus_add_uloop(ctx);
@ -641,24 +648,33 @@ void load_forced_inform_json_file(struct cwmp *cwmp)
struct blob_attr *cur;
struct blob_attr *custom_forced_inform_list = NULL;
int rem;
char *temp = NULL;
if (cwmp->conf.forced_inform_json_file == NULL || !file_exists(cwmp->conf.forced_inform_json_file))
global_string_param_read(&cwmp->conf.forced_inform_json_file, &temp);
if (CWMP_STRLEN(temp) == 0 || !file_exists(temp)) {
FREE(temp);
return;
}
memset(&bbuf, 0, sizeof(struct blob_buf));
blob_buf_init(&bbuf, 0);
if (blobmsg_add_json_from_file(&bbuf, cwmp->conf.forced_inform_json_file) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", cwmp->conf.forced_inform_json_file);
if (blobmsg_add_json_from_file(&bbuf, temp) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", temp);
blob_buf_free(&bbuf);
FREE(temp);
return;
}
FREE(temp);
const struct blobmsg_policy p[1] = { { "forced_inform", BLOBMSG_TYPE_ARRAY } };
struct blob_attr *tb[1] = { NULL };
blobmsg_parse(p, 1, tb, blobmsg_data(bbuf.head), blobmsg_len(bbuf.head));
if (tb[0] == NULL) {
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a forced inform parameters list", cwmp->conf.custom_notify_json);
global_string_param_read(&cwmp->conf.custom_notify_json, &temp);
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a forced inform parameters list", temp);
blob_buf_free(&bbuf);
FREE(temp);
return;
}
@ -682,7 +698,6 @@ void load_forced_inform_json_file(struct cwmp *cwmp)
FREE(val);
}
blob_buf_free(&bbuf);
}
void load_boot_inform_json_file(struct cwmp *cwmp)
@ -691,26 +706,34 @@ void load_boot_inform_json_file(struct cwmp *cwmp)
struct blob_attr *cur;
struct blob_attr *custom_boot_inform_list = NULL;
int rem;
char *temp = NULL;
if (cwmp->conf.boot_inform_json_file == NULL || !file_exists(cwmp->conf.boot_inform_json_file))
global_string_param_read(&cwmp->conf.boot_inform_json_file, &temp);
if (CWMP_STRLEN(temp) == 0 || !file_exists(temp)) {
FREE(temp);
return;
}
memset(&bbuf, 0, sizeof(struct blob_buf));
blob_buf_init(&bbuf, 0);
if (blobmsg_add_json_from_file(&bbuf, cwmp->conf.boot_inform_json_file) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", cwmp->conf.boot_inform_json_file);
if (blobmsg_add_json_from_file(&bbuf, temp) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", temp);
blob_buf_free(&bbuf);
FREE(temp);
return;
}
FREE(temp);
const struct blobmsg_policy p[1] = { { "boot_inform", BLOBMSG_TYPE_ARRAY } };
struct blob_attr *tb[1] = { NULL };
blobmsg_parse(p, 1, tb, blobmsg_data(bbuf.head), blobmsg_len(bbuf.head));
if (tb[0] == NULL) {
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a boot inform parameters list", cwmp->conf.custom_notify_json);
global_string_param_read(&cwmp->conf.custom_notify_json, &temp);
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a boot inform parameters list", temp);
blob_buf_free(&bbuf);
FREE(temp);
return;
}
@ -915,21 +938,21 @@ static void cwmp_free(struct cwmp *cwmp)
FREE(cwmp->deviceid.productclass);
FREE(cwmp->deviceid.oui);
FREE(cwmp->deviceid.softwareversion);
FREE(cwmp->conf.lw_notification_hostname);
FREE(cwmp->conf.ip);
FREE(cwmp->conf.ipv6);
FREE(cwmp->conf.acsurl);
FREE(cwmp->conf.acs_userid);
FREE(cwmp->conf.acs_passwd);
FREE(cwmp->conf.interface);
FREE(cwmp->conf.cpe_userid);
FREE(cwmp->conf.cpe_passwd);
FREE(cwmp->conf.ubus_socket);
FREE(cwmp->conf.connection_request_path);
FREE(cwmp->conf.default_wan_iface);
FREE(cwmp->conf.forced_inform_json_file);
FREE(cwmp->conf.custom_notify_json);
FREE(cwmp->conf.boot_inform_json_file);
global_string_param_free(&cwmp->conf.lw_notification_hostname);
global_string_param_free(&cwmp->conf.ip);
global_string_param_free(&cwmp->conf.ipv6);
global_string_param_free(&cwmp->conf.acsurl);
global_string_param_free(&cwmp->conf.acs_userid);
global_string_param_free(&cwmp->conf.acs_passwd);
global_string_param_free(&cwmp->conf.interface);
global_string_param_free(&cwmp->conf.cpe_userid);
global_string_param_free(&cwmp->conf.cpe_passwd);
global_string_param_free(&cwmp->conf.ubus_socket);
global_string_param_free(&cwmp->conf.connection_request_path);
global_string_param_free(&cwmp->conf.default_wan_iface);
global_string_param_free(&cwmp->conf.forced_inform_json_file);
global_string_param_free(&cwmp->conf.custom_notify_json);
global_string_param_free(&cwmp->conf.boot_inform_json_file);
FREE(nonce_key);
clean_list_param_notify();
bkp_tree_clean();
@ -979,8 +1002,11 @@ static void configure_var_state(struct cwmp *cwmp)
cwmp_uci_add_section_with_specific_name("cwmp", "acs", "acs", UCI_VARSTATE_CONFIG);
cwmp_uci_add_section_with_specific_name("cwmp", "cpe", "cpe", UCI_VARSTATE_CONFIG);
get_firewall_zone_name_by_wan_iface(cwmp->conf.default_wan_iface, &zone_name);
char *def_wan_intf = NULL;
global_string_param_read(&cwmp->conf.default_wan_iface, &def_wan_intf);
get_firewall_zone_name_by_wan_iface(def_wan_intf, &zone_name);
cwmp_uci_set_varstate_value("cwmp", "acs", "zonename", zone_name ? zone_name : "wan");
FREE(def_wan_intf);
}
int main(int argc, char **argv)

18
datamodel_interface.c
View file

@ -363,7 +363,8 @@ char *cwmp_get_single_parameter_value(char *parameter_name, struct cwmp_dm_param
blob_buf_init(&b, 0);
bb_add_string(&b, "path", !parameter_name || parameter_name[0] == '\0' ? DM_ROOT_OBJ : parameter_name);
bb_add_string(&b, "proto", "cwmp");
blobmsg_add_u32(&b, "instance_mode", cwmp->conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp->conf.instance_mode);
blobmsg_add_u32(&b, "instance_mode", mode);
e = icwmp_ubus_invoke(USP_OBJECT_NAME, "get", b.head, ubus_get_single_parameter_callback, dm_parameter);
blob_buf_free(&b);
@ -457,7 +458,8 @@ char *cwmp_get_parameter_values(char *parameter_name, struct list_head *paramete
blob_buf_init(&b, 0);
bb_add_string(&b, "path", param);
bb_add_string(&b, "proto", "cwmp");
blobmsg_add_u32(&b, "instance_mode", cwmp->conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp->conf.instance_mode);
blobmsg_add_u32(&b, "instance_mode", mode);
e = icwmp_ubus_invoke(USP_OBJECT_NAME, "get", b.head, ubus_get_parameter_callback, &get_result);
blob_buf_free(&b);
@ -491,7 +493,8 @@ char *cwmp_get_multiple_parameters_values(struct list_head *arg_params_list, str
blobmsg_add_string(&b, NULL, param_value->name);
}
blobmsg_close_array(&b, arr);
blobmsg_add_u32(&b, "instance_mode", cwmp->conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp->conf.instance_mode);
blobmsg_add_u32(&b, "instance_mode", mode);
e = icwmp_ubus_invoke(USP_OBJECT_NAME, "getm_values", b.head, ubus_get_parameter_callback, &get_result );
blob_buf_free(&b);
@ -521,7 +524,8 @@ char *cwmp_get_parameter_names(char *object_name, bool next_level, struct list_h
bb_add_string(&b, "path", object);
blobmsg_add_u8(&b, "next-level", next_level);
bb_add_string(&b, "proto", "cwmp");
blobmsg_add_u32(&b, "instance_mode", cwmp->conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp->conf.instance_mode);
blobmsg_add_u32(&b, "instance_mode", mode);
e = icwmp_ubus_invoke(USP_OBJECT_NAME, "object_names", b.head, ubus_get_parameter_callback, &get_result);
blob_buf_free(&b);
@ -603,7 +607,8 @@ int cwmp_set_multiple_parameters_values(struct list_head *parameters_values_list
bb_add_string(&b, "key", parameter_key ? parameter_key : "");
blobmsg_add_u32(&b, "transaction_id", transaction_id);
bb_add_string(&b, "proto", "cwmp");
blobmsg_add_u32(&b, "instance_mode", cwmp->conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp->conf.instance_mode);
blobmsg_add_u32(&b, "instance_mode", mode);
e = icwmp_ubus_invoke(USP_OBJECT_NAME, "setm_values", b.head, ubus_setm_values_callback, &set_result);
blob_buf_free(&b);
@ -670,7 +675,8 @@ static void prepare_add_delete_blobmsg(struct blob_buf *b, char *object_name, ch
bb_add_string(b, "key", key ? key : "");
blobmsg_add_u32(b, "transaction_id", transaction_id);
bb_add_string(b, "proto", "cwmp");
blobmsg_add_u32(b, "instance_mode", cwmp_main.conf.instance_mode);
unsigned int mode = global_uint_param_read(&cwmp_main.conf.instance_mode);
blobmsg_add_u32(b, "instance_mode", mode);
}
char *cwmp_add_object(char *object_name, char *key, char **instance)

38
event.c
View file

@ -185,7 +185,9 @@ int cwmp_root_cause_event_bootstrap(struct cwmp *cwmp)
if (acsurl == NULL)
save_acs_bkp_config(cwmp);
if (acsurl == NULL || ((cmp = CWMP_STRCMP(cwmp->conf.acsurl, acsurl)) != 0)) {
char *conf_url = NULL;
global_string_param_read(&cwmp->conf.acsurl, &conf_url);
if (acsurl == NULL || ((cmp = CWMP_STRCMP(conf_url, acsurl)) != 0)) {
pthread_mutex_lock(&(cwmp->mutex_session_queue));
if (cwmp->head_event_container != NULL && cwmp->head_session_queue.next != &(cwmp->head_session_queue)) {
struct session *session;
@ -209,6 +211,7 @@ int cwmp_root_cause_event_bootstrap(struct cwmp *cwmp)
} else {
FREE(acsurl);
}
FREE(conf_url);
if (cmp) {
pthread_mutex_lock(&(cwmp->mutex_session_queue));
@ -329,7 +332,7 @@ int cwmp_root_cause_get_rpc_method(struct cwmp *cwmp)
}
cwmp_save_event_container(event_container);
session = list_entry(cwmp->head_event_container, struct session, head_event_container);
if (cwmp->conf.acs_getrpc && cwmp_add_session_rpc_acs(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
if (global_bool_param_read(&cwmp->conf.acs_getrpc) && cwmp_add_session_rpc_acs(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
pthread_mutex_unlock(&(cwmp->mutex_session_queue));
return CWMP_MEM_ERR;
}
@ -351,18 +354,19 @@ void *thread_event_periodic(void *v)
long int delta_time;
time_t unknown_time;
periodic_interval = cwmp->conf.period;
periodic_enable = cwmp->conf.periodic_enable;
periodic_time = cwmp->conf.time;
periodic_interval = global_int_param_read(&cwmp->conf.period);
periodic_enable = global_bool_param_read(&cwmp->conf.periodic_enable);
periodic_time = global_time_param_read(&cwmp->conf.time);
unknown_time = convert_datetime_to_timestamp("0001-01-01T00:00:00Z");
for (;;) {
pthread_mutex_lock(&(cwmp->mutex_periodic));
if (cwmp->conf.periodic_enable) {
if (periodic_enable) {
current_time = time(NULL);
if (periodic_time != 0) {
if (periodic_time == unknown_time) {
delta_time = (current_time + cwmp->conf.periodic_entropy) % periodic_interval;
unsigned int periodic_entropy = global_uint_param_read(&cwmp->conf.periodic_entropy);
delta_time = (current_time + periodic_entropy) % periodic_interval;
} else {
delta_time = (current_time - periodic_time) % periodic_interval;
}
@ -385,10 +389,10 @@ void *thread_event_periodic(void *v)
if (thread_end)
break;
if (periodic_interval != cwmp->conf.period || periodic_enable != cwmp->conf.periodic_enable || periodic_time != cwmp->conf.time) {
periodic_enable = cwmp->conf.periodic_enable;
periodic_interval = cwmp->conf.period;
periodic_time = cwmp->conf.time;
if (periodic_interval != global_int_param_read(&cwmp->conf.period) || periodic_enable != global_bool_param_read(&cwmp->conf.periodic_enable) || periodic_time != global_time_param_read(&cwmp->conf.time)) {
periodic_enable = global_bool_param_read(&cwmp->conf.periodic_enable);
periodic_interval = global_int_param_read(&cwmp->conf.period);
periodic_time = global_time_param_read(&cwmp->conf.time);
continue;
}
CWMP_LOG(INFO, "Periodic thread: add periodic event in the queue");
@ -420,13 +424,13 @@ int cwmp_root_cause_event_periodic(struct cwmp *cwmp)
char local_time[27] = { 0 };
struct tm *t_tm;
if (cwmp->cwmp_period == cwmp->conf.period && cwmp->cwmp_periodic_enable == cwmp->conf.periodic_enable && cwmp->cwmp_periodic_time == cwmp->conf.time)
if (cwmp->cwmp_period == global_int_param_read(&cwmp->conf.period) && cwmp->cwmp_periodic_enable == global_bool_param_read(&cwmp->conf.periodic_enable) && cwmp->cwmp_periodic_time == global_time_param_read(&cwmp->conf.time))
return CWMP_OK;
pthread_mutex_lock(&(cwmp->mutex_periodic));
cwmp->cwmp_period = cwmp->conf.period;
cwmp->cwmp_periodic_enable = cwmp->conf.periodic_enable;
cwmp->cwmp_periodic_time = cwmp->conf.time;
cwmp->cwmp_period = global_int_param_read(&cwmp->conf.period);
cwmp->cwmp_periodic_enable = global_bool_param_read(&cwmp->conf.periodic_enable);
cwmp->cwmp_periodic_time = global_time_param_read(&cwmp->conf.time);
CWMP_LOG(INFO, cwmp->cwmp_periodic_enable ? "Periodic event is enabled. Interval period = %ds" : "Periodic event is disabled", cwmp->cwmp_period);
t_tm = localtime(&cwmp->cwmp_periodic_time);
@ -451,7 +455,8 @@ void connection_request_ip_value_change(struct cwmp *cwmp, int version)
{
char *bip = NULL;
char *ip_version = (version == IPv6) ? "ipv6" : "ip";
char *ip_value = (version == IPv6) ? cwmp->conf.ipv6 : cwmp->conf.ip;
char *ip_value = NULL;
(version == IPv6) ? global_string_param_read(&cwmp->conf.ipv6, &ip_value) : global_string_param_read(&cwmp->conf.ip, &ip_value);
if (version == IPv6)
cwmp_load_saved_session(cwmp, &bip, CR_IPv6);
@ -481,6 +486,7 @@ void connection_request_ip_value_change(struct cwmp *cwmp, int version)
pthread_cond_signal(&(cwmp->threshold_session_send));
}
FREE(bip);
FREE(ip_value);
}
void connection_request_port_value_change(struct cwmp *cwmp, int port)

10
heartbeat.c
View file

@ -22,7 +22,8 @@ static struct session_status heart_beat_session_status = {0};
void check_trigger_heartbeat_session()
{
if (cwmp_main.conf.heart_beat_enable && !old_heartbeat_enable)
bool enable = global_bool_param_read(&cwmp_main.conf.heart_beat_enable);
if (enable && !old_heartbeat_enable)
pthread_cond_signal(&threshold_heartbeat_session);
}
@ -55,8 +56,9 @@ void *thread_heartbeat_session(void *v __attribute__((unused)))
if (thread_end)
break;
if (cwmp_main.conf.heart_beat_enable) {
heartbeat_interval.tv_sec = time(NULL) + cwmp_main.conf.heartbeat_interval;
bool enable = global_bool_param_read(&cwmp_main.conf.heart_beat_enable);
if (enable) {
heartbeat_interval.tv_sec = time(NULL) + global_int_param_read(&cwmp_main.conf.heartbeat_interval);
pthread_mutex_lock(&mutex_heartbeat);
pthread_cond_timedwait(&threshold_heartbeat_session, &mutex_heartbeat, &heartbeat_interval);
if (thread_end)
@ -151,7 +153,7 @@ void *thread_heartbeat_session(void *v __attribute__((unused)))
heart_beat_session_status.last_status = SESSION_SUCCESS;
heart_beat_session_status.next_retry = 0;
heart_beat_session_status.success_session++;
heartbeat_interval.tv_sec = time(NULL) + cwmp_main.conf.heartbeat_interval;
heartbeat_interval.tv_sec = time(NULL) + global_int_param_read(&cwmp_main.conf.heartbeat_interval);
pthread_mutex_unlock(&mutex_heartbeat_session);
pthread_mutex_unlock(&mutex_heartbeat);
} else {

57
http.c
View file

@ -45,6 +45,8 @@ int http_client_init(struct cwmp *cwmp)
char *acs_var_stat = NULL;
uci_get_value(UCI_DHCP_DISCOVERY_PATH, &dhcp_dis);
char *url = NULL;
global_string_param_read(&cwmp->conf.acsurl, &url);
if (dhcp_dis && cwmp->retry_count_session > 0 && strcmp(dhcp_dis, "enable") == 0) {
uci_get_state_value(UCI_DHCP_ACS_URL, &acs_var_stat);
@ -52,20 +54,24 @@ int http_client_init(struct cwmp *cwmp)
if (icwmp_asprintf(&http_c.url, "%s", acs_var_stat) == -1) {
free(acs_var_stat);
FREE(dhcp_dis);
FREE(url);
return -1;
}
} else {
if (cwmp->conf.acsurl == NULL || icwmp_asprintf(&http_c.url, "%s", cwmp->conf.acsurl) == -1) {
if (CWMP_STRLEN(url) == 0 || icwmp_asprintf(&http_c.url, "%s", url) == -1) {
FREE(dhcp_dis);
FREE(url);
return -1;
}
}
} else {
if (cwmp->conf.acsurl == NULL || icwmp_asprintf(&http_c.url, "%s", cwmp->conf.acsurl) == -1) {
if (url == NULL || icwmp_asprintf(&http_c.url, "%s", url) == -1) {
FREE(dhcp_dis);
FREE(url);
return -1;
}
}
FREE(url);
if (dhcp_dis)
free(dhcp_dis);
@ -79,7 +85,8 @@ int http_client_init(struct cwmp *cwmp)
if (!curl)
return -1;
if (cwmp->conf.ipv6_enable) {
bool v6_enable = global_bool_param_read(&cwmp->conf.ipv6_enable);
if (v6_enable) {
unsigned char buf[sizeof(struct in6_addr)];
char *ip = NULL;
@ -146,7 +153,7 @@ int http_send_message(struct cwmp *cwmp, char *msg_out, int msg_out_len, char **
CURLcode res;
long http_code = 0;
static char ip_acs[128] = { 0 };
char *ip = NULL;
char *ip = NULL, *temp = NULL;
char errbuf[CURL_ERROR_SIZE];
http_c.header_list = NULL;
@ -157,21 +164,25 @@ int http_send_message(struct cwmp *cwmp, char *msg_out, int msg_out_len, char **
if (!http_c.header_list)
return -1;
if (cwmp->conf.http_disable_100continue) {
if (global_bool_param_read(&cwmp->conf.http_disable_100continue)) {
http_c.header_list = curl_slist_append(http_c.header_list, "Expect:");
if (!http_c.header_list)
return -1;
}
curl_easy_setopt(curl, CURLOPT_URL, http_c.url);
curl_easy_setopt(curl, CURLOPT_USERNAME, cwmp->conf.acs_userid);
curl_easy_setopt(curl, CURLOPT_PASSWORD, cwmp->conf.acs_passwd);
global_string_param_read(&cwmp->conf.acs_userid, &temp);
curl_easy_setopt(curl, CURLOPT_USERNAME, temp);
FREE(temp);
global_string_param_read(&cwmp->conf.acs_passwd, &temp);
curl_easy_setopt(curl, CURLOPT_PASSWORD, temp);
FREE(temp);
curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC | CURLAUTH_DIGEST);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, HTTP_TIMEOUT);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, HTTP_TIMEOUT);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
switch (cwmp->conf.compression) {
switch (global_int_param_read(&cwmp->conf.compression)) {
case COMP_NONE:
break;
case COMP_GZIP:
@ -201,14 +212,18 @@ int http_send_message(struct cwmp *cwmp, char *msg_out, int msg_out_len, char **
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, fc_cookies);
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, fc_cookies);
if (cwmp->conf.acs_ssl_capath)
curl_easy_setopt(curl, CURLOPT_CAPATH, cwmp->conf.acs_ssl_capath);
if (cwmp->conf.insecure_enable) {
global_string_param_read(&cwmp->conf.acs_ssl_capath, &temp);
if (CWMP_STRLEN(temp) != 0)
curl_easy_setopt(curl, CURLOPT_CAPATH, temp);
if (global_bool_param_read(&cwmp->conf.insecure_enable)) {
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
}
FREE(temp);
curl_easy_setopt(curl, CURLOPT_INTERFACE, cwmp->conf.interface);
global_string_param_read(&cwmp->conf.interface, &temp);
curl_easy_setopt(curl, CURLOPT_INTERFACE, temp);
FREE(temp);
*msg_in = (char *)calloc(1, sizeof(char));
res = curl_easy_perform(curl);
@ -255,7 +270,7 @@ int http_send_message(struct cwmp *cwmp, char *msg_out, int msg_out_len, char **
}
if (http_code == 415) {
cwmp->conf.compression = COMP_NONE;
global_int_param_write(&cwmp->conf.compression, COMP_NONE);
goto error;
}
if (http_code != 200 && http_code != 204)
@ -301,6 +316,7 @@ static void http_cr_new_client(int client, bool service_available)
bool method_is_get = false;
bool internal_error = false;
char cr_http_get_head[HTTP_GET_HDR_LEN] = {0};
char *temp = NULL;
fp = fdopen(client, "r+");
if (fp == NULL) {
@ -308,8 +324,10 @@ static void http_cr_new_client(int client, bool service_available)
service_available = false;
goto http_end;
}
char *username = cwmp_main.conf.cpe_userid;
char *password = cwmp_main.conf.cpe_passwd;
char *username = NULL;
global_string_param_read(&cwmp_main.conf.cpe_userid, &username);
char *password = NULL;
global_string_param_read(&cwmp_main.conf.cpe_passwd, &password);
memset(auth_digest_buffer, 0, BUFSIZ);
if (!username || !password) {
@ -318,7 +336,10 @@ static void http_cr_new_client(int client, bool service_available)
service_available = false;
goto http_end;
}
snprintf(cr_http_get_head, sizeof(cr_http_get_head), "GET %s HTTP/1.1", cwmp_main.conf.connection_request_path);
global_string_param_read(&cwmp_main.conf.connection_request_path, &temp);
snprintf(cr_http_get_head, sizeof(cr_http_get_head), "GET %s HTTP/1.1", temp);
FREE(temp);
while (fgets(buffer, sizeof(buffer), fp)) {
if (buffer[0] == '\r' || buffer[0] == '\n') {
/* end of http request (empty line) */
@ -369,6 +390,8 @@ static void http_cr_new_client(int client, bool service_available)
else
auth_status = 0;
http_end:
FREE(username);
FREE(password);
if (!service_available || !method_is_get) {
CWMP_LOG(INFO, "Receive Connection Request: Return 503 Service Unavailable");
if (fp) {
@ -413,7 +436,7 @@ void http_server_init(void)
unsigned short cr_port;
for (;;) {
cr_port = (unsigned short)(cwmp_main.conf.connection_request_port);
cr_port = (unsigned short)global_int_param_read(&cwmp_main.conf.connection_request_port);
unsigned short i = (DEFAULT_CONNECTION_REQUEST_PORT == cr_port) ? 1 : 0;
//Create socket
cwmp_main.cr_socket_desc = socket(AF_INET6, SOCK_STREAM, 0);

11
inc/common.h
View file

@ -547,5 +547,16 @@ int cwmp_schedule_rpc(struct cwmp *cwmp, struct session *session);
int run_session_end_func(void);
void set_interface_reset_request(char *param_name, char *value);
bool uci_str_to_bool(char *value);
bool global_bool_param_read(const bool *param);
void global_string_param_read(char **param, char **val);
int global_int_param_read(const int *param);
time_t global_time_param_read(const time_t *param);
unsigned int global_uint_param_read(const unsigned int *param);
void global_bool_param_write(bool *param, bool value);
void global_string_param_write(char **param, char *value);
void global_int_param_write(int *param, int value);
void global_time_param_write(time_t *param, time_t value);
void global_uint_param_write(unsigned int *param, unsigned int value);
void global_string_param_free(char **param);
#endif

2
inc/config.h
View file

@ -15,8 +15,6 @@
#include "cwmp_uci.h"
extern pthread_mutex_t mutex_config_load;
int global_conf_init(struct cwmp *cwmp);
int get_global_config(struct config *conf);
int cwmp_get_deviceid(struct cwmp *cwmp);

24
netlink.c
View file

@ -111,16 +111,20 @@ static void freecwmp_netlink_interface(struct nlmsghdr *nlh)
}
if_indextoname(ifa->ifa_index, if_name);
if (itfcmp(cwmp_main.conf.interface, if_name)) {
char *intf = NULL;
global_string_param_read(&cwmp_main.conf.interface, &intf);
if (itfcmp(intf, if_name)) {
rth = RTA_NEXT(rth, rtl);
FREE(intf);
continue;
}
FREE(intf);
inet_ntop(AF_INET, &(addr), if_addr, INET_ADDRSTRLEN);
FREE(cwmp_main.conf.ip);
cwmp_main.conf.ip = strdup(if_addr);
cwmp_uci_set_varstate_value("cwmp", "cpe", "ip", cwmp_main.conf.ip);
global_string_param_free(&cwmp_main.conf.ip);
global_string_param_write(&cwmp_main.conf.ip, if_addr);
cwmp_uci_set_varstate_value("cwmp", "cpe", "ip", if_addr);
connection_request_ip_value_change(&cwmp_main, IPv4);
break;
}
@ -133,14 +137,18 @@ static void freecwmp_netlink_interface(struct nlmsghdr *nlh)
}
inet_ntop(AF_INET6, RTA_DATA(rth), pradd_v6, sizeof(pradd_v6));
if_indextoname(ifa->ifa_index, if_name);
if (strncmp(cwmp_main.conf.interface, if_name, IFNAMSIZ)) {
char *intf = NULL;
global_string_param_read(&cwmp_main.conf.interface, &intf);
if (strncmp(intf, if_name, IFNAMSIZ)) {
rth = RTA_NEXT(rth, rtl);
FREE(intf);
continue;
}
FREE(intf);
FREE(cwmp_main.conf.ipv6);
cwmp_main.conf.ipv6 = strdup(pradd_v6);
cwmp_uci_set_varstate_value("cwmp", "cpe", "ipv6", cwmp_main.conf.ip);
global_string_param_free(&cwmp_main.conf.ipv6);
global_string_param_write(&cwmp_main.conf.ipv6, pradd_v6);
cwmp_uci_set_varstate_value("cwmp", "cpe", "ipv6", pradd_v6);
connection_request_ip_value_change(&cwmp_main, IPv6);
break;
}

36
notifications.c
View file

@ -476,21 +476,28 @@ void load_custom_notify_json(struct cwmp *cwmp)
int rem;
cwmp->custom_notify_active = false;
if (cwmp->conf.custom_notify_json == NULL || !file_exists(cwmp->conf.custom_notify_json))
char *cust_notify_json = NULL;
global_string_param_read(&cwmp->conf.custom_notify_json, &cust_notify_json);
if (CWMP_STRLEN(cust_notify_json) == 0 || !file_exists(cust_notify_json)) {
FREE(cust_notify_json);
return;
}
// Check for custom notification success import marker
if (file_exists(NOTIFY_MARKER) == true)
if (file_exists(NOTIFY_MARKER) == true) {
FREE(cust_notify_json);
return;
}
memset(&bbuf, 0, sizeof(struct blob_buf));
blob_buf_init(&bbuf, 0);
// Create success marker in temp area, so that it can be in sync with backup script
if (blobmsg_add_json_from_file(&bbuf, cwmp->conf.custom_notify_json) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", cwmp->conf.custom_notify_json);
if (blobmsg_add_json_from_file(&bbuf, cust_notify_json) == false) {
CWMP_LOG(WARNING, "The file %s is not a valid JSON file", cust_notify_json);
blob_buf_free(&bbuf);
creat(RUN_NOTIFY_MARKER, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
FREE(cust_notify_json);
return;
}
@ -498,11 +505,13 @@ void load_custom_notify_json(struct cwmp *cwmp)
struct blob_attr *tb_notif[1] = { NULL};
blobmsg_parse(p_notif, 1, tb_notif, blobmsg_data(bbuf.head), blobmsg_len(bbuf.head));
if (tb_notif[0] == NULL) {
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a notify parameters list", cwmp->conf.custom_notify_json);
CWMP_LOG(WARNING, "The JSON file %s doesn't contain a notify parameters list", cust_notify_json);
blob_buf_free(&bbuf);
creat(RUN_NOTIFY_MARKER, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
FREE(cust_notify_json);
return;
}
FREE(cust_notify_json);
custom_notify_list = tb_notif[0];
const struct blobmsg_policy p[2] = { { "parameter", BLOBMSG_TYPE_STRING }, { "notify_type", BLOBMSG_TYPE_STRING } };
@ -674,8 +683,8 @@ void *thread_periodic_check_notify(void *v)
time_t current_time;
int is_notify;
periodic_interval = cwmp->conf.periodic_notify_interval;
periodic_enable = cwmp->conf.periodic_notify_enable;
periodic_interval = global_int_param_read(&cwmp->conf.periodic_notify_interval);
periodic_enable = global_bool_param_read(&cwmp->conf.periodic_notify_enable);
for (;;) {
if (periodic_enable) {
@ -752,8 +761,11 @@ static void udplw_server_param(struct addrinfo **res)
conf = &(cwmp->conf);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
snprintf(port, sizeof(port), "%d", conf->lw_notification_port);
getaddrinfo(conf->lw_notification_hostname, port, &hints, res);
snprintf(port, sizeof(port), "%d", global_int_param_read(&conf->lw_notification_port));
char *hostname = NULL;
global_string_param_read(&conf->lw_notification_hostname, &hostname);
getaddrinfo(hostname, port, &hints, res);
FREE(hostname);
}
char *calculate_lwnotification_cnonce()
@ -823,8 +835,10 @@ void cwmp_lwnotification()
return;
}
message_compute_signature(msg_out, signature, sizeof(signature));
snprintf(msg, sizeof(msg), "%s \n %s: %s \n %s: %s \n %s: %zu\n %s: %s\n\n%s", "POST /HTTPS/1.1", "HOST", conf->lw_notification_hostname, "Content-Type", "test/xml; charset=utf-8", "Content-Lenght", strlen(msg_out), "Signature", signature, msg_out);
char *hostname = NULL;
global_string_param_read(&conf->lw_notification_hostname, &hostname);
snprintf(msg, sizeof(msg), "%s \n %s: %s \n %s: %s \n %s: %zu\n %s: %s\n\n%s", "POST /HTTPS/1.1", "HOST", hostname, "Content-Type", "test/xml; charset=utf-8", "Content-Lenght", strlen(msg_out), "Signature", signature, msg_out);
FREE(hostname);
send_udp_message(servaddr, msg);
free_all_list_lw_notify();
//freeaddrinfo(servaddr); //To check

17
reboot.c
View file

@ -23,8 +23,9 @@ static void *thread_delay_reboot(void *arg)
{
struct cwmp *cwmp = (struct cwmp *)arg;
CWMP_LOG(INFO, "The device will reboot after %d seconds", cwmp->conf.delay_reboot);
sleep(cwmp->conf.delay_reboot);
int delay_reboot = global_int_param_read(&cwmp->conf.delay_reboot);
CWMP_LOG(INFO, "The device will reboot after %d seconds", delay_reboot);
sleep(delay_reboot);
cwmp_uci_set_value("cwmp", "cpe", "delay_reboot", "-1");
/* check if the session is running before calling reboot method */
/* if the session is in progress, wait until the end of the session */
@ -62,7 +63,7 @@ static void create_delay_reboot_thread(struct cwmp *cwmp, bool thread_exist)
static void *thread_schedule_reboot(void *arg)
{
struct cwmp *cwmp = (struct cwmp *)arg;
time_t remaining_time = cwmp->conf.schedule_reboot - time(NULL);
time_t remaining_time = global_time_param_read(&cwmp->conf.schedule_reboot) - time(NULL);
CWMP_LOG(INFO, "The device will reboot after %ld seconds", remaining_time);
sleep(remaining_time);
@ -103,16 +104,18 @@ static void create_schedule_reboot_thread(struct cwmp *cwmp, bool thread_exist)
void launch_reboot_methods(struct cwmp *cwmp)
{
int delay_reboot = global_int_param_read(&cwmp->conf.delay_reboot);
time_t schedule_reboot = global_time_param_read(&cwmp->conf.schedule_reboot);
if (cwmp->conf.delay_reboot != g_curr_delay_reboot && cwmp->conf.delay_reboot > 0) {
if (delay_reboot != g_curr_delay_reboot && delay_reboot > 0) {
create_delay_reboot_thread(cwmp, (g_curr_delay_reboot != -1));
g_curr_delay_reboot = cwmp->conf.delay_reboot;
g_curr_delay_reboot = delay_reboot;
}
if (cwmp->conf.schedule_reboot != g_curr_schedule_redoot && (cwmp->conf.schedule_reboot - time(NULL)) > 0) {
if (schedule_reboot != g_curr_schedule_redoot && (schedule_reboot - time(NULL)) > 0) {
create_schedule_reboot_thread(cwmp, (g_curr_schedule_redoot != 0));
g_curr_schedule_redoot = cwmp->conf.schedule_reboot;
g_curr_schedule_redoot = schedule_reboot;
}
}

50
rpc_soap.c
View file

@ -131,7 +131,7 @@ int xml_handle_message(struct session *session)
CWMP_LOG(INFO, "SOAP RPC message: %s", c);
rpc_cpe = NULL;
for (i = 1; i < __RPC_CPE_MAX; i++) {
if (i != RPC_CPE_FAULT && c && strcmp(c, rpc_cpe_methods[i].name) == 0 && rpc_cpe_methods[i].amd <= conf->supported_amd_version) {
if (i != RPC_CPE_FAULT && c && strcmp(c, rpc_cpe_methods[i].name) == 0 && rpc_cpe_methods[i].amd <= global_int_param_read(&conf->supported_amd_version)) {
CWMP_LOG(INFO, "%s RPC is supported", c);
rpc_cpe = cwmp_add_session_rpc_cpe(session, i);
if (rpc_cpe == NULL)
@ -275,7 +275,8 @@ static void load_inform_xml_schema(mxml_node_t **tree, struct cwmp *cwmp, struct
mxmlElementSetAttr(envelope, "xmlns:soap_enc", "http://schemas.xmlsoap.org/soap/encoding/");
mxmlElementSetAttr(envelope, "xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
mxmlElementSetAttr(envelope, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
mxmlElementSetAttr(envelope, "xmlns:cwmp", cwmp_urls[(cwmp->conf.supported_amd_version) - 1]);
int amd_ver = global_int_param_read(&cwmp->conf.supported_amd_version);
mxmlElementSetAttr(envelope, "xmlns:cwmp", cwmp_urls[amd_ver - 1]);
mxml_node_t *header = mxmlNewElement(envelope, "soap_env:Header");
if (header == NULL) {
@ -292,7 +293,7 @@ static void load_inform_xml_schema(mxml_node_t **tree, struct cwmp *cwmp, struct
mxmlElementSetAttr(id, "soap_env:mustUnderstand", "1");
mxml_node_t *node = NULL;
if (cwmp->conf.supported_amd_version >= 4) {
if (amd_ver >= 4) {
node = mxmlNewElement(header, "cwmp:SessionTimeout");
if (!node) {
MXML_DELETE(xml);
@ -300,14 +301,15 @@ static void load_inform_xml_schema(mxml_node_t **tree, struct cwmp *cwmp, struct
}
mxmlElementSetAttr(node, "soap_env:mustUnderstand", "0");
node = mxmlNewInteger(node, cwmp->conf.session_timeout);
unsigned int sess_timeout = global_uint_param_read(&cwmp->conf.session_timeout);
node = mxmlNewInteger(node, sess_timeout);
if (!node) {
MXML_DELETE(xml);
return;
}
}
if (cwmp->conf.supported_amd_version >= 5) {
if (amd_ver >= 5) {
node = mxmlNewElement(header, "cwmp:SupportedCWMPVersions");
if (!node) {
MXML_DELETE(xml);
@ -315,7 +317,7 @@ static void load_inform_xml_schema(mxml_node_t **tree, struct cwmp *cwmp, struct
}
mxmlElementSetAttr(node, "soap_env:mustUnderstand", "0");
node = mxmlNewOpaque(node, xml_get_cwmp_version(cwmp->conf.supported_amd_version));
node = mxmlNewOpaque(node, xml_get_cwmp_version(amd_ver));
if (!node) {
MXML_DELETE(xml);
return;
@ -545,19 +547,21 @@ int cwmp_rpc_acs_parse_response_inform(struct cwmp *cwmp, struct session *sessio
b = mxmlWalkNext(b, tree, MXML_DESCEND_FIRST);
if (!b || mxmlGetType(b) != MXML_OPAQUE || !mxmlGetOpaque(b))
goto error;
if (cwmp->conf.supported_amd_version == 1) {
cwmp->conf.amd_version = 1;
int supported_amd_version = global_int_param_read(&cwmp->conf.supported_amd_version);
if (supported_amd_version == 1) {
global_int_param_write(&cwmp->conf.amd_version, 1);
return 0;
}
b = mxmlFindElement(tree, tree, "UseCWMPVersion", NULL, NULL, MXML_DESCEND);
if (b && cwmp->conf.supported_amd_version >= 5) { //IF supported version !=5 acs response dosen't contain UseCWMPVersion
if (b && supported_amd_version >= 5) { //IF supported version !=5 acs response dosen't contain UseCWMPVersion
b = mxmlWalkNext(b, tree, MXML_DESCEND_FIRST);
if (!b || mxmlGetType(b) != MXML_OPAQUE || !mxmlGetOpaque(b))
goto error;
c = (char *) mxmlGetOpaque(b);
if (c && *(c + 1) == '.') {
c += 2;
cwmp->conf.amd_version = atoi(c) + 1;
global_int_param_write(&cwmp->conf.amd_version, atoi(c) + 1);
return 0;
}
goto error;
@ -570,28 +574,28 @@ int cwmp_rpc_acs_parse_response_inform(struct cwmp *cwmp, struct session *sessio
}
}
if (i == 0) {
cwmp->conf.amd_version = i + 1;
global_int_param_write(&cwmp->conf.amd_version, i + 1);
} else if (i >= 1 && i <= 3) {
switch (cwmp->conf.supported_amd_version) {
switch (supported_amd_version) {
case 1:
cwmp->conf.amd_version = 1; //Already done
global_int_param_write(&cwmp->conf.amd_version, 1); //Already done
break;
case 2:
case 3:
case 4:
//MIN ACS CPE
if (cwmp->conf.supported_amd_version <= i + 1)
cwmp->conf.amd_version = cwmp->conf.supported_amd_version;
if (supported_amd_version <= i + 1)
global_int_param_write(&cwmp->conf.amd_version, supported_amd_version);
else
cwmp->conf.amd_version = i + 1;
global_int_param_write(&cwmp->conf.amd_version, i + 1);
break;
//(cwmp->supported_conf.amd_version < i+1) ?"cwmp->conf.amd_version":"i+1";
case 5:
cwmp->conf.amd_version = i + 1;
global_int_param_write(&cwmp->conf.amd_version, i + 1);
break;
}
} else if (i >= 4) {
cwmp->conf.amd_version = cwmp->conf.supported_amd_version;
global_int_param_write(&cwmp->conf.amd_version, supported_amd_version);
}
return 0;
@ -666,7 +670,9 @@ int cwmp_rpc_acs_prepare_get_rpc_methods(struct cwmp *cwmp, struct session *sess
n = mxmlFindElement(tree, tree, "soap_env:Envelope", NULL, NULL, MXML_DESCEND);
if (!n)
return -1;
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[(cwmp->conf.amd_version) - 1]);
int amd_version = global_int_param_read(&cwmp->conf.amd_version);
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[amd_version - 1]);
n = mxmlFindElement(tree, tree, "soap_env:Body", NULL, NULL, MXML_DESCEND);
if (!n)
return -1;
@ -697,7 +703,8 @@ int cwmp_rpc_acs_prepare_transfer_complete(struct cwmp *cwmp, struct session *se
n = mxmlFindElement(tree, tree, "soap_env:Envelope", NULL, NULL, MXML_DESCEND);
if (!n)
goto error;
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[(cwmp->conf.amd_version) - 1]);
int amd_version = global_int_param_read(&cwmp->conf.amd_version);
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[amd_version - 1]);
n = mxmlFindElement(tree, tree, "soap_env:Body", NULL, NULL, MXML_DESCEND);
if (!n)
@ -792,7 +799,8 @@ int cwmp_rpc_acs_prepare_du_state_change_complete(struct cwmp *cwmp, struct sess
if (!n)
goto error;
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[(cwmp->conf.amd_version) - 1]);
int amd_version = global_int_param_read(&cwmp->conf.amd_version);
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[amd_version - 1]);
n = mxmlFindElement(tree, tree, "soap_env:Body", NULL, NULL, MXML_DESCEND);
if (!n)
goto error;

9
session.c
View file

@ -55,7 +55,7 @@ int cwmp_apply_acs_changes(void)
{
int error;
old_heartbeat_enable = cwmp_main.conf.heart_beat_enable;
old_heartbeat_enable = global_bool_param_read(&cwmp_main.conf.heart_beat_enable);
if ((error = cwmp_config_reload(&cwmp_main)))
return error;
@ -112,7 +112,7 @@ struct session *cwmp_add_queue_session(struct cwmp *cwmp)
/*
* Set Required methods as initial value of
*/
if (cwmp->conf.acs_getrpc) {
if (global_bool_param_read(&cwmp->conf.acs_getrpc)) {
rpc_acs = cwmp_add_session_rpc_acs_head(session, RPC_ACS_GET_RPC_METHODS);
if (rpc_acs == NULL) {
FREE(session);
@ -167,6 +167,7 @@ int cwmp_move_session_to_session_queue(struct cwmp *cwmp, struct session *sessio
struct list_head *ilist, *jlist;
struct rpc *rpc_acs, *queue_rpc_acs;
struct session *session_queue;
bool acs_getrpc = global_bool_param_read(&cwmp->conf.acs_getrpc);
pthread_mutex_lock(&(cwmp->mutex_session_queue));
cwmp->retry_count_session++;
@ -179,7 +180,7 @@ int cwmp_move_session_to_session_queue(struct cwmp *cwmp, struct session *sessio
if (session->head_rpc_acs.next != &(session->head_rpc_acs)) {
rpc_acs = list_entry(session->head_rpc_acs.next, struct rpc, list);
if (rpc_acs->type != RPC_ACS_INFORM) {
if (cwmp->conf.acs_getrpc && cwmp_add_session_rpc_acs_head(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
if (acs_getrpc && cwmp_add_session_rpc_acs_head(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
pthread_mutex_unlock(&(cwmp->mutex_session_queue));
return CWMP_MEM_ERR;
}
@ -189,7 +190,7 @@ int cwmp_move_session_to_session_queue(struct cwmp *cwmp, struct session *sessio
}
}
} else {
if (cwmp->conf.acs_getrpc && cwmp_add_session_rpc_acs_head(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
if (acs_getrpc && cwmp_add_session_rpc_acs_head(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
pthread_mutex_unlock(&(cwmp->mutex_session_queue));
return CWMP_MEM_ERR;
}

9
ssl_utils.c
View file

@ -121,18 +121,23 @@ void message_compute_signature(char *msg_out, char *signature, size_t len)
struct cwmp *cwmp = &cwmp_main;
struct config *conf;
conf = &(cwmp->conf);
char *password = NULL;
global_string_param_read(&conf->acs_passwd, &password);
#ifdef LMBEDTLS
unsigned char result[MBEDTLS_MD_MAX_SIZE] = {0};
const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
mbedtls_md_hmac(md_info, (unsigned char *)conf->acs_passwd, CWMP_STRLEN(conf->acs_passwd), (unsigned char *)msg_out, CWMP_STRLEN(msg_out), result);
mbedtls_md_hmac(md_info, (unsigned char *)password, CWMP_STRLEN(password), (unsigned char *)msg_out, CWMP_STRLEN(msg_out), result);
#else
unsigned char result[EVP_MAX_MD_SIZE] = {0};
HMAC(EVP_sha1(), conf->acs_passwd, CWMP_STRLEN(conf->acs_passwd), (unsigned char *)msg_out, CWMP_STRLEN(msg_out), result, NULL);
HMAC(EVP_sha1(), password, CWMP_STRLEN(password), (unsigned char *)msg_out, CWMP_STRLEN(msg_out), result, NULL);
#endif
FREE(password);
for (int i = 0; i < result_len; i++) {
if (len - CWMP_STRLEN(signature) < 3) // each time 2 hex chars + '\0' at end so needed space is 3 bytes
break;

8
ubus_utils.c
View file

@ -183,7 +183,10 @@ static void bb_add_icwmp_status(struct blob_buf *bb)
void *tbl = blobmsg_open_table(bb, "cwmp");
bb_add_string(bb, "status", cwmp_main.init_complete ? "up" : "init");
bb_add_string(bb, "start_time", get_time(cwmp_main.start_time));
bb_add_string(bb, "acs_url", cwmp_main.conf.acsurl);
char *acs_url = NULL;
global_string_param_read(&cwmp_main.conf.acsurl, &acs_url);
bb_add_string(bb, "acs_url", acs_url);
FREE(acs_url);
blobmsg_close_table(bb, tbl);
}
@ -279,7 +282,8 @@ static void icwmp_inform_get_rpc_method(struct ubus_context *ctx, struct ubus_re
cwmp_save_event_container(event_container);
session = list_entry(cwmp_main.head_event_container, struct session, head_event_container);
if (cwmp_main.conf.acs_getrpc && cwmp_add_session_rpc_acs(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
bool acs_getrpc = global_bool_param_read(&cwmp_main.conf.acs_getrpc);
if (acs_getrpc && cwmp_add_session_rpc_acs(session, RPC_ACS_GET_RPC_METHODS) == NULL) {
pthread_mutex_unlock(&(cwmp_main.mutex_session_queue));
return;
}

14
xml.c
View file

@ -138,13 +138,14 @@ int xml_send_message(struct cwmp *cwmp, struct session *session, struct rpc *rpc
char c[512];
int msg_out_len = 0, f, r = 0;
mxml_node_t *b;
int compression = global_int_param_read(&cwmp->conf.compression);
if (session->tree_out) {
unsigned char *zmsg_out;
msg_out = mxmlSaveAllocString(session->tree_out, whitespace_cb);
CWMP_LOG_XML_MSG(DEBUG, msg_out, XML_MSG_OUT);
if (cwmp->conf.compression != COMP_NONE) {
if (zlib_compress(msg_out, &zmsg_out, &msg_out_len, cwmp->conf.compression)) {
if (compression != COMP_NONE) {
if (zlib_compress(msg_out, &zmsg_out, &msg_out_len, compression)) {
return -1;
}
FREE(msg_out);
@ -236,7 +237,8 @@ int xml_prepare_msg_out(struct session *session)
return -1;
}
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[(conf->amd_version) - 1]);
int amd_version = global_int_param_read(&conf->amd_version);
mxmlElementSetAttr(n, "xmlns:cwmp", cwmp_urls[amd_version - 1]);
if (!session->tree_out)
return -1;
@ -464,10 +466,14 @@ void load_notification_xml_schema(mxml_node_t **tree)
return;
}
if (NULL == mxmlNewOpaque(un, conf->acs_userid)) {
char *acs_userid = NULL;
global_string_param_read(&conf->acs_userid, &acs_userid);
if (NULL == mxmlNewOpaque(un, acs_userid)) {
FREE(acs_userid);
MXML_DELETE(xml);
return;
}
FREE(acs_userid);
mxml_node_t *cn = mxmlNewElement(notification, "CN");
if (cn == NULL) {