void psm_cli_set(int argc, char **argv)
{
psm_handle_t handle;
int ret;
if (argc != 4) {
wmprintf("[psm] Usage: %s <module> <variable> <value>\r\n",
argv[0]);
wmprintf("[psm] Error: invalid number of arguments\r\n");
return;
}
if ((ret = psm_open(&handle, argv[1])) != 0) {
psm_e("psm_open failed with: %d "
"(Is the module name registered?)", ret);
return;
}
psm_set(&handle, argv[2], argv[3]);
psm_close(&handle);
}
int diagnostics_write_stats()
{
int ret;
psm_handle_t handle;
char psm_val[DIAG_STATS_LENGTH];
ret = psm_register_module(STATS_MOD_NAME, "common_part", PSM_CREAT);
if (ret != WM_SUCCESS && ret != -WM_E_EXIST) {
dbg("Failed to register stats module with psm\r\n");
return -1;
}
/* Query for cumulative statistics first, since this has to open psm
* itself.
*/
get_stats(psm_val, sizeof(psm_val), CLOUD_CUMUL_STATS);
ret = psm_open(&handle, STATS_MOD_NAME);
if (ret != WM_SUCCESS) {
dbg("Failed to open psm module. Error: %d\r\n", ret);
if (ret == -WM_E_PSM_METADATA_CRC)
psm_erase_and_init();
if (ret == -WM_E_CRC)
psm_erase_partition
(psm_get_partition_id(STATS_MOD_NAME));
return ret;
}
psm_set(&handle, VAR_CLOUD_CUMUL_STATS, psm_val);
snprintf(psm_val, sizeof(psm_val), "%d", g_wm_stats.reboot_reason);
psm_set(&handle, VAR_REBOOT_REASON, psm_val);
snprintf(psm_val, sizeof(psm_val), "%u", sys_get_epoch());
psm_set(&handle, VAR_EPOCH, psm_val);
get_stats(psm_val, sizeof(psm_val), CONN_STATS);
psm_set(&handle, VAR_CONN_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), DHCP_STATS);
psm_set(&handle, VAR_DHCP_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), HTTP_CLIENT_STATS);
psm_set(&handle, VAR_HTTP_CLIENT_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), CLOUD_STATS);
psm_set(&handle, VAR_CLOUD_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), HTTPD_STATS);
psm_set(&handle, VAR_HTTPD_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), NET_STATS);
psm_set(&handle, VAR_NET_STATS, psm_val);
get_stats(psm_val, sizeof(psm_val), IP_ADDR);
psm_set(&handle, VAR_IP_ADDR, psm_val);
get_stats(psm_val, sizeof(psm_val), TIME);
psm_set(&handle, VAR_TIME, psm_val);
psm_close(&handle);
return 0;
}
/****************************************
* generate new token to global token array
****************************************/
static int deal_with_token(bool should_re_gen)
{
int ret;
#define STR_LEN 35
char strval[STR_LEN] = {0};
psm_handle_t handle;
ret = psm_open(&handle,"ot_config");
if(ret) {
LOG_ERROR("open psm area error \r\n");
return -WM_FAIL;
}
ret = psm_get(&handle,OT_TOKEN,strval,STR_LEN);
if(!ret && !should_re_gen) { //token already exist
//read token_string to token array
arch_axtobuf_detail(strval, sizeof(strval), token, sizeof(token), NULL);
goto exit;
}
//should regenerator token
if(ret) { //which mean first time generate token
memset(token,0,sizeof(token));
}
//max length is 10 + 16 + 16 +6 = 48
#define GEN_BUF_LEN (52)
uint8_t token_generate_buffer[GEN_BUF_LEN];
int n = 0;
n = snprintf_safe((char *)token_generate_buffer,GEN_BUF_LEN,"%u",os_ticks_get());
memcpy(token_generate_buffer + n,cfg_struct.key,OT_PROTO_DEVICE_KEY_SIZE);
n+= OT_PROTO_DEVICE_KEY_SIZE;
memcpy(token_generate_buffer + n,token,sizeof(token));
n += sizeof(token);
memcpy(token_generate_buffer + n,cfg_struct.mac_address,6);
n += 6;
//generate token
md5(token_generate_buffer,n,token);
snprintf_safe(strval,STR_LEN,"%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
token[0],
token[1],
token[2],
token[3],
token[4],
token[5],
token[6],
token[7],
token[8],
token[9],
token[10],
token[11],
token[12],
token[13],
token[14],
token[15]
);
ret = psm_set(&handle,OT_TOKEN,strval);
if(ret){
LOG_ERROR("write token fail");
goto exit;
}
LOG_DEBUG("generate token success \r\n");
exit:
psm_close(&handle);
return ret;
}
