这两份代码呈现的，/******************************************************************************
* Copyright (c) 2020-2020 TP-Link Technologies CO.,LTD.
*
* Filename: diagnose_main.h
* Version: 1.0
* Description: 自动诊断头文件
* Author: 赖滨绍<laibinshao@tp-link.com.cn>
* Date: 2020-12-10
******************************************************************************/
#ifndef _H_DIAGNOSE_MAIN
#define _H_DIAGNSOE_MAIN
#include "diagnose_commom.h"
typedef enum
{
DIAGNOSE_WIRELESS=0, /*无线诊断*/
DIAGNOSE_GATEWAY, /*网关诊断*/
DIAGNOSE_ADDR1, /*外网1诊断*/
DIAGNOSE_ADDR2, /*外网2诊断*/
DIAGNOSE_BASE_CLOUD, /*基础云诊断*/
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
DIAGNOSE_LTE_DNS1, /* LTE检测的DNS
地址1 */
DIAGNOSE_LTE_DNS2, /* LTE检测的DNS
地址2 */
DIAGNOSE_USER_ADDR1, /* 用户自定义
地址1 */
DIAGNOSE_USER_ADDR2, /* 用户自定义
地址2 */
#endif
DIAGNOSE_STORAGE, /*存储诊断*/
DIAGNOSE_FIRMWARE, /*固件诊断*/
DIAGNOSE_SAFETY, /*安全诊断（视频加密）*/
DIAGNOSE_MAX
} DIAGNOSE_PARA; /*标记诊断项对应的位*/
typedef enum
{
NET_GATEWAY = 0, /*网关*/
NET_INTERNET1, /*外网1*/
NET_INTERNET2, /*外网2*/
NET_BASE_CLOUD, /*基础云*/ /* 由于外销基础云域名不让ping， 暂改成官网域名 “www.tp-link.com” */
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
NET_4G_DET_DNS1, /* 4G网络检测的DNS
地址1 */
NET_4G_DET_DNS2, /* 4G网络检测的DNS
地址2 */
NET_USER_DEFINED1, /* 用户自定义
地址1 */
NET_USER_DEFINED2, /* 用户自定义
地址2 */
#endif
NET_MAX
}NETWORK_PARA; /*网络诊断参数，表示在g_ping_array数组中的位置*/
typedef enum
{
CSTG_OFFLINE = 0, /*云掉线*/
CSTG_ONLINE /*云在线*/
} CSTG_STAT; /*云状态*/
#endif
/******************************************************************************
* Copyright (c) 2020-2020 TP-Link Technologies CO.,LTD.
*
* Filename: diagnose_main.c
* Version: 1.0
* Description: 自动诊断部分
* Author: 赖滨绍<laibinshao@tp-link.com.cn>
* Date: 2020-12-10
******************************************************************************/
#include <sys/types.h>
#include <arpa/inet.h>
#include <errno.h>
#include "diagnose_main.h"
#include "msg_utils.h"
#include "telnet.h"
#define ITEMS_TIMEOUT_VAL 15 /*网络诊断超时时间*/
#define MAX_CLIENTS_NUM 10 /*接受客户端请求诊断数量*/
#define CLIENT_GET_TIMEOUT 30 /*客户端get请求最大次数*/
#define CLIENT_RECLAIM_INTERVAL 50 /*客户端诊断实例资源回收超时*/
DIAG_ADDR g_default_address; /*网络诊断
地址*/
LOCAL S32 g_diagnose_timerid = ERROR; /*网络诊断超时定时器*/
LOCAL S8 g_is_auto_diagnose = 0; /*是否收到自诊断消息*/
PHY_STATUS g_phy_stat; /*物理链路状态*/
TASK_STRUCT g_client_array[MAX_CLIENTS_NUM]; /*记录客户端信息*/
NETWORK_STRUCT g_network_array[ADDR_COUNTS]; /*网络
地址诊断信息*/
CONNECT_INFO g_connect_info;
STORAGE_INFO g_storage_info;
FIRMWARE_STRUCT g_firmware_info;
VIDEO_ENCRYPTION g_video_encryption;
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
#define NET_DETECTION_DEFAULT_DNS1 "8.8.8.8"
#define NET_DETECTION_DEFAULT_DNS2 "www.google.com"
LOCAL S8 g_is_lte_diagnose = 0; /* 是否是lte模块发起的自诊断信息 */
LOCAL S8 g_is_other_model_diagnose = 0; /* 其他模块发起的自诊断信息 */
#endif
LOCAL S8 g_task_running = 0; /*当前是否进行了除网络诊断外的其他诊断*/
/***********************************************************************************************
*函数：
*描述：加载数据模型中的诊断
地址
*参数：
*返回值：
***********************************************************************************************/
S32 load_network_address()
{
int index = 0;
DIAG_ADDR target_addr;
memset(&target_addr, 0, sizeof(DIAG_ADDR));
if (0 == ds_read(DIAGNOSE_ADDR_PATH, (void*)(&target_addr), sizeof(DIAG_ADDR)))
{
DIAGNOSE_WARNING("diagnose read address error.");
return ERROR;
}
/*第0位保留为网关
地址*/
for(index = 1; index < ADDR_COUNTS; index++)
{
strncpy(g_default_address.diag_addr[index], target_addr.diag_addr[index], ADDR_LEN);
}
DIAGNOSE_DEBUG("internet1:%s internet2:%s basecloud:%s",
g_default_address.diag_addr[1], g_default_address.diag_addr[2], g_default_address.diag_addr[3]);
return OK;
}
/***********************************************************************************************
*函数：
*描述：关注数据据块，加载网关
地址
*参数：
*返回值：
***********************************************************************************************/
void load_gateway_address()
{
LINK_STATUS link_status = {0};
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
LTE_CONFIG_INFO_DATA lte_config = {0};
LTE_DHCP_IP lte_dhcp_ip = {0};
ds_read(LTE_INFO_DATA_PATH, (U8*)<e_config, sizeof(LTE_CONFIG_INFO_DATA));
if(lte_config.internet_wired_enable == 0 || (lte_config.internet_wired_enable == 2 && lte_config.auto_switch_wired == 0))
{
ds_read(LTE_DHCP_IP_PATH, (U8*)<e_dhcp_ip, sizeof(LTE_DHCP_IP));
ip_to_str(lte_dhcp_ip.gateway, g_default_address.diag_addr[0]);
}else
#endif
{
ds_read(LINK_STATUS_PATH, &link_status, sizeof(LINK_STATUS));
ip_to_str(link_status.gateway, g_default_address.diag_addr[0]);
}
DIAGNOSE_DEBUG("gateway:%s, internet1:%s,internet2:%s,cloud:%s",g_default_address.diag_addr[0],
g_default_address.diag_addr[1],g_default_address.diag_addr[2],g_default_address.diag_addr[3]);
}
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
/***********************************************************************************************
*函数：
*描述：关注lte模块net_det数据块，加载用户自定义
地址
*参数：
*返回值：
***********************************************************************************************/
void load_user_defined_address()
{
LTE_CONFIG_NET_DETECTION net_det = {0};
if(0 == ds_read(LTE_NET_DET_PATH, (U8*)&net_det, sizeof(LTE_CONFIG_NET_DETECTION)))
{
DIAGNOSE_ERROR("read path: %s\n failed.", LTE_NET_DET_PATH);
return;
}
DIAGNOSE_ERROR("[LTE] add default dns address:%s", NET_DETECTION_DEFAULT_DNS1);
strncpy(g_default_address.diag_addr[NET_4G_DET_DNS1], NET_DETECTION_DEFAULT_DNS1, ADDR_LEN);
DIAGNOSE_ERROR("[LTE] add default dns address:%s", NET_DETECTION_DEFAULT_DNS2);
strncpy(g_default_address.diag_addr[NET_4G_DET_DNS2], NET_DETECTION_DEFAULT_DNS2, ADDR_LEN);
if(strlen(net_det.hostname_1) != 0)
{
DIAGNOSE_ERROR("add user defined address:%s.", net_det.hostname_1);
strncpy(g_default_address.diag_addr[NET_USER_DEFINED1], net_det.hostname_1, ADDR_LEN);
}else
{
memset(g_default_address.diag_addr[NET_USER_DEFINED1], 0, ADDR_LEN);
}
if(strlen(net_det.hostname_2) != 0)
{
DIAGNOSE_ERROR("add user defined address:%s.", net_det.hostname_2);
strncpy(g_default_address.diag_addr[NET_USER_DEFINED2], net_det.hostname_2, ADDR_LEN);
}else
{
memset(g_default_address.diag_addr[NET_USER_DEFINED2], 0, ADDR_LEN);
}
DIAGNOSE_ERROR("user defined addrees1:%s, user define address2:%s.", g_default_address.diag_addr[NET_USER_DEFINED1],
g_default_address.diag_addr[NET_USER_DEFINED2]);
}
#endif
/***********************************************************************************************
*函数：ip_to_str
*描述：将网络字节序IP转成字符形式
*参数：
*返回值：
***********************************************************************************************/
S32 ip_to_str(U32 ip_addr, char* str_ip)
{
struct in_addr dst;
if (NULL == str_ip)
{
return ERROR;
}
memset(str_ip, 0, IP_LEN);
dst.s_addr = ip_addr;
if (NULL == inet_ntop(AF_INET, (void*)&dst, str_ip, IP_LEN))
{
return ERROR;
}
return OK;
}
void diagnose_stop(void)
{
int index =0;
g_task_running = 0;
if (g_is_auto_diagnose)
{
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
if(g_is_lte_diagnose)
{
lte_diagnose_reply_result();
g_is_lte_diagnose = 0;
}else
#endif
{
diagnose_reply_result(); /*诊断完成后发送诊断消息*/
}
g_is_auto_diagnose = 0;
}
DIAGNOSE_DEBUG("diagnose stop, save diagnose result to network config\n");
diagnose_result_save_config();
if (ERROR != g_diagnose_timerid)
{
inet_del_timer(g_diagnose_timerid);
g_diagnose_timerid = ERROR;
}
for (index = 0; index < ADDR_COUNTS; index++)
{
if (TESTED != g_network_array[index].status)
{
g_network_array[index].status = TESTED;
g_network_array[index].res = DIAGNOSE_FAILED;
}
if (g_network_array[index].do_telnet)
{
if (g_network_array[index].tel_state != TESTED)
{
g_network_array[index].tel_res = DIAGNOSE_FAILED;
}
telnet_stop(&g_network_array[index]);
}
}
}
/***********************************************************************************************
*函数：check_signal_quality
*描述：获取无线信号强度
*参数：
*返回值：
***********************************************************************************************/
S32 check_signal_quality(CONNECT_INFO* ptr_wireless)
{
DS_HANDLE_CONTEXT ds_context;
JSON_OBJPTR data_obj = NULL;
const char* ptr_value = NULL;
int error_code = OK;
PHY_STATUS phy_status = {0};
if (NULL == ptr_wireless)
{
return ERROR;
}
ds_read(PHY_STATUS_PATH, &phy_status, sizeof(PHY_STATUS));
if (1 == phy_status.ether || 0 == phy_status.wlan)
{
strncpy(ptr_wireless->link_type, "ethernet", LINK_TYPE_LEN);
return OK;
}
/*构造jason请求sd信息*/
memset(&ds_context, 0, sizeof(DS_HANDLE_CONTEXT));
if (NULL == (ds_context.req_obj = jso_new_obj()))
{
return ERROR;
}
if (NULL == (data_obj = jso_new_obj()))
{
error_code = ERROR;
goto out;
}
jso_obj_add(ds_context.req_obj, "network", data_obj);
jso_add_string(data_obj, "get_connection_type", "");
jso_add_string(ds_context.req_obj, "method", "do");
ds_context.group_mask = ROOT_MASK;
ds_context.method = METHOD_DO;
ds_handle(&ds_context);
if (NULL == ds_context.res_obj)
{
error_code = ERROR;
goto out;
}
if (NULL == (ptr_value = jso_obj_get_string_origin(ds_context.res_obj, "link_type")))
{
error_code = ERROR;
goto out;
}
strncpy(ptr_wireless->link_type, ptr_value, LINK_TYPE_LEN);
if (0 == strcmp(ptr_value, "ethernet"))
{
/*有线连接*/
error_code = OK;
goto out;
}
/*无线连接*/
if (NULL == (ptr_value = jso_obj_get_string_origin(ds_context.res_obj, "ssid")))
{
error_code = ERROR;
goto out;
}
strncpy(ptr_wireless->ssid, ptr_value, WIFI_SSID_MAX_LEN);
jso_obj_get_int(ds_context.res_obj, "rssi", &(ptr_wireless->rssi));
error_code = OK;
DIAGNOSE_INFO("ssid:%s rssi:%d", ptr_wireless->ssid, ptr_wireless->rssi);
out:
if (NULL != ds_context.req_obj)
{
jso_free_obj(ds_context.req_obj);
ds_context.req_obj = NULL;
}
if (NULL != ds_context.res_obj)
{
jso_free_obj(ds_context.res_obj);
ds_context.res_obj = NULL;
}
return error_code;
}
/***********************************************************************************************
*函数：
*描述：网络诊断数组初始化
*参数：
*返回值：
***********************************************************************************************/
void address_array_init()
{
/*数组第0位放网关
地址*/
memset(&g_network_array[NET_GATEWAY], 0, sizeof(NETWORK_STRUCT));
strncpy(g_network_array[NET_GATEWAY].para_name, "gateway", PARA_NAME_LEN);
g_network_array[NET_GATEWAY].params_code = DIAGNOSE_GATEWAY;
g_network_array[NET_GATEWAY].test = 1;
/*数组第1位放外网
地址1*/
memset(&g_network_array[NET_INTERNET1], 0, sizeof(NETWORK_STRUCT));
strncpy(g_network_array[NET_INTERNET1].para_name, "internet1", PARA_NAME_LEN);
g_network_array[NET_INTERNET1].params_code = DIAGNOSE_ADDR1;
g_network_array[NET_INTERNET1].test = 1;
/*数组第2位放外网
地址2*/
memset(&g_network_array[NET_INTERNET2], 0, sizeof(NETWORK_STRUCT));
strncpy(g_network_array[NET_INTERNET2].para_name, "internet2", PARA_NAME_LEN);
g_network_array[NET_INTERNET2].params_code = DIAGNOSE_ADDR2;
g_network_array[NET_INTERNET2].test = 1;
/*数组第3位放云服务器
地址*/
memset(&g_network_array[NET_BASE_CLOUD], 0, sizeof(NETWORK_STRUCT));
strncpy(g_network_array[NET_BASE_CLOUD].para_name, "cloud", PARA_NAME_LEN);
g_network_array[NET_BASE_CLOUD].params_code = DIAGNOSE_BASE_CLOUD;
g_network_array[NET_BASE_CLOUD].test = 1;
g_network_array[NET_BASE_CLOUD].do_telnet = 1;
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
memset(&g_network_array[NET_4G_DET_DNS1], 0, sizeof(NETWORK_STRUCT));
memset(&g_network_array[NET_4G_DET_DNS2], 0, sizeof(NETWORK_STRUCT));
memset(&g_network_array[NET_USER_DEFINED1], 0, sizeof(NETWORK_STRUCT));
memset(&g_network_array[NET_USER_DEFINED2], 0, sizeof(NETWORK_STRUCT));
LTE_CONFIG_NET_DETECTION net_det = {0};
if(0 == ds_read(LTE_NET_DET_PATH, (U8*)&net_det, sizeof(LTE_CONFIG_NET_DETECTION)))
{
DIAGNOSE_ERROR("read path %s failed.", LTE_NET_DET_PATH);
return;
}
if(net_det.ping_enable == 1 && g_is_lte_diagnose == 1 && g_is_other_model_diagnose == 0)
{
/* 如果是LTE模块发起的ping检测只检测dns1 dns2
和用户自定义
地址 */
g_network_array[NET_INTERNET1].test = 0;
g_network_array[NET_INTERNET2].test = 0;
/* 如果是LTE模块发起的ping检测暂时不检测网关
地址 */
g_network_array[NET_GATEWAY].test = 0;
/* 如果是LTE模块发起的ping检测不对bata云进行telnet */
g_network_array[NET_BASE_CLOUD].do_telnet = 0;
g_network_array[NET_BASE_CLOUD].test = 0;
/* 数组第4位放LTE检测的DNS
地址1 */
strncpy(g_network_array[NET_4G_DET_DNS1].para_name, "dns1", PARA_NAME_LEN);
g_network_array[NET_4G_DET_DNS1].params_code = DIAGNOSE_LTE_DNS1;
g_network_array[NET_4G_DET_DNS1].test = 1;
/* 数组第5位放LTE检测的DNS
地址2 */
strncpy(g_network_array[NET_4G_DET_DNS2].para_name, "dns2", PARA_NAME_LEN);
g_network_array[NET_4G_DET_DNS2].params_code = DIAGNOSE_LTE_DNS2;
g_network_array[NET_4G_DET_DNS2].test = 1;
/* 数组第6位放用户自定义
地址1(如果有配置的话) */
if(strlen(net_det.hostname_1) != 0)
{
strncpy(g_network_array[NET_USER_DEFINED1].para_name, "hostname_1", PARA_NAME_LEN);
g_network_array[NET_USER_DEFINED1].params_code = DIAGNOSE_USER_ADDR1;
g_network_array[NET_USER_DEFINED1].test = 1;
}
/* 数组第7位放用户自定义
地址2(如果有配置的话) */
if(strlen(net_det.hostname_2) != 0)
{
strncpy(g_network_array[NET_USER_DEFINED2].para_name, "hostname_2", PARA_NAME_LEN);
g_network_array[NET_USER_DEFINED2].params_code = DIAGNOSE_USER_ADDR2;
g_network_array[NET_USER_DEFINED2].test = 1;
}
}
#endif
return;
}
/***********************************************************************************************
*函数：
*描述：ping结束时，保存错误码，保存ip、域名及ping结果，设置相应标志
*参数：
*返回值：
***********************************************************************************************/
void save_result_callback(struct _DIAGNOSE_CONTEXT* context)
{
int index = 0;
if (NULL == context)
{
return;
}
g_network_array[context->index].status = TESTED; /*设置诊断状态为结束*/
if (NULL != context->dnsData)
{
strncpy(g_network_array[context->index].str_domain, context->dnsData->
url, ADDR_LEN); /*保存域名*/
}
if (0 == context->ipAddr && NULL != context->dnsData) /*dns解析失败*/
{
g_network_array[context->index].res = DIAGNOSE_FAILED;
goto exit;
}
ip_to_str(context->ipAddr, g_network_array[context->index].str_ip);/*保存ip
地址*/
if (PING_SUCCESS != context->status)
{
g_network_array[context->index].res = DIAGNOSE_FAILED; /*设置诊断结果为失败*/
goto exit;
}
g_network_array[context->index].res = DIAGNOSE_SUCCESS; /*设置诊断结果为成功*/
DIAGNOSE_DEBUG("save %s OK", g_network_array[context->index].para_name);
exit:
/*是否所有诊断结束*/
for (index = 0; index < ADDR_COUNTS; index++)
{
if (0 == g_network_array[index].test)
{
continue;
}
if (g_network_array[index].do_telnet && TESTED != g_network_array[index].tel_state)
{
break;
}
if (TESTED != g_network_array[index].status)
{
break;
}
}
if (ADDR_COUNTS == index)
{
diagnose_stop();
}
return;
}
/***********************************************************************************************
*函数：
*描述：发起ping请求
*参数：
*返回值：ERROR:ping失败 OK：ping 发起成功
***********************************************************************************************/
S32 ping_start(char* addr, U32 index, U32* context_id)
{
U32 icmpid = 0;
IP_ADDR ip_addr = {0};
DIAGNOSE_DNS_DATA* dns_data = NULL;
if (NULL == addr || NULL == context_id)
{
return ERROR;
}
/*ip合法检查*/
if (0 == inet_pton(AF_INET, addr, (void*)&ip_addr))
{
if (FALSE == valid_domain(addr))
{
DIAGNOSE_WARNING("Invalid target domain name format.");
return ERROR;
}
dns_data = (DIAGNOSE_DNS_DATA *)DIAGNOSE_MALLOC(sizeof(DIAGNOSE_DNS_DATA));
if (NULL == dns_data)
{
DIAGNOSE_WARNING("Failed to alloc memory, size=%d.", sizeof(DIAGNOSE_DNS_DATA));
return ERROR;
}
memset(dns_data, 0, sizeof(DIAGNOSE_DNS_DATA));
strncpy(dns_data->
url, addr, ADDR_LEN);
}
else
{
if (FALSE == valid_ip_addr(ip_addr.ipAddr))
{
DIAGNOSE_DEBUG("Invalid target ip format.");
return ERROR;
}
}
/*发起ping请求*/
DIAGNOSE_ERROR("start ping:%s", (NULL == dns_data) ? addr : dns_data->
url);
icmpid = diagnose_ping(dns_data, ip_addr.ipAddr, DEFAULT_PING_SIZE,
DEFAULT_PING_TIMES, DEFAULT_PING_TIMEOUT, index, save_result_callback);
if (CONTEXT_IDLE == icmpid)
{
DIAGNOSE_FREE(dns_data);
return ERROR;
}
*context_id = icmpid;
return OK;
}
/***********************************************************************************************
*函数：network_diagnose
*描述：基础网络诊断
*参数：
*返回值：
***********************************************************************************************/
S32 network_diagnose()
{
int index = 0;
U32 context_id = 0;
int ping_stat = 0;
address_array_init();
for (index = 0; index < ADDR_COUNTS; index++)
{
if (0 == g_network_array[index].test)
{
continue;
}
ping_stat = ping_start(g_default_address.diag_addr[index], index, &context_id);
if (OK != ping_stat)
{
DIAGNOSE_DEBUG("ping start failed");
g_network_array[index].res = DIAGNOSE_FAILED;
g_network_array[index].status = TESTED;
}
else
{
g_network_array[index].status = TESTING;
}
if (g_network_array[index].do_telnet)
{
if (OK == telnet_start(g_default_address.diag_addr[index], &g_network_array[index]))
{
g_network_array[index].tel_state = TESTING;
}
else
{
g_network_array[index].tel_state = TESTED;
g_network_array[index].tel_res = DIAGNOSE_FAILED;
}
}
}
g_diagnose_timerid = inet_add_timer(diagnose_timer_handle, 0, ITEMS_TIMEOUT_VAL, EXECUTE_SINGLE);
if (ERROR == g_diagnose_timerid)
{
return ERROR;
}
return OK;
}
/***********************************************************************************************
*函数：get_sd_info
*描述：通过ds_handle获得sd卡信息
*参数：
*返回值：
***********************************************************************************************/
LOCAL S32 get_sd_info(STORAGE_INFO* ptr_storage)
{
const char* ptr = NULL;
int error_code = OK;
JSON_OBJPTR data_obj = NULL;
JSON_OBJPTR data_array = NULL;
JSON_OBJPTR array_obj = NULL;
JSON_OBJPTR json_harddisk_manage = NULL;
JSON_OBJPTR json_harddisk_info = NULL;
JSON_OBJPTR json_harddisk_NO = NULL;
JSON_OBJPTR json_harddisk_parse = NULL;
DS_HANDLE_CONTEXT ds_context;
if (NULL == ptr_storage)
{
return ERROR;
}
/*构造jason请求sd信息*/
memset(&ds_context, 0, sizeof(DS_HANDLE_CONTEXT));
if (NULL == (ds_context.req_obj = jso_new_obj()))
{
DIAGNOSE_WARNING("jso_new_obj failed.");
return ERROR;
}
if (NULL == (data_obj = jso_new_obj()))
{
error_code = ERROR;
goto out;
}
jso_obj_add(ds_context.req_obj, "harddisk_manage", data_obj);
jso_add_string(ds_context.req_obj, "method", "get");
if (NULL == (data_array = jso_new_array()))
{
error_code = ERROR;
goto out;
}
jso_obj_add(data_obj, "name", data_array);
if (NULL == (array_obj = jso_new_string("harddisk")))
{
error_code = ERROR;
goto out;
}
jso_array_add(data_array, array_obj);
if (NULL == (array_obj = jso_new_string("video")))
{
error_code = ERROR;
goto out;
}
jso_array_add(data_array, array_obj);
if (NULL == (array_obj = jso_new_string("picture")))
{
error_code = ERROR;
goto out;
}
jso_array_add(data_array, array_obj);
if (NULL == (data_array = jso_new_array()))
{
error_code = ERROR;
goto out;
}
jso_obj_add(data_obj, "table", data_array);
if (NULL == (array_obj = jso_new_string("hd_info")))
{
error_code = ERROR;
goto out;
}
jso_array_add(data_array, array_obj);
/*发送请求*/
ds_context.group_mask = ROOT_MASK;
ds_context.method = METHOD_GET;
ds_handle(&ds_context);
if(NULL == ds_context.res_obj)
{
error_code = ERROR;
goto out;
}
/*读取返回值*/
if (NULL == (json_harddisk_manage = jso_obj_get(ds_context.res_obj, "harddisk_manage")))
{
error_code = ERROR;
goto out;
}
if (NULL == (json_harddisk_info = jso_obj_get(json_harddisk_manage, "hd_info")))
{
error_code = ERROR;
goto out;
}
if (NULL == (json_harddisk_NO = jso_array_get_idx(json_harddisk_info, 0)))
{
error_code = ERROR;
goto out;
}
if (NULL == (json_harddisk_parse = jso_obj_get(json_harddisk_NO, "hd_info_1")))
{
error_code = ERROR;
goto out;
}
if (NULL != (ptr= jso_obj_get_string_origin(json_harddisk_parse, "total_space"))) /*sd总大小*/
{
strncpy(ptr_storage->size.total, ptr, SD_SIZE_LEN);
}
if (NULL != (ptr = jso_obj_get_string_origin(json_harddisk_parse, "free_space"))) /*sd剩余空间*/
{
strncpy(ptr_storage->size.free, ptr, SD_SIZE_LEN);
}
if (NULL != (ptr = jso_obj_get_string_origin(json_harddisk_parse,"record_duration")))/*sd已录时长*/
{
strncpy(ptr_storage->recorded_time, ptr, SD_SIZE_LEN);
}
if (NULL != (ptr = jso_obj_get_string_origin(json_harddisk_parse, "status"))) /*sd状态*/
{
strncpy(ptr_storage->available, ptr, SD_STATUS_LEN);
}
error_code = OK;
out:
if (NULL != ds_context.req_obj)
{
jso_free_obj(ds_context.req_obj);
ds_context.req_obj = NULL;
}
if (NULL != ds_context.res_obj)
{
jso_free_obj(ds_context.res_obj);
ds_context.res_obj = NULL;
}
return error_code;
}
/***********************************************************************************************
*函数：storage_diagnose
*描述：存储诊断
*参数：
*返回值：
***********************************************************************************************/
LOCAL S32 storage_diagnose(STORAGE_INFO* ptr_storage)
{
if (NULL == ptr_storage)
{
return ERROR;
}
DIAGNOSE_DEBUG("start storage diagnose");
/*云存储*/
ds_read(CSTG_UPLOAD_ENABLE_PATH, &(ptr_storage->upload_enable), sizeof(CSTG_UPLOAD_ENABLE));
ds_read(CSTG_IS_UPLOADING_PATH, &(ptr_storage->uploading), sizeof(CSTG_IS_UPLOADING));
/*本地存储*/
ds_read(PLAN_ADVANCE_PATH, &(ptr_storage->plan_advance), sizeof(PLAN_ADVANCE));/*预录
和延录时间*/
get_sd_info(ptr_storage); /*请求sd 状态、总大小、剩余空间、已录时长*/
return OK;
}
/***********************************************************************************************
*函数：
*描述：获取固件是否有更新
*参数：
*返回值：
***********************************************************************************************/
S32 request_fw_status()
{
DS_HANDLE_CONTEXT ds_context = {0};
JSON_OBJPTR data_obj = NULL;
if (NULL == (ds_context.req_obj = jso_new_obj()))
{
return ERROR;
}
if (NULL == (data_obj = jso_new_obj()))
{
return ERROR;
}
jso_obj_add(ds_context.req_obj, "cloud_status", data_obj);
jso_add_string(ds_context.req_obj, "method", "get");
jso_add_string(data_obj, "name", "check_fw_ver");
ds_context.group_mask = ROOT_MASK;
ds_context.method = METHOD_GET;
ds_handle(&ds_context);
if(NULL == ds_context.res_obj)
{
return ERROR;
}
return OK;
}
/***********************************************************************************************
*函数：firmware_diagnose
*描述：固件诊断
*参数：
*返回值：
***********************************************************************************************/
LOCAL S32 firmware_diagnose(FIRMWARE_STRUCT* ptr_firmware)
{
NEW_FIRMWARE new_firm;
if (NULL == ptr_firmware)
{
return ERROR;
}
DIAGNOSE_DEBUG("start firmware diagnose");
memset(&new_firm, 0, sizeof(NEW_FIRMWARE));
if (0 == ds_read(CLOUD_CONFIG_NEWFW_PATH, &new_firm, sizeof(NEW_FIRMWARE)))
{
return ERROR;
}
ptr_firmware->fw_new_
notify = new_firm.fw_new_
notify;
return OK;
}
/***********************************************************************************************
*函数：safety_diagnose
*描述：安全诊断
*参数：
*返回值：
***********************************************************************************************/
void safety_diagnose(VIDEO_ENCRYPTION* ptr_videoencryption)
{
if (NULL == ptr_videoencryption)
{
return;
}
DIAGNOSE_DEBUG("start safety diagnose");
ptr_videoencryption->is_encryption = 1;
return;
}
S32 diagnose_msg_send(int res)
{
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
if(g_is_lte_diagnose)
{
LTE_NETWORK_DIAGNOSE_RPL_MSG msg = {0};
DIAGNOSE_ERROR("send lte model diagnose msg out id:%d", res);
msg.res = res;
return msg_send(LTE_NETWORK_DIAGNOSE_RPL_MID, (U8 *)&msg, sizeof(msg));
}else
#endif
{
NETWORK_DIAGNOSE_RPL_MSG msg = {0};
DIAGNOSE_DEBUG("send diagnose msg out id:%d", res);
msg.res = res;
return msg_send(NETWORK_DIAGNOSE_RPL_MID, (U8 *)&msg, sizeof(msg));
}
}
S32 diagnose_reply_result(void)
{
int res = 0;
if (LINK_DOWN == g_phy_stat.ether && LINK_DOWN == g_phy_stat.wlan)
{
res = NETWORK_PHY_DOWN;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_GATEWAY].res)
{
res = NETWORK_GATEWAY_FAILED;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_INTERNET1].res && DIAGNOSE_FAILED == g_network_array[NET_INTERNET2].res)
{
if (DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].res &&
DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].tel_res)
{
res = NETWORK_FAILED;
goto out;
}
res = NETWORK_OK;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].res && DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].tel_res)
{
res = NETWORK_CLOUD_FAILED;
goto out;
}
res = NETWORK_OK;
out:
return diagnose_msg_send(res);
}
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
S32 lte_diagnose_reply_result(void)
{
int res = 0;
LTE_CONFIG_NET_DETECTION lte_net_detection;
memset(<e_net_detection, 0, sizeof(LTE_CONFIG_NET_DETECTION));
ds_read(LTE_NET_DET_PATH, <e_net_detection, sizeof(LTE_CONFIG_NET_DETECTION));
INFO_INTERNET info_internet;
memset(&info_internet, 0, sizeof(INFO_INTERNET));
ds_read(INFO_INTERNET_PATH, &info_internet, sizeof(INFO_INTERNET));
if (INTERNET_4G_CONNECTED != info_internet.link_status)
{
res = NETWORK_4G_DOWN;
goto out;
}
if(strlen(lte_net_detection.hostname_1) != 0 || strlen(lte_net_detection.hostname_2) != 0)
{
if(DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS1].res &&
DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS2].res)
{
if(g_network_array[NET_USER_DEFINED1].test == 1 && g_network_array[NET_USER_DEFINED2].test == 1)
{
if(g_network_array[NET_USER_DEFINED1]
.res == DIAGNOSE_FAILED &&
g_network_array[NET_USER_DEFINED2]
.res == DIAGNOSE_FAILED)
{
res = NETWORK_DETECTION_FAILED;
goto out;
}
}else
{
if((g_network_array[NET_USER_DEFINED1].test == 1 && g_network_array[NET_USER_DEFINED1]
.res == DIAGNOSE_FAILED) ||
(g_network_array[NET_USER_DEFINED2].test == 1 && g_network_array[NET_USER_DEFINED2]
.res == DIAGNOSE_FAILED))
{
res = NETWORK_DETECTION_FAILED;
goto out;
}
}
}
res = NETWORK_DETECTION_OK;
goto out;
}else
{
if (DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS1].res &&
DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS2].res)
{
res = NETWORK_DETECTION_FAILED;
goto out;
}
}
res = NETWORK_DETECTION_OK;
out:
return diagnose_msg_send(res);
}
#endif
S32 diagnose_result_save_config(void)
{
int res = 0;
LINK_STATUS link_status = {0};
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
LTE_CONFIG_INFO_DATA lte_config = {0};
ds_read(LTE_INFO_DATA_PATH, (U8*)<e_config, sizeof(LTE_CONFIG_INFO_DATA));
if(lte_config.internet_wired_enable == 0 || (lte_config.internet_wired_enable == 2 && lte_config.auto_switch_wired == 0))
{
INFO_INTERNET info_internet = {0};
ds_read(INFO_INTERNET_PATH, (U8*)&info_internet, sizeof(INFO_INTERNET));
if(INTERNET_4G_CONNECTED != info_internet.link_status)
{
res = NETWORK_PHY_DOWN;
goto out;
}
if(DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS1].res &&
DIAGNOSE_FAILED == g_network_array[NET_4G_DET_DNS2].res)
{
if(g_network_array[NET_USER_DEFINED1].test == 1 && g_network_array[NET_USER_DEFINED2].test == 1)
{
if(g_network_array[NET_USER_DEFINED1]
.res == DIAGNOSE_FAILED &&
g_network_array[NET_USER_DEFINED2]
.res == DIAGNOSE_FAILED)
{
res = NETWORK_DETECTION_FAILED;
goto out;
}
}else if(g_network_array[NET_USER_DEFINED1].test == 0 && g_network_array[NET_USER_DEFINED2].test == 0)
{
res = NETWORK_DETECTION_FAILED;
goto out;
}else
{
if(g_network_array[NET_USER_DEFINED1]
.res == DIAGNOSE_FAILED ||
g_network_array[NET_USER_DEFINED2]
.res == DIAGNOSE_FAILED)
{
res = NETWORK_DETECTION_FAILED;
goto out;
}
}
}
res = NETWORK_OK;
}else
#endif
{
if (LINK_DOWN == g_phy_stat.ether && LINK_DOWN == g_phy_stat.wlan)
{
res = NETWORK_PHY_DOWN;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_GATEWAY].res)
{
res = NETWORK_GATEWAY_FAILED;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_INTERNET1].res && DIAGNOSE_FAILED == g_network_array[NET_INTERNET2].res)
{
if (DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].res &&
DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].tel_res)
{
res = NETWORK_FAILED;
goto out;
}
res = NETWORK_OK;
goto out;
}
if (DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].res && DIAGNOSE_FAILED == g_network_array[NET_BASE_CLOUD].tel_res)
{
res = NETWORK_CLOUD_FAILED;
goto out;
}
res = NETWORK_OK;
}
out:
ds_read(LINK_STATUS_PATH, (U8 *)&link_status, sizeof(link_status));
if (link_status.internet_status != res)
{
DIAGNOSE_ERROR("internet status has changed: [%d] ===> [%d]", link_status.internet_status, res);
link_status.internet_status = res;
}
ds_write(LINK_STATUS_PATH, (U8 *)&link_status, sizeof(link_status));
return OK;
}
/***********************************************************************************************
*函数：get_result
*描述：web轮询诊断结果
*参数：
type：本次诊断的参数，每一位代表一个诊断项
*返回值：
***********************************************************************************************/
LOCAL S32 get_result(JSON_OBJPTR jso_result, char* type, int cli_index)
{
JSON_OBJPTR data_obj = NULL;
JSON_OBJPTR data_array = NULL;
int index = 0;
int finish = 0;
char buffer[PARSE_BUFFER_LEN] = {'\0'};
char item_status[DIAGNOSE_BIT_LEN + 1] = {'\0'};
if (NULL == type || NULL == jso_result)
{
return SLP_EINVARG;
}
memset(item_status, '0', DIAGNOSE_BIT_LEN);
if (NULL == (data_array = jso_new_array()))
{
DIAGNOSE_WARNING("Lookup failed, jso_new_array failed.");
return SLP_ENOMEMORY;
}
/*无线信号*/
if (SET_TEST == type[DIAGNOSE_WIRELESS] && NULL != (data_obj = jso_new_obj()))
{
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_connect_info.rssi);
jso_add_string(data_obj, "link_type", g_connect_info.link_type);
jso_add_string(data_obj, "rssi", buffer);
jso_add_string(data_obj, "ssid", g_connect_info.ssid);
jso_obj_add(jso_result, "wireless", data_obj);
if (TESTED == g_connect_info.status)
{
item_status[DIAGNOSE_WIRELESS] = ITEM_FINISH;
}
else if (TESTING == g_connect_info.status)
{
item_status[DIAGNOSE_WIRELESS] = ITEM_TESTING;
}
}
/*网络诊断*/
for (index = 0; index < ADDR_COUNTS; index++)
{
if (SET_TEST == type[g_network_array[index].params_code] && NULL != (data_obj = jso_new_obj()))
{
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_network_array[index].res);
jso_add_string(data_obj, "ip", g_network_array[index].str_ip);
jso_add_string(data_obj, "domain", g_network_array[index].str_domain);
jso_add_string(data_obj, "res", buffer);
if (1 == g_network_array[index].do_telnet)
{
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_network_array[index].tel_res);
jso_add_string(data_obj, "telnet", buffer);
}
jso_obj_add(jso_result, g_network_array[index].para_name, data_obj);
if (TESTED == g_network_array[index].status)
{
item_status[g_network_array[index].params_code] = ITEM_FINISH;
}
}
}
/*存储诊断*/
if(SET_TEST == type[DIAGNOSE_STORAGE] && NULL != (data_obj = jso_new_obj()))
{
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_storage_info.upload_enable.enable);
jso_add_string(data_obj, "cstg_enable", buffer);
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_storage_info.uploading.is_uploading);
jso_add_string(data_obj, "cstg_uploading", buffer);
jso_add_string(data_obj, "hd_status", g_storage_info.available);
jso_add_string(data_obj, "total", g_storage_info.size.total);
jso_add_string(data_obj, "free", g_storage_info.size.free);
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", 3);
jso_add_string(data_obj, "record_type", buffer);
jso_add_string(data_obj, "record_duration", g_storage_info.recorded_time);
jso_add_string(data_obj, "hd_lifespan", g_storage_info.sd_lifespan);
jso_obj_add(jso_result, "storage", data_obj);
if (TESTED == g_storage_info.status)
{
item_status[DIAGNOSE_STORAGE] = ITEM_FINISH;
}
}
/*固件诊断*/
if(SET_TEST == type[DIAGNOSE_FIRMWARE] && NULL != (data_obj = jso_new_obj()))
{
firmware_diagnose(&g_firmware_info);
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_firmware_info.fw_new_
notify);
jso_add_string(data_obj, "new_fw", buffer);
jso_obj_add(jso_result, "firmware", data_obj);
if (TESTED == g_firmware_info.status)
{
item_status[DIAGNOSE_FIRMWARE] = ITEM_FINISH;
}
}
/*安全诊断*/
if(SET_TEST == type[DIAGNOSE_SAFETY] && NULL != (data_obj = jso_new_obj()))
{
memset(buffer, 0, PARSE_BUFFER_LEN);
snprintf(buffer, PARSE_BUFFER_LEN, "%d", g_video_encryption.is_encryption);
jso_add_string(data_obj, "is_encrypted", buffer);
jso_obj_add(jso_result, "encrypted", data_obj);
if (TESTED == g_video_encryption.status)
{
item_status[DIAGNOSE_SAFETY] = ITEM_FINISH;
}
}
for (index = 0; index < DIAGNOSE_BIT_LEN; index++)
{
if (SET_TEST == type[index] && ITEM_FINISH != item_status[index])
{
break;
}
}
if (DIAGNOSE_BIT_LEN == index || AUTO_STOP == g_client_array[cli_index].is_stop)
{
finish = 1;
goto exit;
}
g_client_array[cli_index].time_out++;
if (g_client_array[cli_index].time_out > CLIENT_GET_TIMEOUT)
{
finish = 1;
inet_del_timer(g_client_array[cli_index].timerid);
memset(&g_client_array[cli_index], 0, sizeof(TASK_STRUCT));
}
exit:
jso_add_string(jso_result, "status", item_status);
jso_add_string(jso_result, "finish", finish == 1 ? "1" : "0");
return SLP_ENONE;
}
void diagnose_timer_handle(S32 param)
{
DIAGNOSE_INFO("Ping test timeout!");
diagnose_stop();
}
void init_global_var()
{
memset(&g_connect_info, 0, sizeof(g_connect_info));
memset(&g_storage_info, 0, sizeof(g_storage_info));
memset(&g_firmware_info, 0, sizeof(g_firmware_info));
memset(&g_video_encryption, 0, sizeof(g_video_encryption));
memset(g_network_array, 0, sizeof(NETWORK_STRUCT) * ADDR_COUNTS);
memset(g_client_array, 0, sizeof(TASK_STRUCT) * MAX_CLIENTS_NUM);
memset(&g_phy_stat, 0, sizeof(PHY_STATUS));
}
/***********************************************************************************************
*函数：
*描述：来自客户端的诊断，如web、App
*参数：
*返回值：
***********************************************************************************************/
LOCAL S32 client_diagnose()
{
if (0 == g_task_running)
{
memset(&g_connect_info, 0, sizeof(g_connect_info));
memset(&g_storage_info, 0, sizeof(g_storage_info));
memset(&g_firmware_info, 0, sizeof(g_firmware_info));
memset(&g_video_encryption, 0, sizeof(g_video_encryption));
request_fw_status();
check_signal_quality(&g_connect_info);
g_connect_info.status = TESTED;
storage_diagnose(&g_storage_info);
g_storage_info.status = TESTED;
firmware_diagnose(&g_firmware_info);
g_firmware_info.status = TESTED;
safety_diagnose(&g_video_encryption);
g_video_encryption.status = TESTED;
g_task_running = 1;
}
if (ERROR == g_diagnose_timerid)
{
network_diagnose();
}
return OK;
}
void phy_status_change(void)
{
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
LTE_CONFIG_INFO_DATA lte_config = {0};
ds_read(LTE_INFO_DATA_PATH, (U8*)<e_config, sizeof(LTE_CONFIG_INFO_DATA));
#endif
ds_read(PHY_STATUS_PATH, &g_phy_stat, sizeof(PHY_STATUS));
if (LINK_DOWN == g_phy_stat.ether && LINK_DOWN == g_phy_stat.wlan)
{
DIAGNOSE_DEBUG("catch phy link down");
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
if(lte_config.internet_wired_enable == 1 || (lte_config.internet_wired_enable == 2 && lte_config.auto_switch_wired == 1))
#endif
{
diagnose_stop();
}
}
}
/*开启自诊断*/
S32 diagnose_operation_handle(dms_handler_t *handler, U8 *mbuf, U32 mlen, U32 sender_dms_id)
{
/*开启网络诊断*/
g_is_auto_diagnose = 1;
if (ERROR == g_diagnose_timerid)
{
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
NET_DIAGNOSE_MSG *msg = NULL;
if(mbuf != NULL && mlen == sizeof(NET_DIAGNOSE_MSG))
{
msg = (NET_DIAGNOSE_MSG*)mbuf;
if(msg->model == MODEL_LTE)
{
g_is_lte_diagnose = 1;
g_is_other_model_diagnose = 0;
}else
{
g_is_other_model_diagnose = 1;
}
}else
{
g_is_other_model_diagnose = 1;
}
#endif
network_diagnose();
}
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
else if(ERROR != g_diagnose_timerid)
{
NET_DIAGNOSE_MSG *msg = NULL;
if(mbuf != NULL && mlen == sizeof(NET_DIAGNOSE_MSG))
{
msg = (NET_DIAGNOSE_MSG*)mbuf;
if(msg->model == MODEL_LTE)
{
LTE_NETWORK_DIAGNOSE_RPL_MSG msg_sendto_lte = {0};
int res = TIMER_NOT_OVER;
DIAGNOSE_ERROR("send lte model diagnose msg out id:%d", res);
msg_sendto_lte.res = res;
msg_send(LTE_NETWORK_DIAGNOSE_RPL_MID, (U8 *)&msg_sendto_lte, sizeof(msg));
}
}
}
#endif
return OK;
}
void client_array_reclaim_handle(S32 param)
{
if (param >= 0 && param < MAX_CLIENTS_NUM)
{
inet_del_timer(g_client_array[param].timerid);
memset(&g_client_array[param], 0, sizeof(TASK_STRUCT));
}
}
S32 get_empty_client_ctx(int* client_index)
{
int index = 0;
if (NULL == client_index)
{
return ERROR;
}
for (index = 0; index < MAX_CLIENTS_NUM; index++)
{
if (0 == strlen(g_client_array[index].instance_id))
{
g_client_array[index].timerid = inet_add_timer(client_array_reclaim_handle, index, CLIENT_RECLAIM_INTERVAL, EXECUTE_SINGLE);
if (ERROR == g_client_array[index].timerid)
{
return ERROR;
}
*client_index = index;
return OK;
}
}
return ERROR;
}
S32 get_client_instance_by_id(const char* instance_id, int* cli_index)
{
int index = 0;
if (NULL == instance_id || NULL == cli_index)
{
return ERROR;
}
for (index = 0; index < MAX_CLIENTS_NUM; index++)
{
if (0 == strlen(g_client_array[index].instance_id))
{
continue;
}
if (0 == strcmp(g_client_array[index].instance_id, instance_id))
{
*cli_index = index;
return OK;
}
}
return ERROR;
}
S32 valid_param(const char* type)
{
int type_len = 0;
int index = 0;
if (NULL == type)
{
return SLP_EINVARG;
}
type_len = strlen(type);
if (0 == type_len || type_len > DIAGNOSE_BIT_LEN)
{
return SLP_EINVARG;
}
for (index = 0; index < type_len; index++)
{
if (type[index] != '0' && type[index] != '1')
{
return IPC_DIAGNOSE_TYPE_NOT_SUPPORT;
}
if (index > DIAGNOSE_MAX && SET_TEST == type[index])
{
return IPC_DIAGNOSE_TYPE_NOT_SUPPORT;
}
}
return SLP_ENONE;
}
/***********************************************************************************************
*函数：start_oneclick_diagnose_callback
*描述：快速诊断
*参数：读取诊断id,执行对应诊断内容
*返回值：
***********************************************************************************************/
S32 start_oneclick_diagnose_callback(DS_HANDLE_CONTEXT *context, JSON_OBJPTR param)
{
const char* ptr = NULL;
char instance_id[DIAGNOSE_ID_LEN + 1] = {'\0'};
U64 time_stamp = 0;
int rand_num = 0;
int error_code = SLP_ENONE;
int client_index = 0;
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
LTE_CONFIG_INFO_DATA lte_config = {0};
LTE_CONFIG_NET_DETECTION net_det = {0};
#endif
if (!context || !context->res_obj || !context->req_obj)
{
error_code = SLP_ESYSTEM;
goto out;
}
ptr = jso_obj_get_string_origin(param, "type");
if (NULL == ptr)
{
error_code = IPC_DIAGNOSE_PARAMS_INVALID;
goto out;
}
error_code = valid_param(ptr);
if (SLP_ENONE != error_code)
{
goto out;
}
if (ERROR == get_empty_client_ctx(&client_index))
{
error_code = IPC_DIAGNOSE_TASK_BUSY;
goto out;
}
#ifdef CONFIG_MOBILE_ACCESS_SET_SUPPORT
if(0 == ds_read(LTE_INFO_DATA_PATH, (U8*)<e_config, sizeof(LTE_CONFIG_INFO_DATA)))
{
DIAGNOSE_ERROR("read config path %s fail.", LTE_INFO_DATA_PATH);
error_code = IPC_DIAGNOSE_INTERNAL_ERROR;
goto out;
}
if(0 == ds_read(LTE_NET_DET_PATH, (U8*)&net_det, sizeof(LTE_CONFIG_NET_DETECTION)))
{
DIAGNOSE_ERROR("read config path %s fail.", LTE_NET_DET_PATH);
error_code = IPC_DIAGNOSE_INTERNAL_ERROR;
goto out;
}
if((lte_config.internet_wired_enable == 0 || (lte_config.internet_wired_enable == 2 && lte_config.auto_switch_wired == 0))
&& net_det.ping_enable == 1)
{
goto out;
}else
#endif
{
if (ERROR == client_diagnose())
{
goto out;
}
}
/*返回诊断id*/
srand((U32)time(NULL));
time_stamp = nvmp_get_us();
rand_num = rand() % 10000;
snprintf(instance_id, DIAGNOSE_ID_LEN, "%llu-%u", time_stamp, rand_num);
g_client_array[client_index].time_out = 0;
g_client_array[client_index].is_stop = 0;
strncpy(g_client_array[client_index].instance_id, instance_id, DIAGNOSE_ID_LEN);
jso_add_string(context->res_obj, "diagnose_id", instance_id);
return SLP_ENONE;
out:
snprintf(instance_id, DIAGNOSE_ID_LEN, "%d", 0);
jso_add_string(context->res_obj, "diagnose_id", instance_id);
return error_code;
}
S32 diagnose_result_callback(DS_HANDLE_CONTEXT *context, JSON_OBJPTR param)
{
const char* ptr = NULL;
char str_type[DIAGNOSE_BIT_LEN + 1] = {'\0'}; /*诊断内容*/
char instance_id[DIAGNOSE_ID_LEN + 1] = {'\0'}; /*诊断实例id*/
int error_code = SLP_ENONE;
int cli_index = 0;
if (!context || !context->res_obj || !context->req_obj)
{
return SLP_ESYSTEM;
}
if (NULL == (ptr = jso_obj_get_string_origin(param, "diagnose_id")))
{
return IPC_DIAGNOSE_PARAMS_INVALID;
}
strncpy(instance_id, ptr, DIAGNOSE_ID_LEN);
if (ERROR == get_client_instance_by_id(instance_id, &cli_index))
{
return IPC_DIAGNOSE_ID_NOT_FOUND;
}
if (NULL == (ptr = jso_obj_get_string_origin(param, "type")))
{
return IPC_DIAGNOSE_PARAMS_INVALID;
}
error_code = valid_param(ptr);
if (SLP_ENONE != error_code)
{
return error_code;
}
strncpy(str_type, ptr, DIAGNOSE_BIT_LEN);
return get_result(context->res_obj, str_type, cli_index);
}
S32 stop_oneclick_diagnose_callback(DS_HANDLE_CONTEXT *context, JSON_OBJPTR param)
{
char instance_id[DIAGNOSE_ID_LEN + 1] = {'\0'};
const char* ptr = NULL;
int cli_index = 0;
if (!context || !context->res_obj || !context->req_obj)
{
return SLP_ESYSTEM;
}
ptr = jso_obj_get_string_origin(param, "diagnose_id");
if (NULL == ptr)
{
return IPC_DIAGNOSE_PARAMS_INVALID;
}
strncpy(instance_id, ptr, DIAGNOSE_ID_LEN);
if (ERROR == get_client_instance_by_id(instance_id, &cli_index))
{
return IPC_DIAGNOSE_ID_NOT_FOUND;
}
g_client_array[cli_index].is_stop = AUTO_STOP;
if (g_client_array[cli_index].timerid > 0)
{
inet_del_timer(g_client_array[cli_index].timerid);
}
memset(&g_client_array[cli_index], 0, sizeof(TASK_STRUCT));
DIAGNOSE_DEBUG("stop get result .......");
return SLP_ENONE;
}
重点去关注，这函数是不是填充
地址，第一位
地址留给了网关，然后他怎么去获取的网关？我主要关注在有线部分， 234位的外网都正常，现在我要修改功能是，读取网关时，我的ip是在4G那边的，他会默认读到4G的网关，首先找到具体读网关的操作在哪里，然后，能否指定读eth0的网关？
本文详细介绍了支付宝通知系统的两大类型：服务器通知与页面跳转通知，解释了它们的区别、实现方式及注意事项，帮助开发者正确配置支付宝通知。
扫一扫
321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
