/*****************************************************************************
函 数 名 : ws_add_res_struct_string
功能描述 : 该接口提供给web service钩子函数，用于添加web service结果参数
本函数增加一个字符串类型结构参数
输入参数 : ws_env ---- web service执行环境
ws_req_res ---- web service参数结构
name ---- 参数名称，外面分配空间
value ---- 参数值
输出参数 : 无
返 回 值 : ERROR_SUCCESS 添加成功
ERROR_SYSTEM 添加失败
调用函数 :
被调函数 :
============================================================================
修改历史 :
1.日 期 : 2008年8月8日
修改内容 : 新生成函数
*****************************************************************************/
u_int32_t ws_add_res_struct_string(WS_ENV* ws_env, WS_REQ_RES* ws_req_res,
const char* name, const char* value)
{
WS_PARA *para;
//http_out("\nws_add_res_struct_string:%s, %s", name, value);
if((NULL == ws_env) || (NULL == ws_req_res))
{
return ERROR_SYSTEM;
}
if (ws_req_res->res_count >= MAX_RES_STRUCT_PARA_COUNT)
{
WEB_SEND_DEBUG_s("The max response parameter is reached.");
return ERROR_SYSTEM;
}
para = &(ws_req_res->response[ws_req_res->res_count++]);
para->type = WS_PARA_TYPE_STRING;
para->name = ws_strdup(ws_env, name);
para->data = ws_strdup(ws_env, value);
return ERROR_SUCCESS;
}
int ws__getDnsmasqInfo(WS_ENV* ws_env, struct ws__getDnsmasqInfoResponse *ret)
{
CONFIG * cfg = NULL;
cfg = config_load(CFG_DNS_PATH);
if(NULL == cfg)
{
return ws_send_soap_error(ws_env, "Open dns config file failed.");
}
if(config_getint(cfg, "dnsmasq_switch", 0))
{
ret->ret.dnsmasqstat = ws_strdup(ws_env, "enable");
}
else
{
ret->ret.dnsmasqstat = ws_strdup(ws_env, "disable");
}
config_free(cfg);
return WS_OK;
}
/*******************************************************************************
函数名称 : ws__getFluxConfig
功能描述 : 获得流量分析配置
输入参数 : 无
输出参数 : 无
返 回 值 : WS_OK ----操作成功
flux_manage_error_code ----操作失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : zhangfaqi
修改目的 : 创建函数
修改日期 : 2011-4-30
*******************************************************************************/
s32 ws__getFluxConfig(WS_ENV* ws_env, struct ws__getFluxConfigResponse *ret)
{
sqlite3 *db = NULL;
sqlite3_res res;
s32 ws_ret = WS_OK;
s32 sql_ret = SQLITE_OK;
const s8* err_info;
s8 *tmpStr;
db = sqlite3_open_ex(1, FLUX_MANAGE_DBFILE);
if ( NULL == db )
{
ws_ret = ERR_FLUX_MANAGE_OPEN_DB_FAILD;
goto label_ret;
}
/* 查询流量是否开启配置 */
snprintf(g_sqlite_sql_buf, SQLITE_SQL_BUF_SIZE,
"SELECT * FROM " FLUX_MANAGE_TAB_CONFIG);
if ( SQLITE_OK != sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res) )
{
ws_ret = ERR_FLUX_MANAGE_EXEC_SQL_FAILD;
goto label_ret;
}
/* 数据库只有一条配置，所以取第一条即可 */
sql_ret += sqlite3_get_s32_ex(res, 0, FLUX_MANAGE_CONFIG_ENABLE, &(ret->ret.flag));
sql_ret += sqlite3_get_s32_ex(res, 0, FLUX_MANAGE_CONFIG_TYPE, &(ret->ret.logType));
sql_ret += sqlite3_get_s32_ex(res, 0, FLUX_MANAGE_CONFIG_PORT, &(ret->ret.serverPort));
sql_ret += sqlite3_get_str_ex(res, 0, FLUX_MANAGE_CONFIG_IP, &tmpStr);
ret->ret.serverIp = ws_strdup(ws_env, tmpStr);
if ( SQLITE_OK != sql_ret )
{
ws_ret = ERR_FLUX_MANAGE_GET_RES_FAILD;
goto label_ret;
}
label_ret:
sqlite3_res_free_ex(res);
res = NULL;
sqlite3_close_ex(db);
db = NULL;
if (WS_OK != ws_ret)
{
err_info = flux_manage_error_str(ws_ret);
return ws_send_soap_error(ws_env, err_info);
}
return WS_OK;
}
/******************************************************************************
函数名称: ws__mldEnableIfGet
功能描述: 取得mld显示信息
输入参数: ret:结果集
输出参数: ret:结果集
返 回 值: 0表示返回成功
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者: 刘晓贺
修改目的: 新生成函数
修改日期: 2011-2-14
*******************************************************************************/
s32 ws__mldEnableIfGet(WS_ENV * ws_env, struct ws__getIp6McastMldEnableIfResponse *ret)
{
s32 i = 0;
s32 num = 0;
s8 *ifname = NULL;
s32 result = 0;
sqlite3 *db = NULL;
sqlite3_res res = NULL;
struct Ip6McastMldEnableIf *data = NULL;
db = sqlite3_open_ex(1, IP_MC_CFG_DB);
if(NULL == db)
{
return ws_send_soap_error(ws_env, "open basic db failed!");
}
result = sqlite3_exec_query_ex(db, "select count(*) as count from tb_basic_interface_info;", &res);
if(SQLITE_OK != result)
{
sqlite3_close_ex(db);
return ws_send_soap_error(ws_env, "sqlite3_exec_query_ex error!");
}
/*获取当前数据库中的记录数*/
sqlite3_get_s32_ex(res, 0, "count", &num);
/*释放结果集，多次查询时，每次都需要释放*/
sqlite3_res_free_ex(res);
res = NULL;
data = (struct Ip6McastMldEnableIf *)ws_malloc(ws_env, num * sizeof(struct Ip6McastMldEnableIf));
result = sqlite3_exec_query_ex(db, "select * from tb_basic_interface_info;", &res);
if(SQLITE_OK != result)
{
sqlite3_close_ex(db);
return ws_send_soap_error(ws_env, "sqlite3_exec_query_ex error!");
}
for(i = 0; i < num; i++)
{
sqlite3_get_str_ex(res, i, "ifname", &ifname);
data[i].ifname = ws_strdup(ws_env, ifname);
}
/*释放结果集，多次查询时，每次都需要释放*/
sqlite3_res_free_ex(res);
res = NULL;
sqlite3_close_ex(db);
ret->ret.sum = num;
ret->ret.res_USCOREcount = num;
ret->ret.__size = num;
ret->ret.__ptrres = data;
return SQLITE_OK;
}
s32 ws__getAvSigsType(WS_ENV *soap, struct ws__getAvSigsListType *ret)
{
sqlite3 *dba_con = NULL;
sqlite3_res dba_res = NULL;
u32 count = 0;
u32 i = 0;
s8 *tmp = NULL;
struct AvSigsType *Info = NULL;
dba_con = sqlite3_open_ex(1, AV_DESC_DBFILE);
if (NULL == dba_con)
{
return WS_OK;
}
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "SELECT COUNT(*) AS count FROM tb_av_description_category;");
sqlite3_exec_query_ex(dba_con, g_sqlite_sql_buf, &dba_res);
sqlite3_get_u32_ex(dba_res, 0, "count", &count);
ret->ret.sum = (s32)count;
ret->ret.res_USCOREcount = ret->ret.__size = (s32)count;
if(0 == count)
{
goto label_ret;
}
Info = (struct AvSigsType *)ws_malloc(soap, count * sizeof(struct AvSigsType));
if(NULL == Info)
{
goto label_ret;
}
ret->ret.__ptrres = Info;
sqlite3_res_free_ex(dba_res);
dba_res = NULL;
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "SELECT * FROM tb_av_description_category;");
sqlite3_exec_query_ex(dba_con, g_sqlite_sql_buf, &dba_res);
for(i = 0; i < count; i++)
{
sqlite3_get_s32_ex(dba_res, (s32)i, "category_id", &Info[i].value);
sqlite3_get_str_ex(dba_res, (s32)i, "category_name", &tmp);
Info[i].name= ws_strdup(soap, tmp);
}
label_ret:
sqlite3_res_free_ex(dba_res);
dba_res = NULL;
sqlite3_close_ex(dba_con);
dba_con = NULL;
return WS_OK;
}
/*******************************************************************************
函数名称 : cwmp_node_get_TrapDestination
功能描述 : 取得Trap接收主机的IP
输入参数 : ws_env 运行环境
输出参数 : get_value 返回值
get_type 返回类型
返 回 值 : 执行成功返回ERR_SUCCESS
否则返回失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 雷宁
修改目的 : 新函数
修改日期 : 2010-03-26
*******************************************************************************/
u32 cwmp_node_get_TrapDestination(WS_ENV* ws_env, s8** get_value, u32 *get_type)
{
char str[STRSIZE]={0};
if(!ERROR_SUCCESS == getSnmpTrapDesIp(str))
{
return ERR_CWMP_INTERNAL;
}
*get_value = ws_strdup(ws_env, str);
*get_type = CWMP_VALUE_TYPE_STRING;
return ERROR_SUCCESS;
}
/*******************************************************************************
函数名称 : cwmp_node_get_ReadWriteCommunity
功能描述 : 取得SNMP读写口令
输入参数 : ws_env 运行环境
输出参数 : get_value 返回值
get_type 返回类型
返 回 值 : 执行成功返回ERR_SUCCESS
否则返回失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 雷宁
修改目的 : 新函数
修改日期 : 2010-03-16
*******************************************************************************/
u32 cwmp_node_get_ReadWriteCommunity(WS_ENV* ws_env, s8** get_value, u32 *get_type)
{
char str[STRSIZE]={0};
if(!ERROR_SUCCESS == snmp_get_sysRwCommon(str, STRSIZE))
{
return ERR_CWMP_INTERNAL;
}
*get_value = ws_strdup(ws_env, str);
*get_type = CWMP_VALUE_TYPE_STRING;
return ERROR_SUCCESS;
}
/*******************************************************************************
函数名称 : cwmp_node_get_contract
功能描述 : 取得SNMP联系人信息
输入参数 : ws_env 运行环境
输出参数 : get_value 返回值
get_type 返回类型
返 回 值 : 执行成功返回ERR_SUCCESS
否则返回失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 雷宁
修改目的 : 新函数
修改日期 : 2010-03-16
*******************************************************************************/
u32 cwmp_node_get_contract(WS_ENV* ws_env, s8** get_value, u32 *get_type)
{
char str[STRSIZE]={0};
if(!ERROR_SUCCESS == snmp_get_syscontact(str, STRSIZE))
{
return ERR_CWMP_INTERNAL;
}
*get_value = ws_strdup(ws_env, str);
*get_type = CWMP_VALUE_TYPE_STRING;
return ERROR_SUCCESS;
}
/*****************************************************************************
函 数 名 : ws_add_req_para_string
功能描述 : 该接口提供给display/submit流程，用于调用web service
本函数增加一个字符串类型请求参数
字符串空间在外面分配
输入参数 : ws_env ---- web service执行环境
ws_req_res ---- web service参数结构
name ---- 参数名称，外面分配空间
value ---- 参数值
输出参数 : 无
返 回 值 : ERROR_SUCCESS 添加成功
ERROR_SYSTEM 添加失败
调用函数 :
被调函数 :
============================================================================
修改历史 :
1.日 期 : 2008年8月8日
修改内容 : 新生成函数
*****************************************************************************/
u_int32_t ws_add_req_para_string(WS_ENV* ws_env, WS_REQ_RES* ws_req_res,
const char* name, const char* value)
{
WS_PARA *para;
if((NULL == ws_env) || (NULL == ws_req_res))
{
return ERROR_SYSTEM;
}
if (ws_req_res->req_count >= MAX_REQ_PARA_COUNT)
{
char err_string[512] = {0};
snprintf(err_string, sizeof(err_string), "The max number of web service parameter is %d", MAX_REQ_PARA_COUNT);
SubEnv__set_err(err_string);
return ERROR_SYSTEM;
}
para = &(ws_req_res->request[ws_req_res->req_count++]);
para->type = WS_PARA_TYPE_STRING;
para->name = ws_strdup(ws_env, name);
para->data = ws_strdup(ws_env, value);
return ERROR_SUCCESS;
}
/*****************************************************************************
函 数 名 : tinfotostatus
功能描述 : 交换机：把后两个结构体的值赋给第一个结构体。现定每个聚合组最多8个物理端口，因此list长度为1024存ifindex列表远够。
输入参数 : struct port_aggr_bondInfo* aggr_Info ---- 赋值的结构体
struct port_aggr_statusInfo* bond_Info ---- 赋值的结构体
输出参数 : struct AggrStatus* aggrStatus ---- 被赋值结构体
返 回 值 : ERR_OK ---- 执行成功
ws_new_soap_fault ---- 执行失败
-----------------------------------------------------------------------------
最近一次修改记录:
修改作者: liuguang
修改目的: 生成新函数
修改日期: 2009年9月30日
*****************************************************************************/
void tinfotostatus(WS_ENV* soap, struct AggrStatus* aggrStatus, struct port_aggr_bondInfo* aggr_Info, struct port_aggr_statusInfo* bond_Info)
{
s8 name[IFNAMSIZ];
char iflist[1024];
s8 dev_id[32];
aggrStatus->aggrID = (s32)aggr_Info->aggrID;
aggrStatus->aggrType = (s32)aggr_Info->aggrType;
aggrStatus->aggrHash = (s32)aggr_Info->aggrHash;
aggrStatus->aggrName = ws_strdup(soap, aggr_Info->aggrName);
snprintf(dev_id, sizeof(dev_id), "%X,%02X:%02X:%02X:%02X:%02X:%02X", bond_Info->aggrDevID.sys_priority,
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[0],
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[1],
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[2],
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[3],
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[4],
bond_Info->aggrDevID.sys_mac_addr.mac_addr_value[5]);
aggrStatus->aggrDevID1 = ws_strdup(soap, dev_id);
if(BOND_STATIC == aggr_Info->aggrType)
{
aggrStatus->aggrDevID2 = ws_strdup(soap, "------");
}
else
{
snprintf(dev_id, sizeof(dev_id), "%X,%02X:%02X:%02X:%02X:%02X:%02X", bond_Info->partner_aggrDevID.sys_priority,
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[0],
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[1],
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[2],
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[3],
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[4],
bond_Info->partner_aggrDevID.sys_mac_addr.mac_addr_value[5]);
aggrStatus->aggrDevID2 = ws_strdup(soap, dev_id);
}
/* 不存在或未添加 */
if (0xFFFF == bond_Info->min_port || 0xFFFE == bond_Info->min_port)
{
aggrStatus->aggrMinPort = "";
}
else
{
snprintf(name, sizeof(name), "%d", IFM_GET_ETH_IFINDEX(bond_Info->min_port));
aggrStatus->aggrMinPort = ws_strdup(soap, name);
}
iflist[0] = '\0';
port_aggr_u8toeth_string(iflist, bond_Info->select_ports);
aggrStatus->aggrSelPort = ws_strdup(soap, iflist);
iflist[0] = '\0';
port_aggr_u8toeth_string(iflist, bond_Info->unselect_ports);
aggrStatus->aggrUnsPort = ws_strdup(soap, iflist);
return;
}
s32 ws__getBgpGlobalInfo(WS_ENV * ws_env, s32 afi, s32 safi, struct BgpGlobalInfoRespone * ret)
{
web_bgp_global_info_t info;
memset(ret,0,sizeof(struct BgpGlobalInfoRespone));
if( 1 != socket_api_request(WEB_BGP_APICMD_GET_GLO,NULL,0,&info,sizeof(web_bgp_global_info_t)) )
return ws_send_soap_error(ws_env,"send getBgpGlobalInfo command error!");
ret->ret.state = info.state;
ret->ret.asid = info.asid ;
ret->ret.disEBGP=info.disEBGP;
ret->ret.disIBGP=info.disIBGP;
ret->ret.disLOCAL=info.disLOCAL;
ret->ret.settype= info.settype;
ret->ret.ebgpmaxpath = info.ebgpmaxpath;
ret->ret.ibgpmaxpath = info.ibgpmaxpath;
ret->ret.grState= info.grState;
ret->ret.grRestart = info.grRestartTime;
ret->ret.grStale = info.grStaleTime ;
ret->ret.rtid = ws_strdup(ws_env, inet_ntoa(info.rtid));
ret->ret.redis= ws_strdup(ws_env,(s8*)info.redis);
return WS_OK;
}
/*****************************************************************************
函 数 名 : ws__getLocalUserInfoSync
功能描述 : 本地用户远程同步
输入参数 : soap ---- web service执行环境
输出参数 : ret ---- 返回结果
返 回 值 : WS_OK ---- 执行成功
----------------------------------------------------------------------------
----
最近一次修改记录 :
修改作者 : 仇俊杰
修改目的 : 新添加函数
修改日期 : 2011-2-22
*****************************************************************************/
int ws__getLocalUserInfoSync(WS_ENV* ws_env, struct getLocalUserRemoteSyncResponse * ret)
{
CONFIG * cfg = NULL;
cfg = config_load(LOCAL_USER_CFG_PATH);
if (NULL == cfg)
{
return ws_send_soap_error (ws_env, "Open file failed!");
}
ret->ret.umcPort = config_getint(cfg, "umc_port", 80);
ret->ret.umcIp = ws_strdup (ws_env, config_get(cfg, "umc_ip", "127.0.0.1"));
config_free(cfg);
return WS_OK;
}
s32 ws__getBgpAggInfo(WS_ENV * ws_env,s32 afi, s32 safi, s32 nstart, s32 nsize, struct BgpAggInfoRespone * ret )
{
struct BgpAggInfo * out = NULL;
web_bgp_aggregate_info_t * info = (void*)buff;
s32 count ,i ;
s32 sum = 0 , max = 0;
u8 iptrans[INET6_ADDRSTRLEN];
u8 *ipret=NULL;
if( socket_api_write(WEB_BGP_APICMD_GET_AGG,NULL,0) < 0 )
return ws_send_soap_error(ws_env,"send command error!");
do{
count = socket_api_read(WEB_BGP_APICMD_GET_AGG,info,SOCKET_API_BUFFER_SIZE);
if( count <= 0 )
{
break;
}
if( max < sum + count )
{
void * tmp = ws_malloc(ws_env,(sum + count)*sizeof(struct BgpAggInfo));
if( out != NULL )
{
memcpy(tmp,out,sum * sizeof(struct BgpAggInfo));
ws_free(ws_env,out);
}
out = tmp ;
max = sum + count ;
}
for(i=0;i<count;i++)
{
ipret = (u8*)inet_ntop((s32)info[i].p.family,(void*)&info[i].p.u,(s8*)iptrans,INET6_ADDRSTRLEN);
if( ipret == NULL )
continue;
out[sum].addr = ws_strdup(ws_env,(s8*)ipret);
out[sum].mask = info[i].p.prefixlen;
out[sum].sonly= info[i].summary_only;
out[sum].asset=info[i].as_set;
sum++;
}
}while( ! socket_api_check_flag(SOCKET_API_FLAG_LASTONE) );
ret->ret.sum = sum ;
ret->ret.__ptrres = out ;
ret->ret.__size = sum ;
ret->ret.res_USCOREcount = sum ;
return WS_OK;
}
/*******************************************************************************
函数名称 : ws__getHotbConfig
功能描述 : 获取双机热备配置信息
输入参数 : soap ---- web service执行环境
输出参数 : ret ---- 返回结果
返 回 值 : WS_OK ---- 执行成功
soapFault ---- 执行失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 吕进
修改目的 : 双机热备配置页面整改
修改日期 : 2010年10月8日
*******************************************************************************/
int ws__getHotbConfig(WS_ENV* soap, struct ws__getHotbConfigResponse *ret)
{
int retcode;
struct hotb_config_s hotb_cfg;
s32 hotbakmode = 0;
retcode = hotb_get_config(&hotb_cfg);
//vsm
s8 vsm_port_name[INTERFACE_NAME_MAX_LENGTH] = {0};
s8* show_name;
s8 state[HOTB_STATE_LEN];
if( 0 == retcode)
{
// 根据双机热备配置信息，获取双机热备配置类型
if (HOTB_SWITCH_ON == hotb_cfg.hotb_switch && HOTB_SILENCE_MODE_ON == hotb_cfg.silenece_mode)
{
ret->ret.hotbakType = HOTB_SILENCE_HOTBAK;
}
else if (HOTB_SWITCH_NON_ON == hotb_cfg.hotb_switch && HOTB_NOT_SUPPORT_NO_SYMMETRY_ROUTE == hotb_cfg.supportNoSymmetryRoute)
{
ret->ret.hotbakType = HOTB_ORDINARY_HOTBAK;
}
else if (HOTB_SWITCH_ON == hotb_cfg.hotb_switch && HOTB_NOT_SUPPORT_NO_SYMMETRY_ROUTE == hotb_cfg.supportNoSymmetryRoute)
{
ret->ret.hotbakType = HOTB_ADVANCED_HOTBAK;
}
else if (HOTB_SWITCH_ON == hotb_cfg.hotb_switch && HOTB_SUPPORT_NO_SYMMETRY_ROUTE == hotb_cfg.supportNoSymmetryRoute)
{
ret->ret.hotbakType = HOTB_NON_SYMMETRY_HOTBAK;
}
else
{
ret->ret.hotbakType = HOTB_CLOSE;
}
ret->ret.ip = ws_strdup(soap, hotb_cfg.hotb_ip);
ifm_name2stack(hotb_cfg.hotb_ifname, vsm_port_name, sizeof(vsm_port_name), &show_name);
ret->ret.ifname = ws_strdup(soap, show_name);
hotb_get_bak_mod(&hotbakmode);
ret->ret.hotbakmode = hotbakmode;
ret->ret.syncname = ws_strdup(soap, hotb_cfg.sync_port);
}
else
{
ret->ret.hotbakType = HOTB_CLOSE;
ret->ret.ip = ws_strdup(soap, "");
ret->ret.ifname = ws_strdup(soap, "");
ret->ret.hotbakmode = 0;
}
hotb_silence_get_state(state);
ret->ret.state = ws_strdup(soap, state);
return WS_OK;
}
s32 rlt_get_rule_by_policyid(WS_ENV* soap,sqlite3 *db,struct RltRuleInfo *rule_info_list, u32 policyId)
{
s32 sql_ret = SQLITE_OK;
sqlite3_res res = NULL;
s32 res_row;
s8 * unit;
snprintf(g_sqlite_sql_buf, SQLITE_SQL_BUF_SIZE, "SELECT * FROM tb_rlimit_rule where policy_id=%u;", policyId);
sql_ret += sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
while ( SQLITE_OK == (sql_ret += sqlite3_res_next_ex(res, &res_row)) && SQLITE_RES_END != res_row )
{
sql_ret += sqlite3_get_s32_ex(res, res_row, "policy_id", &(rule_info_list[res_row].policyId));
sql_ret += sqlite3_get_s32_ex(res, res_row, "rule_id", &(rule_info_list[res_row].ruleId));
sql_ret += sqlite3_get_s32_ex(res, res_row, "app_group_id", &(rule_info_list[res_row].appId));
sql_ret += sqlite3_get_s32_ex(res, res_row, "cir", &(rule_info_list[res_row].cir));
if (SQLITE_OK != sql_ret)
{
break;
}
sql_ret += sqlite3_get_str_ex(res, res_row, "unit", &unit);
rule_info_list[res_row].unit = ws_strdup(soap,unit);
if (SQLITE_OK != sql_ret)
{
break;
}
}
sqlite3_res_free_ex(res);
res = NULL;
if (SQLITE_OK != sql_ret)
{
return ERROR_FAIL;
}
return ERROR_SUCCESS;
}
WsBool ws_bc_add_function(WsBc *bc, WsUInt8 *index_return, char *name,
WsUInt8 num_arguments, WsUInt8 num_locals,
WsUInt32 code_size, unsigned char *code)
{
WsBcFunction *nf;
/* First, add the function to the function pool. */
nf = ws_realloc(bc->functions,
(bc->num_functions + 1) * sizeof(WsBcFunction));
if (nf == NULL)
return WS_FALSE;
bc->functions = nf;
bc->functions[bc->num_functions].num_arguments = num_arguments;
bc->functions[bc->num_functions].num_locals = num_locals;
bc->functions[bc->num_functions].code_size = code_size;
bc->functions[bc->num_functions].code = ws_memdup(code, code_size);
if (bc->functions[bc->num_functions].code == NULL)
return WS_FALSE;
/* Save the index of the function. */
*index_return = bc->num_functions++;
/* For external functions (which have name), add a name entry to the
function name pool. */
if (name) {
WsBcFunctionName *nfn;
nfn = ws_realloc(bc->function_names,
((bc->num_function_names + 1)
* sizeof(WsBcFunctionName)));
if (nfn == NULL)
return WS_FALSE;
bc->function_names = nfn;
bc->function_names[bc->num_function_names].index = *index_return;
bc->function_names[bc->num_function_names].name = ws_strdup(name);
if (bc->function_names[bc->num_function_names].name == NULL)
return WS_FALSE;
bc->num_function_names++;
}
/* All done. */
return WS_TRUE;
}
/*****************************************************************************
函 数 名 : ws__getAcceptCtrlVlanInfo
功能描述 : 获取端口的接收控制vlan列表
输入参数 :
输出参数 :
返 回 值 : WS_OK ---- 执行成功
else ---- 执行失败
-----------------------------------------------------------------------------
最近一次修改记录:
修改作者: wuyang
修改目的: 生成新函数
修改日期: 2011年10月31日
*****************************************************************************/
int ws__getAcceptCtrlVlanInfo(WS_ENV* soap, struct ws_getAcceptVlanInfoResponse* ret)
{
u32 sys_error_code;
s32 count;
s32 i;
s8 vlan_str[SMART_LINK_VLAN_LEN] ={0};
accept_vlan_s* accept_vlan;
struct AcceptVlanInfo* AcceptVlan;
sys_error_code = smart_link_dba_get_accept_vlan_count(&count);
if (ERROR_SUCCESS != sys_error_code)
{
return ws_send_soap_error(soap, smart_link_error_str(sys_error_code));
}
if (0 == count)
{
return WS_OK;
}
accept_vlan = (accept_vlan_s*)ws_malloc(soap, (u32)count * sizeof(accept_vlan_s));
if (NULL == accept_vlan)
{
return ws_send_soap_error(soap, smart_link_error_str(ERR_SMART_LINK_FAIL_MALLOC));
}
AcceptVlan = (struct AcceptVlanInfo*)ws_malloc(soap, (u32)count * sizeof(struct AcceptVlanInfo));
if (NULL == AcceptVlan)
{
return ws_send_soap_error(soap, smart_link_error_str(ERR_SMART_LINK_FAIL_MALLOC));
}
sys_error_code = smart_link_dba_get_accept_vlan_info(count, accept_vlan);
if (ERROR_SUCCESS != sys_error_code)
{
return ws_send_soap_error(soap, smart_link_error_str(sys_error_code));
}
for (i = 0; i < count; i++)
{
AcceptVlan[i].AcceptPort = accept_vlan[i].ifindex;
vlan_bitmap_to_string(accept_vlan[i].accept_ctrl_vlan, vlan_str);
AcceptVlan[i].AcceptCtrlVlan = ws_strdup(soap, vlan_str);
}
ret->ret.sum = count;
ret->ret.res_USCOREcount = count;
ret->ret.__size = count;
ret->ret.__ptrres = AcceptVlan;
return WS_OK;
}
s32 ws__mailCfgget(WS_ENV *soap, struct ws__getpdfCfg *ret)
{
sqlite3 *dba_con = NULL;
sqlite3_res dba_res = NULL;
s8* tmp = NULL;
FILE *fp = NULL;
u8 buf[64] = {0};
dba_con = sqlite3_open_ex(1, "/config/db/ssa_cfg.db");
if (dba_con == NULL)
{
return WS_OK;
}
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "SELECT * FROM tb_pdf_mail_cfg");
sqlite3_exec_query_ex(dba_con, g_sqlite_sql_buf, &dba_res);
sqlite3_get_str_ex(dba_res, 0, "server_ip", &tmp);
ret->ret.serverIp = ws_strdup(soap, tmp);
sqlite3_get_str_ex(dba_res, 0, "mail_username", &tmp);
ret->ret.mailUsrname= ws_strdup(soap, tmp);
sqlite3_get_str_ex(dba_res, 0, "password", &tmp);
ret->ret.password= ws_strdup(soap, tmp);
sqlite3_get_str_ex(dba_res, 0, "mail_addr", &tmp);
ret->ret.mailAddr = ws_strdup(soap, tmp);
sqlite3_get_str_ex(dba_res, 0, "time", &tmp);
ret->ret.time = ws_strdup(soap, tmp);
sqlite3_res_free_ex(dba_res);
sqlite3_close_ex(dba_con);
fp = fopen("/tmp/pdfname", "r");
if (fp == NULL)
{
ret->ret.pdfName = ws_strdup(soap, "");
return WS_OK;
}
fread(buf, 64, 1, fp);
ret->ret.pdfName = ws_strdup(soap, (s8*)buf);
fclose(fp);
return WS_OK;
}
s32 ws__showBgpNeighbor(WS_ENV * ws_env,s32 afi, s32 safi,s32 nstart, s32 nsize,struct BgpShowNeighborResponse * ret)
{
s8 temp[SU_ADDRSTRLEN];
s32 count = 0 , i = 0;
s32 sum = 0 ;
s32 max = 0;
struct BgpShowNeighbor * out = NULL;
web_bgp_neighbor_show_info_t * info = (void*)buff;
if( socket_api_write(WEB_BGP_APICMD_SHOW_NBR,NULL,0) < 0 )
return ws_send_soap_error(ws_env,"send command error!");
do{
count = socket_api_read(WEB_BGP_APICMD_SHOW_NBR,info,SOCKET_API_BUFFER_SIZE);
if( count <= 0 )
{
break;
}
if( max < sum + count )
{
void * tmp = ws_malloc(ws_env,(sum + count)*sizeof(struct BgpShowNeighbor));
if( out != NULL )
{
memcpy(tmp,out,sum * sizeof(struct BgpShowNeighbor));
ws_free(ws_env,out);
}
out = tmp ;
max = sum + count ;
}
for(i=0;i<count;i++)
{
out[sum].hostip = ws_strdup(ws_env, sockunion2str(&(info[i].su), temp, SU_ADDRSTRLEN) ) ;
out[sum].asid = info[i].asid ;
out[sum].hostid = ws_strdup(ws_env,inet_ntoa(info[i].id));
out[sum].state = ws_strdup(ws_env,bgp_status_msg[(s32)info[i].state]);
out[sum].localinterface = ws_strdup(ws_env,inet_ntoa(info[i].nexthop));
out[sum].uptime = ws_strdup(ws_env,web_time_dump(info[i].t_uptime));
out[sum].overtime = ws_strdup(ws_env,web_time_dump(info[i].t_dead));
sum++;
}
}while( ! socket_api_check_flag(SOCKET_API_FLAG_LASTONE) );
ret->ret.sum = sum ;
ret->ret.__ptrres = out ;
ret->ret.__size = sum ;
ret->ret.res_USCOREcount = sum ;
return WS_OK;
}
/*******************************************************************************
函数名称 : cwmp_node_get_PeriodicInformTime
功能描述 : 取得CPE连接ACS的某一个绝对时间
输入参数 : ws_env 运行环境
输出参数 : get_value 返回值
get_type 返回类型
返 回 值 : 执行成功返回ERR_SUCCESS
否则返回失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 雷宁
修改目的 : 新函数
修改日期 : 2010-03-09
*******************************************************************************/
u32 cwmp_node_get_PeriodicInformTime(WS_ENV* ws_env, s8** get_value, u32 *get_type)
{
CONFIG * cfg = NULL;
const s8 *time_config = NULL;
s8 time_str[32] = {0};
time_t PeriodicInformTime;
struct tm *time_cur;
cfg = config_load(CWMP_CONF_FILE_PATH);
if (NULL != cfg)
{
time_config = config_get(cfg, "time", NULL);
if(NULL == time_config)
{
/* cft在上面load时已经分配空间，下面往配置文件写time时还会给分配空间，但并没有释放,
会存在内存泄漏，所以在这里释放空间并且重新加载配置文件*/
config_free(cfg);
cfg = config_load(CWMP_CONF_FILE_PATH);
time(&PeriodicInformTime);
time_cur = gmtime(&PeriodicInformTime);
if( NULL != time_cur)
{
snprintf(time_str,32,"%04d-%02d-%02d %02d:%02d:%02d",
(1900+time_cur->tm_year),(1+time_cur->tm_mon),time_cur->tm_mday,time_cur->tm_hour,time_cur->tm_min,time_cur->tm_sec);
time_str[strlen(time_str)]='\0';
}
cfg = config_set(cfg, "time", time_str);
config_store(cfg, CWMP_CONF_FILE_PATH);
}
else
{
snprintf(time_str,32,"%s",time_config);
}
}
*get_value = ws_strdup(ws_env, time_str);
*get_type = CWMP_VALUE_TYPE_STRING;
config_free(cfg);
return ERROR_SUCCESS;
}
s32 ws__securityZoneGetNames(WS_ENV *soap, s8 *vfwName, struct ws__getTextResponse *ret)
{
s32 ws_ret = WS_OK;
sqlite3 *db = NULL;
s8 sql[128+1];
sqlite3_res res = NULL;
s8 *tmp_str = NULL;
if (NULL == (db = sqlite3_open_ex(1, DATABASE_SECURITY_ZONE_PATH)))
{
ws_ret = ERROR_SECURITY_FAILEDOPEN;
goto label_ret;
}
if (vfwName && vfwName[0] != '\0')
snprintf(sql, 128, "SELECT group_concat(securityName) AS names FROM tb_securityZone WHERE vfw_name='%s'", vfwName);
else
snprintf(sql, 128, "SELECT group_concat(securityName) AS names FROM tb_securityZone");
sqlite3_exec_query_ex(db, sql, &res);
if (SQLITE_OK != sqlite3_get_str_ex(res, 0, "names", &tmp_str))
{
ws_ret = ERROR_SECURITY_GETRES;
goto label_ret;
}
ret->ret.text = ws_strdup(soap, tmp_str);
label_ret:
sqlite3_res_free_ex(res);
sqlite3_close_ex(db);
if (WS_OK != ws_ret)
{
ret->ret.text = "";
return ws_send_soap_error(soap, g_securityzone_error[ws_ret]);
}
return WS_OK;
}
/*****************************************************************************
函 数 名 : ws__getPoeIlimit
功能描述 : 获取poe设备的电流信息
输入参数 : ws_env ---- web service执行环境
输出参数 : ret ---- 得到poe 设备信息
返 回 值 : ERROR_SUCCESS ---- 执行成功
ws_new_soap_fault---- 执行失败
-----------------------------------------------------------------------------
最近一次修改记录:
修改作者: ninglijun
修改目的: 生成新函数
修改日期: 2012年09月14日
*****************************************************************************/
int ws__getPoeIlimit(WS_ENV* ws_env, struct ws__getPoeIlimitResponse * ret)
{
drv_poe_dev_info_s * dev_info = NULL;
struct PoeIlimit * wspoeilimit = NULL;
s32 res,i,num;
s8 buff[32];
dev_info = (drv_poe_dev_info_s*)ws_malloc(ws_env, sizeof(drv_poe_dev_info_s));
if (NULL == dev_info)
{
return ws_send_soap_error(ws_env, poe_error_str(ERR_POE_FAIL_MALLOC));
}
res = poe_syscall_get_poe_dev_info(dev_info);
if(ERROR_SUCCESS != res)
{
return ws_send_soap_error(ws_env, poe_error_str(ERR_POE_FAIL_SYSCALL));
}
num = dev_info->poe_port_cust_ilimit_valid_num;
ret->ret.sum = dev_info->poe_port_cust_ilimit_valid_num;
ret->ret.res_USCOREcount = dev_info->poe_port_cust_ilimit_valid_num;
ret->ret.__size = dev_info->poe_port_cust_ilimit_valid_num;
wspoeilimit = (struct PoeIlimit *)ws_malloc(ws_env, num * sizeof(struct PoeIlimit));
if (NULL == wspoeilimit)
{
return ws_send_soap_error(ws_env, poe_error_str(ERR_POE_FAIL_MALLOC));
}
for(i = 0 ; i < num ; i++)
{
snprintf(buff,sizeof(buff),"%d",(dev_info->poe_port_cust_ilimit_value[i] / 1000));
wspoeilimit[i].poeIlimitVlaue= ws_strdup(ws_env, buff);
wspoeilimit[i].count = i;
}
ret->ret.__ptrres = wspoeilimit;
return ERROR_SUCCESS;
}
WsBool ws_hash_put(WsHashPtr hash, const char *name, void *data)
{
WsHashItem *i;
size_t h = count_hash(name);
for (i = hash->items[h]; i; i = i->next) {
if (strcmp(i->name, name) == 0) {
/* Found it. */
/* Destroy the old item */
if (hash->destructor)
(*hash->destructor)(i->data, hash->destructor_context);
i->data = data;
return WS_FALSE;
}
}
/* Must create a new mapping. */
i = ws_calloc(1, sizeof(*i));
if (i == NULL)
return WS_FALSE;
i->name = ws_strdup(name);
if (i->name == NULL) {
ws_free(i);
return WS_FALSE;
}
i->data = data;
/* Link it to our hash. */
i->next = hash->items[h];
hash->items[h] = i;
return WS_TRUE;
}
s32 ws__getdsLiteDhcpName(WS_ENV* ws_env, struct ws__getDsliteDhcpResponse *ret)
{
u32 dhcp_num;
u8 i;
tb_dhcpv6_pool_aftr_Info_s *aftrname = NULL;
aftrname = dhcp_v6_server_aftr_db_get(&dhcp_num);
if(NULL == aftrname)
{
return ws_send_soap_error(ws_env, "IP6 get dhcp configuration error!");
}
ret->ret.sum = ret->ret.res_USCOREcount = ret->ret.__size = dhcp_num;
ret->ret.__ptrres = (struct dhcpshow *)ws_malloc(ws_env, sizeof(struct dhcpshow) * dhcp_num);
if(NULL == ret->ret.__ptrres)
{
return ws_send_soap_error(ws_env, "ws_malloc error!");
}
for(i=0; i<dhcp_num; i++)
{
ret->ret.__ptrres[i].name = ws_strdup(ws_env, aftrname[i].aftr_name);
}
free(aftrname);
return WS_OK;
}
s32 ws__getArpCheatList(WS_ENV *ws_env, s8 *startTime,
s8 *endTime, s32 offset, s32 count,struct ws__getArpCheatListResponse *ret)
{
sqlite3 * db = NULL;
sqlite3_res res = NULL;
s32 ws_err;
s8 *ip, *oldMac, *newMac, *date;
s32 i, total_count;
s8* sql = NULL;
s32 sql_len = 0;
struct tm tm;
struct ArpCheatInfo * tmp_arpCheatInfo;
s8 sql_query[1000];
if (NULL != startTime && '\0' != startTime[0]
&& WS_OK != (ws_err = ws_check_datetime(ws_env, startTime, "startTime", &tm)))
{
return ws_err;
}
if (NULL != endTime && '\0' != endTime[0]
&& WS_OK != (ws_err = ws_check_datetime(ws_env, startTime, "endTime", &tm)))
{
return ws_err;
}
/* 为sql条件语句分配空间 */
sql = ws_malloc(ws_env, 2048);
if (NULL == sql)
{
return ws_send_soap_error(ws_env, "operated failed.");
}
sql[0] = '\0';
/* 构造条件语句 */
if (NULL != startTime && startTime[0] != '\0')
{
sql_len += snprintf(sql + sql_len, 2048-(u32)sql_len, "attacktime >= '%s'", startTime);
}
if (NULL != endTime && endTime[0] != '\0')
{
sql_len += snprintf(sql + sql_len, 2048-(u32)sql_len, " and attacktime <= '%s'", endTime);
}
/* 方便越界定位 */
sql[2048 - 1] = '\0';
/* 打开一个连接，出错则返回 */
db = sqlite3_open_ex(1, "/log/dblog/arpsafety_log.db");
if ( NULL == db )
{
return ws_send_soap_error(ws_env, "operated failed.");
}
if(sql[0] == '\0')
{
snprintf(sql_query, sizeof(sql_query), "select count(*) as count from tb_arpsafety_log;");
}
else
{
snprintf(sql_query, sizeof(sql_query), "select count(*) as count from tb_arpsafety_log where %s;", sql);
}
if (SQLITE_OK != sqlite3_exec_query_ex(db, sql_query, &res))
{
goto label_ret;
}
if (SQLITE_OK != sqlite3_get_s32_ex(res, 0, "count", &total_count))
{
goto label_ret;
}
sqlite3_res_free_ex(res);
res = NULL;
if(sql[0] == '\0')
{
snprintf(sql_query, sizeof(sql_query), "select * from tb_arpsafety_log limit %d, %d;", offset, count);
}
else
{
snprintf(sql_query, sizeof(sql_query), "select * from tb_arpsafety_log where %s limit %d, %d;", sql, offset, count);
}
if (SQLITE_OK != sqlite3_exec_query_ex(db, sql_query, &res))
{
goto label_ret;
}
if(-1 == count)
count = total_count;
tmp_arpCheatInfo = (struct ArpCheatInfo*)ws_malloc(ws_env, count * sizeof(struct ArpCheatInfo));
for(i = 0; i < count; i++)
{
if(SQLITE_OK != sqlite3_get_s32_ex(res, i, "id", &(tmp_arpCheatInfo[i].id)))
{
goto label_ret;
}
if(SQLITE_OK != sqlite3_get_str_ex(res, i, "ip", &ip))
{
goto label_ret;
}
tmp_arpCheatInfo[i].ip = ws_strdup(ws_env, ip);
if(SQLITE_OK != sqlite3_get_str_ex(res, i, "real_mac", &oldMac))
{
goto label_ret;
}
tmp_arpCheatInfo[i].oldMac = ws_strdup(ws_env, oldMac);
if(SQLITE_OK != sqlite3_get_str_ex(res, i, "cheat_mac", &newMac))
{
goto label_ret;
}
tmp_arpCheatInfo[i].newMac = ws_strdup(ws_env, newMac);
if(SQLITE_OK != sqlite3_get_str_ex(res, i, "attacktime", &date))
{
goto label_ret;
}
tmp_arpCheatInfo[i].date = ws_strdup(ws_env, date);
}
ret->ret.sum = total_count;
ret->ret.__size = count;
ret->ret.res_USCOREcount = count;
ret->ret.__ptrres = tmp_arpCheatInfo;
label_ret:
if (NULL != res)
{
sqlite3_res_free_ex(res);
res = NULL;
}
if (NULL != db)
{
sqlite3_close_ex(db);
db = NULL;
}
return WS_OK;
}
s32 ws__getArpPortCfgList(WS_ENV* ws_env, struct ws__getArpPortCfgResponse* ret)
{
struct ArpPortCfgInfo *arpPortCfgInfo = NULL;
sqlite3 * db = NULL;
sqlite3_res res = NULL;
sqlite3_res state_res = NULL;
s32 ws_ret = WS_OK;
const s8 * err_info = NULL;
u32 if_count = 0;
s8 tmp_str[32] = {0};
u32 tmp_int = 0;
u32 i = 0;
db = sqlite3_open_ex(2, IFMODE_DBFILE, CFG_ARPPORTCFG_DBFILE);
if (NULL == db)
{
ws_ret = ERR_ARPSAFETY_OPEN_DB_FAILD;
goto label_ret;
}
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf),
"select count(ifindex) as count from ("
"select l3.ifindex from tb_port_l3 as l3 "
"union all "
"select l2.ifindex from tb_port_l2 as l2 "
"union all "
"select vlan.ifindex from tb_vlan as vlan where vlan.ifindex!=0) as Temp;");
if (SQLITE_OK != sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res))
{
ws_ret = ERR_ARPSAFETY_EXEC_SQL_FAILD;
goto label_ret;
}
if (SQLITE_OK != sqlite3_get_u32_ex(res, 0, "count", &if_count))
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
sqlite3_res_free_ex(res);
res = NULL;
ret->ret.sum = if_count;
ret->ret.__size = if_count;
ret->ret.res_USCOREcount = if_count;
arpPortCfgInfo = (struct ArpPortCfgInfo *)ws_malloc(ws_env, if_count*sizeof(struct ArpPortCfgInfo));
if (NULL == arpPortCfgInfo)
{
ws_ret = ERR_ARPSAFETY_MALLOC_FAILD;
goto label_ret;
}
ret->ret.__ptrres = arpPortCfgInfo;
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf),
"select ifindex from("
"select l3.ifindex from tb_port_l3 as l3 "
"union all "
"select l2.ifindex from tb_port_l2 as l2 "
"union all "
"select vlan.ifindex from tb_vlan as vlan where vlan.ifindex!=0) as Temp order by ifindex;");
if (SQLITE_OK != sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res))
{
ws_ret = ERR_ARPSAFETY_EXEC_SQL_FAILD;
goto label_ret;
}
for (i=0; i<if_count; i++)
{
if (SQLITE_OK != sqlite3_get_s32_ex(res, i, "ifindex", &arpPortCfgInfo[i].portIndex))
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
if(ERROR_SUCCESS != if_get_name_by_index(tmp_str, sizeof(tmp_str),arpPortCfgInfo[i].portIndex))
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
arpPortCfgInfo[i].portName = ws_strdup(ws_env, tmp_str);
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "SELECT count(*) as count FROM "CFG_ARPPORT_TAB_TABLENAME" where portName='%s';",
arpPortCfgInfo[i].portName);
if (SQLITE_OK != sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &state_res))
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
if (SQLITE_OK != sqlite3_get_u32_ex(state_res, 0, "count", &tmp_int))
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
sqlite3_res_free_ex(state_res);
state_res = NULL;
if (0 == tmp_int)
{
arpPortCfgInfo[i].state = 0;
}
else
{
arpPortCfgInfo[i].state = 1;
}
}
sqlite3_res_free_ex(res);
res = NULL;
qsort (arpPortCfgInfo, (u32)if_count, sizeof(struct ArpPortCfgInfo), PhysNet_sort);
label_ret:
sqlite3_res_free_ex(state_res);
state_res = NULL;
sqlite3_res_free_ex(res);
res = NULL;
if (NULL != db)
{
sqlite3_close_ex(db);
db = NULL;
}
if (WS_OK != ws_ret)
{
err_info = arpsafety_error_str(ws_ret);
return ws_send_soap_error(ws_env, err_info);
}
return WS_OK;
}
/*******************************************************************************
函数名称 : ws__getArpList
功能描述 : web service实现函数，从数据面获取学习得到的Macip地址
输入参数 : ws_env ---- web service执行环境
输出参数 : 无
返 回 值 : WS_OK ---- 执行成功
soapFault ---- 执行失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : zhangfaqi
修改目的 : 新添加函数
修改日期 : 2011-04-02
*******************************************************************************/
s32 ws__getArpList(WS_ENV* ws_env, s32 offset, s32 count, struct ws__getArpListResponse *ret)
{
arp_item_t *item_buf;
struct ArpInfo *arp_Info;
const s8* err_info;
struct in_addr IP;
u32 i;
u32 ws_ret = ERROR_SUCCESS;
u32 number; /* arp记录总条数 */
s8 *inside_name = NULL; /* 接口名 */
s32 offset_left = 0; /* 分页偏移量 */
s32 count_left = 0; /* 分页每页显示数 */
char *mac_addr = NULL; /* MAC地址临时变量 */
/* 获取数据面macip表项的条数 */
if (ERROR_SUCCESS != arp_get_num(&number))
{
ws_ret = ERR_ARPSAFETY_GET_DATA_FAILD;
goto label_ret;
}
/* 为获取到的数据面macip表象分配内存 */
item_buf = (arp_item_t *)ws_malloc(ws_env, number * sizeof(arp_item_t));
if (NULL == item_buf)
{
ws_ret = ERR_ARPSAFETY_MALLOC_FAILD;
goto label_ret;
}
/* 获取数据面所有arp表项*/
ws_ret = arp_get_items(item_buf, &number);
if (ws_ret != ERROR_SUCCESS)
{
ws_ret = ERR_ARPSAFETY_GET_DATA_FAILD;
goto label_ret;
}
arp_Info = (struct ArpInfo*)ws_malloc(ws_env, number * sizeof(struct ArpInfo));
/* 分页取出 */
for( i = 0; i < number; i++ )
{
/* 偏移量计数 */
offset_left++;
if (count_left < count && offset_left > offset)
{
mac_addr = (char *)malloc(MAC_ADDR_LENGTH);
/* 转换mac地址格式 */
snprintf (mac_addr,MAC_ADDR_LENGTH, MACSTR, MAC2STR(item_buf[i].mac_addr));
/* IP地址 */
IP.s_addr = item_buf[i].ip;
inside_name = (s8*)malloc(INTERFACE_NAME_MAX_LENGTH);
/* 更新端口 */
if_get_name_by_index(inside_name, 32, (s32)(item_buf[i].inport_index));
arp_Info[count_left].inPort = ws_strdup(ws_env, inside_name);
arp_Info[count_left].ip = ws_strdup(ws_env,inet_ntoa(IP));
arp_Info[count_left].mac = ws_strdup(ws_env,mac_addr);
arp_Info[count_left].vlanId = (s32)item_buf[i].vlan_id;
arp_Info[count_left].type = (s32)item_buf[i].type;
free(inside_name);
free(mac_addr);
/* 提取出的记录计数 */
count_left++;
}
}
ret->ret.sum = offset_left;
ret->ret.res_USCOREcount = count_left;
ret->ret.__size = count_left;
ret->ret.__ptrres = arp_Info;
label_ret:
if (WS_OK != ws_ret)
{
err_info = arpsafety_error_str(ws_ret);
return ws_send_soap_error(ws_env,err_info);
}
return WS_OK;
}
/*******************************************************************************
函数名称 : ws__getArpSendList
功能描述 : web service实现函数，得到数据库黑名单防护的初始状态
输入参数 : ws_env ---- web service执行环境
输出参数 : 无
返 回 值 : WS_OK ---- 执行成功
soapFault ---- 执行失败
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : zhangfaqi
修改目的 : 新添加函数
修改日期 : 2011-04-01
*******************************************************************************/
s32 ws__getArpSendList(WS_ENV* ws_env, struct ws__getArpSendListResponse *ret)
{
struct ArpSendInfo* arpsendlistInfo;
sqlite3* db = NULL;
sqlite3_res res = NULL;
s32 ws_ret = ERROR_SUCCESS;
s32 sql_ret = SQLITE_OK;
s8* tmpstr = NULL;
const s8* err_info;
s32 record_num,i;
/* 连接数据库 */
db = sqlite3_open_ex(1, CFG_ARPSAFETY_DBFILE);
if ( NULL == db )
{
ws_ret = ERR_ARPSAFETY_OPEN_DB_FAILD;
goto label_ret;
}
if ( SQLITE_OK != sqlite3_exec_query_ex(db, "SELECT count(*) AS count FROM "CFG_ARPSAFETY_TAB_TABLENAME";", &res) )
{
ws_ret = ERR_ARPSAFETY_EXEC_SQL_FAILD;
goto label_ret;
}
if ( SQLITE_OK != sqlite3_get_s32_ex(res, 0, "count", &record_num) )
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
/* 设置总数的引用返回 */
ret->ret.sum = (s32)record_num;
/* 为返回结果分配内存 */
arpsendlistInfo = (struct ArpSendInfo *)ws_malloc(ws_env,
record_num * sizeof(struct ArpSendInfo));
if (NULL == arpsendlistInfo)
{
ws_ret = ERR_ARPSAFETY_MALLOC_FAILD;
goto label_ret;
}
/* 释放结果集 */
sqlite3_res_free_ex(res);
res = NULL;
if ( SQLITE_OK != sqlite3_exec_query_ex(db, "SELECT * FROM "CFG_ARPSAFETY_TAB_TABLENAME" ORDER BY "CFG_ARPSAFETY_COL_ID" ASC;", &res) )
{
ws_ret = ERR_ARPSAFETY_EXEC_SQL_FAILD;
goto label_ret;
}
for( i = 0; i < record_num; i++ )
{
sql_ret += sqlite3_get_s32_ex(res, i, CFG_ARPSAFETY_COL_ID, &arpsendlistInfo[i].id);
sql_ret += sqlite3_get_s32_ex(res, i, CFG_ARPSAFETY_COL_TIMESLOT, &arpsendlistInfo[i].timeSlot);
sql_ret += sqlite3_get_str_ex(res, i, CFG_ARPSAFETY_COL_PORTID, &tmpstr);
arpsendlistInfo[i].portId = ws_strdup(ws_env,tmpstr);
if ( SQLITE_OK != sql_ret )
{
ws_ret = ERR_ARPSAFETY_GET_RES_FAILD;
goto label_ret;
}
}
/* 设置引用返回*/
ret->ret.res_USCOREcount = i;
ret->ret.__size = i;
/* 设置返回结果集 */
ret->ret.__ptrres = arpsendlistInfo;
label_ret:
/* 释放结果集 */
sqlite3_res_free_ex(res);
/* 关闭数据库连接 */
sqlite3_close_ex(db);
if ( ERROR_SUCCESS != ws_ret )
{
err_info = arpsafety_error_str(ws_ret);
return ws_send_soap_error(ws_env, err_info);
}
return WS_OK;
}
/*******************************************************************************
函数名称 : ws__trackIPGetVrfId
功能描述 : 读取所有记录信息，送往前台页面进行动态替换
输入参数 : ws_env: web service的环境变量
ret: 要返回的结果集
输出参数 : 无
返 回 值 : WS_OK: 执行成功
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : zhangxiaoyan
修改目的 :
修改日期 : 2013.02.1
*******************************************************************************/
s32 ws__trackIPGetVrf(WS_ENV* ws_env,struct ws__getTrackIPListResponse *ret)
{
s8 *name;
s8 *addr;
s8 *interval;
s8 state[TRACKIP_STATE_SIZE]= {0};
s8 *state_buff = NULL;
s32 litevrfid = 0;
s32 vrfid = 0;
s32 result;
s32 num;
s32 i;
sqlite3 *db = NULL;
sqlite3_res res = NULL;
struct TrackIP *trackip_data;
s32 vrf_sw,litevrf_sw;
vrf_getvrfswitch(&vrf_sw);
vrf_getlitevrfswitch(&litevrf_sw);
vrrp_get_curVrfid(&vrfid , &litevrfid);
db = sqlite3_open_ex(1, TRACKIP_CFG_DB);
if( NULL == db )
{
goto out;
}
if(litevrf_sw)
{
snprintf (g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "select count(*) as count from tb_trackip_config where litevrfid= %d and vrfid=0;", litevrfid);
result = sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
}
else
{
snprintf (g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "select count(*) as count from tb_trackip_config where vrfid= %d and litevrfid=0;", vrfid);
result = sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
}
if(SQLITE_OK != result)
{
goto close_db;
}
num = 0;
sqlite3_get_s32_ex(res, 0, "count", &num);
sqlite3_res_free_ex(res);
res = NULL;
/* 将获取的行数赋给返回给web的结构体ws__getTrackIPListResponse */
ret->ret.sum = num;
ret->ret.__size = num;
ret->ret.res_USCOREcount = (int)num;
/* 为结果集分配空间 */
trackip_data = ws_malloc(ws_env, (u32)num*sizeof(struct TrackIP));
if( NULL == trackip_data )
{
goto close_db;
}
memset(trackip_data, 0, (u32)num*sizeof(struct TrackIP));
/* 执行查询语句，取结果集 */
if(litevrf_sw)
{
snprintf (g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "select * from tb_trackip_config where litevrfid= '%d' and vrfid=0 order by name ;", litevrfid);
result = sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
}
else
{
snprintf (g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "select * from tb_trackip_config where vrfid= '%d' and litevrfid=0 order by name ;", vrfid);
result = sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
}
if(SQLITE_OK != result)
{
goto close_db;
}
ret->ret.__ptrres = trackip_data;
for( i = 0; i < num; i++ )
{
sqlite3_get_str_ex(res, i, "name", &name);
trackip_data[i].name = ws_strdup(ws_env, name);
sqlite3_get_str_ex(res, i, "addr", &addr);
trackip_data[i].addr = ws_strdup(ws_env, addr);
sqlite3_get_str_ex(res, i, "interval", &interval);
trackip_data[i].interval = ws_strdup(ws_env, interval);
}
sqlite3_res_free_ex(res);
res = NULL;
/*获取trackip 已正在ping的实例的状态*/
state_buff = trackip_state_load();
for(i = 0; i < num; i++)
{
trackip_state_match(state_buff, trackip_data[i].name, state);
trackip_data[i].state = ws_strdup(ws_env, state);
}
free(state_buff);
state_buff = NULL;
close_db:
sqlite3_close_ex(db);
out:
return WS_OK;
}
s32 pdf_get_policy(WS_ENV *soap, struct PdfPolicyInfo *policy_info_list, sqlite3 *db)
{
s32 sql_ret = SQLITE_OK;
sqlite3_res res = NULL;
s32 res_row;
struct tm *ptr;
struct tm *ptr1;
char s[32];
char s1[32];
s32 start,end;
s32 max = 32;
snprintf(g_sqlite_sql_buf, sizeof(g_sqlite_sql_buf), "SELECT * FROM tb_pdf_policy_cfg");
sql_ret = sqlite3_exec_query_ex(db, g_sqlite_sql_buf, &res);
if ( SQLITE_OK != sql_ret )
{
goto label_ret;
}
/* 循环获取每一行的值 */
while ( SQLITE_OK == (sql_ret = sqlite3_res_next_ex(res, &res_row)) && SQLITE_RES_END != res_row )
{
sql_ret += sqlite3_get_s32_ex(res, res_row, "id", &(policy_info_list[res_row].policyId));
sql_ret += sqlite3_get_str_ex(res, res_row, "policyname", &(policy_info_list[res_row].policyName));
sql_ret += sqlite3_get_str_ex(res, res_row, "business_eth", &(policy_info_list[res_row].businessEth));
sql_ret += sqlite3_get_str_ex(res, res_row, "business_service", &(policy_info_list[res_row].businessService));
sql_ret += sqlite3_get_s32_ex(res, res_row, "group_group", &(policy_info_list[res_row].groupGroup));
sql_ret += sqlite3_get_str_ex(res, res_row, "group_service", &(policy_info_list[res_row].groupService));
sql_ret += sqlite3_get_str_ex(res, res_row, "single_ip", &(policy_info_list[res_row].singleGroup));
sql_ret += sqlite3_get_str_ex(res, res_row, "single_service", &(policy_info_list[res_row].singleService));
sql_ret += sqlite3_get_s32_ex(res, res_row, "top_group", &(policy_info_list[res_row].topGroup));
sql_ret += sqlite3_get_str_ex(res, res_row, "top_service", &(policy_info_list[res_row].topService));
sql_ret += sqlite3_get_s32_ex(res, res_row, "cur_graph", &(policy_info_list[res_row].curGraph));
sql_ret += sqlite3_get_s32_ex(res, res_row, "cur_mlist", &(policy_info_list[res_row].curMlist));
sql_ret += sqlite3_get_s32_ex(res, res_row, "graph_type", &(policy_info_list[res_row].graphType));
sql_ret += sqlite3_get_s32_ex(res, res_row, "cycle", &(policy_info_list[res_row].cycle));
sql_ret += sqlite3_get_s32_ex(res, res_row, "start_time", &start);
sql_ret += sqlite3_get_s32_ex(res, res_row, "end_time", &end);
sql_ret += sqlite3_get_str_ex(res, res_row, "receivers", &(policy_info_list[res_row].receives));
sql_ret += sqlite3_get_str_ex(res, res_row, "pdf_report_name", &(policy_info_list[res_row].pdfName));
if ( SQLITE_OK != sql_ret )
{
goto label_ret;
}
if(policy_info_list[res_row].cycle == 3)
{
ptr = gmtime((time_t*)(&start));
strftime(s, max,"%F %H:%M",ptr);
policy_info_list[res_row].startTime = ws_strdup(soap, s);
ptr1 = gmtime((time_t*)(&end));
strftime(s1, max,"%F %H:%M",ptr1);
policy_info_list[res_row].endTime = ws_strdup(soap, s1);
}
else
{
policy_info_list[res_row].startTime = ws_strdup(soap,"");
policy_info_list[res_row].endTime = ws_strdup(soap,"");
}
/* 字符串使用的是结果集中的字符串指针，需要复制一份作为返回结果 */
policy_info_list[res_row].policyName = ws_strdup(soap, policy_info_list[res_row].policyName);
if(0 != strcmp(policy_info_list[res_row].businessService,""))
{
policy_info_list[res_row].businessEth = ws_strdup(soap, policy_info_list[res_row].businessEth);
policy_info_list[res_row].businessService = ws_strdup(soap, policy_info_list[res_row].businessService);
}
else
{
policy_info_list[res_row].businessEth = ws_strdup(soap,"all_eth");
policy_info_list[res_row].businessService = ws_strdup(soap,"");
}
if(0 != strcmp(policy_info_list[res_row].groupService,""))
{
policy_info_list[res_row].groupService= ws_strdup(soap, policy_info_list[res_row].groupService);
}
else
{
policy_info_list[res_row].groupService= ws_strdup(soap,"");
}
if(0 != strcmp(policy_info_list[res_row].singleService,""))
{
policy_info_list[res_row].singleService= ws_strdup(soap, policy_info_list[res_row].singleService);
policy_info_list[res_row].singleGroup= ws_strdup(soap, policy_info_list[res_row].singleGroup);
}
else
{
policy_info_list[res_row].singleService= ws_strdup(soap,"");
policy_info_list[res_row].singleGroup= ws_strdup(soap,"");
}
if(0 !=strcmp(policy_info_list[res_row].topService,""))
{
policy_info_list[res_row].topService = ws_strdup(soap, policy_info_list[res_row].topService);
}
else
{
policy_info_list[res_row].topService = ws_strdup(soap,"");
}
policy_info_list[res_row].receives = ws_strdup(soap, policy_info_list[res_row].receives);
if( 0 != strcmp(policy_info_list[res_row].pdfName,""))
{
policy_info_list[res_row].pdfName= ws_strdup(soap, policy_info_list[res_row].pdfName);
}
else
{
policy_info_list[res_row].pdfName= ws_strdup(soap, "");
}
}
label_ret:
sqlite3_res_free_ex(res);res = NULL;
if (SQLITE_OK != sql_ret)
{
return ERROR_FAIL;
}
return ERROR_SUCCESS;
}
