/***************************************************************************
* Function Name : je_instanceid_generator_deinit
* Description : This function will free the allocated memory during
* Deinitialization.
* Input : uint32_t - Reason code for invocation of function
* Output : None
* Return value : None.
***************************************************************************/
void je_instanceid_generator_deinit (void)
{
CM_JE_DEBUG_PRINT ("Entered");
if (!je_instance_info_g)
return;
of_free ((je_instance_info_g)->instance_id_valid);
(je_instance_info_g)->instance_id_valid = NULL;
/* free the whole container */
of_free (je_instance_info_g);
je_instance_info_g = NULL;
return;
}
/******************************************************************************
* Function Name : cm_tnsprt_free_message
* Description : This function is used to free the memory, which is
* previously allocated by transport channel.
* Input params : msg_p - Pointer to the buffer that need to be freed.
* Output params : None
* Return value : None
*****************************************************************************/
void cm_tnsprt_free_message (void * msg_p)
{
/* In future, we can convert this into mempools */
if(msg_p != NULL)
{
of_free (msg_p);
msg_p = NULL;
}
}
void *UCMDP_BeginConfigTransaction(uint32_t uiAppId,struct cm_array_of_iv_pairs * arr_p,
uint32_t uiCmdId,
struct cm_app_result ** result_p)
{
char *pTempBuf;;
int32_t iTotalLen=0,return_value;
uint32_t uiLen=0;
void *pt=NULL;
struct cm_app_result *app_result_p=NULL;
ucmcommmsg_t CommMsg={};
pTempBuf=CommMsg.cntlreqmsg.msg;
CM_CBK_DEBUG_PRINT("Entry uiAppId=%d",uiAppId);
if(cm_je_copy_ivpair_arr_to_buffer(arr_p,pTempBuf,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return NULL;
}
pTempBuf+=uiLen;
iTotalLen+=uiLen;
app_result_p = (struct cm_app_result *)of_calloc(1,sizeof(struct cm_app_result));
if(!app_result_p)
{
CM_CBK_DEBUG_PRINT("memory allocation failed");
return NULL;
}
CM_CNTRL_PREPARE_CNTRL_CFG_REQUEST(CommMsg.cntlreqmsg, uiAppId, uiCmdId, CM_CPDP_APPL_TRANS_BEGIN_CMD, 0,iTotalLen);
return_value=UCMCntrlCommHandler(&CommMsg,app_result_p);
if(app_result_p->result_code==OF_FAILURE)
{
*result_p = app_result_p ;
if ((return_value==CM_NO_APPL_TRANS_SUPPORT) || (return_value == CM_APPL_NULL_CALLBACK))
{
CM_CBK_DEBUG_PRINT("No transaction support. Sending temp trans");
return dp_xtn_rec_p;
}
if (return_value == CM_APPL_START_TRANS_FAILED)
{
CM_CBK_DEBUG_PRINT("transaction start failed");
}
return NULL;
}
CM_CBK_DEBUG_PRINT("transaction exists");
pTempBuf=CommMsg.cntlrespmsg.msg;
#if defined(_LP64)
pt = (void *)of_mbuf_get_64(pTempBuf);
#else
pt=(void *)of_mbuf_get_32(pTempBuf);
#endif
pTempBuf+=sizeof(pt);
of_free(app_result_p);
return pt;
}
int32_t UCMDP_GetExactRec(uint32_t uiAppId,struct cm_array_of_iv_pairs *
keys_arr_p, struct cm_array_of_iv_pairs **record_data_pp)
{
char *pRespBuf;
char *pReqBuf;
int32_t iTotalLen=0,return_value=0;
uint32_t uiLen=0, count=0;
struct cm_array_of_iv_pairs *pRecArr;
ucmcommmsg_t CommMsg={};
pReqBuf=CommMsg.cntlreqmsg.msg;
CM_CBK_DEBUG_PRINT("entry");
if(cm_je_copy_ivpair_arr_to_buffer(keys_arr_p,pReqBuf,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return OF_FAILURE;
}
pReqBuf+=uiLen;
iTotalLen+=uiLen;
CM_CNTRL_PREPARE_CNTRL_CFG_REQUEST(CommMsg.cntlreqmsg, uiAppId, 0, CM_CPDP_APPL_GET_EACT_CMD, 0, iTotalLen);
return_value=UCMCntrlCommHandler(&CommMsg,NULL);
if(return_value==OF_FAILURE)
return OF_FAILURE;
if (CommMsg.cntlrespmsg.msg_type == CM_CNTRL_MULTIPART_RESPONSE)
{
pRespBuf=CommMsg.pmultipart;
iTotalLen=CommMsg.msglen;
pRespBuf= of_mbuf_put_32 (pRespBuf, count);
iTotalLen+=4;
}
else
{
pRespBuf=&CommMsg.cntlrespmsg.msg[0];
iTotalLen=CommMsg.cntlrespmsg.length;
}
CM_CBK_DEBUG_PRINT("Total Len %d",iTotalLen);
pRecArr=(struct cm_array_of_iv_pairs *)of_calloc(1,sizeof(struct cm_array_of_iv_pairs));
uiLen=0;
if(cm_je_copy_ivpair_arr_from_buffer(pRespBuf,pRecArr,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return OF_FAILURE;
}
pRespBuf+=uiLen;
*record_data_pp=pRecArr;
if (CommMsg.cntlrespmsg.msg_type == CM_CNTRL_MULTIPART_RESPONSE)
of_free(CommMsg.pmultipart);
return OF_SUCCESS;
}
int32_t UCMDP_SetRecord(uint32_t uiAppId,void * config_trans_p,
struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_array_of_iv_pairs * member_arr_p,
struct cm_app_result ** result_p)
{
char *pTempBuf;;
int32_t iTotalLen=0,return_value;
uint32_t uiLen=0;
struct cm_app_result *app_result_p=NULL;
ucmcommmsg_t CommMsg={};
pTempBuf=CommMsg.cntlreqmsg.msg;
CM_CBK_DEBUG_PRINT(" Entry uiAppId=%d",uiAppId);
#if defined(_LP64)
pTempBuf= of_mbuf_put_64(pTempBuf, (unsigned long)config_trans_p);
#else
pTempBuf= of_mbuf_put_32(pTempBuf, (uint32_t) config_trans_p);
#endif
iTotalLen+=sizeof(long);
if(cm_je_copy_ivpair_arr_to_buffer(keys_arr_p,pTempBuf,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return OF_FAILURE;
}
pTempBuf+=uiLen;
iTotalLen+=uiLen;
uiLen=0;
if(cm_je_copy_ivpair_arr_to_buffer(member_arr_p,pTempBuf,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return OF_FAILURE;
}
app_result_p = (struct cm_app_result *)of_calloc(1,sizeof(struct cm_app_result));
if(!app_result_p)
{
CM_CBK_DEBUG_PRINT("memory allocation failed");
return OF_FAILURE;
}
iTotalLen+=uiLen;
CM_CNTRL_PREPARE_CNTRL_CFG_REQUEST(CommMsg.cntlreqmsg, uiAppId, 0, CM_CPDP_APPL_SET_CMD, sizeof(long), iTotalLen);
return_value=UCMCntrlCommHandler(&CommMsg,app_result_p);
if(return_value == OF_SUCCESS)
{
of_free(app_result_p);
return OF_SUCCESS;
}
*result_p = app_result_p;
return return_value;
}
/***************************************************************************
* Function Name : cm_hash_table_delete
* Description : Deletes hash table
* Input : pHashTab - hash table pointer
* Output : None.
* Return value : None.
***************************************************************************/
void cm_hash_table_delete (struct cm_hash_sll_table *pHashTab)
{
/* release the memory
* assumption - before calling this function, application would have
* deleted all its pointers
*/
of_free (pHashTab);
/* Trace (DSLIB_ID, TRACE_SEVERE,
"cm_hash_table_delete: Hashtable Deleted Successfully...\n\r");*/
return;
}
/******************************************************************************
* Function Name : cm_tnsprt_close_channel
* Description : This API is used to close the Transport connection with the
* Server and frees the Transport channel node.
* Input params : tnsprt_channel_p - pointer to the Transport channel structure.
* Output params : NONE
* Return value : NONE
*****************************************************************************/
void cm_tnsprt_close_channel (struct cm_tnsprt_channel * tnsprt_channel_p)
{
if (unlikely (tnsprt_channel_p == NULL))
{
CM_TRANS_DEBUG_PRINT ("Invalid Transport channel");
return;
}
cm_socket_close (tnsprt_channel_p->sock_fd_i);
of_free (tnsprt_channel_p);
tnsprt_channel_p = NULL;
}
int32_t nsrm_chain_delrec (void * config_transaction_p,
struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_app_result ** result_p)
{
struct cm_app_result *nsrm_chain_result = NULL;
int32_t return_value = OF_FAILURE;
struct nsrm_nschain_object_key *nsrm_chain_key_info;
struct nsrm_nschain_object_config_info *nsrm_chain_config_info = NULL;
CM_CBK_DEBUG_PRINT ("Entered");
nsrm_chain_key_info = (struct nsrm_nschain_object_key*) of_calloc(1, sizeof(struct nsrm_nschain_object_key));
nsrm_chain_config_info = (struct nsrm_nschain_object_config_info *)of_calloc(NSRM_MAX_NSCHAIN_OBJECT_CONFIG_PARAMETERS,sizeof(struct nsrm_nschain_object_config_info ));
if ((nsrm_chain_ucm_setmandparams (keys_arr_p, nsrm_chain_key_info, nsrm_chain_config_info)) !=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
fill_app_result_struct (&nsrm_chain_result, NULL, CM_GLU_SET_MAND_PARAM_FAILED);
*result_p = nsrm_chain_result;
of_free(nsrm_chain_key_info->name_p);
of_free(nsrm_chain_key_info->tenant_name_p);
of_free(nsrm_chain_key_info);
return OF_FAILURE;
}
return_value = nsrm_del_nschain_object(nsrm_chain_key_info);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("nsrm chain add Failed");
fill_app_result_struct (&nsrm_chain_result, NULL, CM_GLU_NS_CHAIN_DEL_FAILED);
*result_p = nsrm_chain_result;
of_free(nsrm_chain_key_info->name_p);
of_free(nsrm_chain_key_info->tenant_name_p);
of_free(nsrm_chain_key_info);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("NSRM Appliance delete successfully");
of_free(nsrm_chain_key_info->name_p);
of_free(nsrm_chain_key_info->tenant_name_p);
of_free(nsrm_chain_key_info);
return OF_SUCCESS;
}
of_status_t of_rs_release_codec_instance (of_rs_cb_t* ofcb)
{
OF_ENTER_FUNCTION
UINT32 i;
if (ofcb->rs_cb != NULL)
{
of_rs_free (ofcb->rs_cb);
ofcb->rs_cb = NULL;
}
#ifdef OF_USE_DECODER
if (ofcb->available_symbols_tab != NULL)
{
#ifdef OF_DEBUG
of_free(ofcb->available_symbols_tab, NULL);
#else
of_free(ofcb->available_symbols_tab);
#endif
ofcb->available_symbols_tab = NULL;
}
#endif /* OF_USE_DECODER */
OF_EXIT_FUNCTION
return OF_STATUS_OK;
}
int32_t nsrm_appliance_delrec (void * config_transaction_p,
struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_app_result ** result_p)
{
struct cm_app_result *nsrm_appliance_result = NULL;
int32_t return_value = OF_FAILURE;
struct nsrm_nwservice_object_key *appliance_info = NULL;
struct nsrm_nwservice_object_config_info *nsrm_appliance_config_info = NULL;
CM_CBK_DEBUG_PRINT ("Entered");
appliance_info = (struct nsrm_nwservice_object_key *) of_calloc(1, sizeof(struct nsrm_nwservice_object_key));
if ((nsrm_appliance_ucm_setmandparams (keys_arr_p, appliance_info, nsrm_appliance_config_info)) !=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
fill_app_result_struct (&nsrm_appliance_result, NULL, CM_GLU_SET_MAND_PARAM_FAILED);
*result_p = nsrm_appliance_result;
of_free(appliance_info->name_p);
of_free(appliance_info->tenant_name_p);
of_free(appliance_info);
return OF_FAILURE;
}
return_value = nsrm_del_nwservice_object(appliance_info);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("nsrm appliance del Failed");
fill_app_result_struct (&nsrm_appliance_result, NULL, CM_GLU_APPLIANCE_DEL_FAILED);
*result_p = nsrm_appliance_result;
of_free(appliance_info->name_p);
of_free(appliance_info->tenant_name_p);
of_free(appliance_info);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("NSRM Appliance delete successfully");
of_free(appliance_info->name_p);
of_free(appliance_info->tenant_name_p);
of_free(appliance_info);
return OF_SUCCESS;
}
int32_t nsrm_appliance_getfirstnrecs (struct cm_array_of_iv_pairs * keys_arr_p,
uint32_t * count_p,
struct cm_array_of_iv_pairs ** array_of_iv_pair_arr_p)
{
struct cm_array_of_iv_pairs *result_iv_pairs_p = NULL;
int32_t return_value = OF_FAILURE;
uint32_t uiRecCount = 0;
int32_t uiRecquestedCount = 1, uiReturnedCnt=0;
struct nsrm_nwservice_object_record *nsrm_appliance_config_info=NULL;
CM_CBK_DEBUG_PRINT ("Entered");
nsrm_appliance_config_info = (struct nsrm_nwservice_object_record*)of_calloc(1,sizeof(struct nsrm_nwservice_object_record));
nsrm_appliance_config_info->info = (struct nsrm_nwservice_object_config_info*)of_calloc(NSRM_MAX_NWSERVICE_OBJECT_CONFIG_PARAMETERS,sizeof(struct nsrm_nwservice_object_config_info));
nsrm_appliance_config_info->key.name_p = (char*)of_calloc(1,128);
nsrm_appliance_config_info->key.tenant_name_p = (char*)of_calloc(1,128);
return_value = nsrm_get_first_nwservice_objects(uiRecquestedCount,
&uiReturnedCnt, nsrm_appliance_config_info);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Get first record failed for NSRM appliance Table");
return OF_FAILURE;
}
result_iv_pairs_p = (struct cm_array_of_iv_pairs *) of_calloc (1, sizeof (struct cm_array_of_iv_pairs));
if (result_iv_pairs_p == NULL)
{
CM_CBK_DEBUG_PRINT ("Memory allocation failed for result_iv_pairs_p");
of_free(nsrm_appliance_config_info->key.name_p);
of_free(nsrm_appliance_config_info->key.tenant_name_p);
of_free(nsrm_appliance_config_info);
of_free(nsrm_appliance_config_info->info);
return OF_FAILURE;
}
nsrm_appliance_ucm_getparams (nsrm_appliance_config_info, &result_iv_pairs_p[uiRecCount]);
uiRecCount++;
*array_of_iv_pair_arr_p = result_iv_pairs_p;
of_free(nsrm_appliance_config_info->key.name_p);
of_free(nsrm_appliance_config_info->key.tenant_name_p);
of_free(nsrm_appliance_config_info);
of_free(nsrm_appliance_config_info->info);
return OF_SUCCESS;
}
int32_t UCMDP_EndConfigTransaction(uint32_t uiAppId,void * config_trans_p,uint32_t uiCmdId,struct cm_app_result ** result_p)
{
char *pTempBuf;;
struct cm_app_result *app_result_p=NULL;
int32_t iTotalLen=0,return_value;
ucmcommmsg_t CommMsg={};
pTempBuf=CommMsg.cntlreqmsg.msg;
CM_CBK_DEBUG_PRINT(" Entry uiAppId=%d",uiAppId);
#if defined(_LP64)
pTempBuf= of_mbuf_put_64(pTempBuf, (unsigned long)config_trans_p);
#else
pTempBuf= of_mbuf_put_32(pTempBuf, (uint32_t) config_trans_p);
#endif
iTotalLen+=sizeof(long);
app_result_p = (struct cm_app_result *)of_calloc(1,sizeof(struct cm_app_result));
if(!app_result_p)
{
CM_CBK_DEBUG_PRINT("memory allocation failed");
return OF_FAILURE;
}
CM_CNTRL_PREPARE_CNTRL_CFG_REQUEST(CommMsg.cntlreqmsg, uiAppId, uiCmdId, CM_CPDP_APPL_TRANS_END_CMD, sizeof(long), iTotalLen);
return_value=UCMCntrlCommHandler(&CommMsg,app_result_p);
if(app_result_p->result_code==OF_FAILURE)
{
if ( (return_value == CM_APPL_NULL_CALLBACK))
{
CM_CBK_DEBUG_PRINT("No transaction support. Sending temp trans");
return OF_SUCCESS;
}
if (return_value == CM_APPL_END_TRANS_FAILED)
{
*result_p = app_result_p ;
CM_CBK_DEBUG_PRINT("transaction start failed");
}
return OF_FAILURE;
}
of_free(app_result_p);
return OF_SUCCESS;
}
of_status_t of_rs_2_m_release_codec_instance (of_rs_2_m_cb_t* ofcb)
{
OF_ENTER_FUNCTION
UINT32 i;
of_rs_2m_release((of_galois_field_code_cb_t*)ofcb);
#ifdef OF_USE_DECODER
if (ofcb->available_symbols_tab != NULL)
{
/*for (i=0;i<ofcb->nb_available_symbols;i++) {
if (ofcb->available_symbols_tab[i] != NULL) {
of_free(ofcb->available_symbols_tab[i] MEM_STATS_ARG);
ofcb->available_symbols_tab[i]=NULL;
}
}*/
of_free(ofcb->available_symbols_tab MEM_STATS_ARG);
ofcb->available_symbols_tab = NULL;
}
#endif /* OF_USE_DECODER */
OF_EXIT_FUNCTION
return OF_STATUS_OK;
}
int32_t UCMDP_VerifyConfig(uint32_t uiAppId,struct cm_array_of_iv_pairs * keys_arr_p,
uint32_t uiCmdId,
struct cm_app_result ** result_p)
{
char *pTempBuf;;
uint32_t uiLen=0;
int32_t return_value, iTotalLen=0;
struct cm_app_result *app_result_p=NULL;
ucmcommmsg_t CommMsg={};
pTempBuf=CommMsg.cntlreqmsg.msg;
uiLen = 0;
if(cm_je_copy_ivpair_arr_to_buffer(keys_arr_p,pTempBuf,&uiLen)!=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT("cm_je_copy_ivpair_arr_to_buffer Failed");
return OF_FAILURE;
}
pTempBuf+=uiLen;
iTotalLen += uiLen;
app_result_p = (struct cm_app_result *)of_calloc(1,sizeof(struct cm_app_result));
if(!app_result_p)
{
CM_CBK_DEBUG_PRINT("memory allocation failed");
return OF_FAILURE;
}
CM_CNTRL_PREPARE_CNTRL_CFG_REQUEST(CommMsg.cntlreqmsg, uiAppId, 0, CM_CPDP_APPL_TEST_CMD, 0, iTotalLen);
return_value=UCMCntrlCommHandler(&CommMsg,app_result_p);
if(return_value == OF_SUCCESS)
{
of_free(app_result_p);
return OF_SUCCESS;
}
*result_p = app_result_p;
return return_value;
}
main (int argc, char *argv[])
{
struct cm_tnsprt_channel *tnsprt_channel_p = NULL;
struct cm_je_config_session *pConfigSess = NULL;
struct cm_role_info role_info = { "Admin", "Admin" };
struct cm_nv_pair nv_pairs[2] = {
{7, "VsgName", CM_DATA_TYPE_STRING, 7, "general"},
{11, "VsgId", CM_DATA_TYPE_UINT, 1, "0"},
}
;
struct cm_array_of_nv_pair nv_pair_array = { 2, nv_pairs };
struct cm_command Command = { CM_CMD_ADD_PARAMS, "IGD.VSG",
nv_pair_array
};
struct cm_result *result_p = NULL;
int32_t return_value;
struct cm_nv_pair nv_pairs2[4] = {
{6, "IPName", CM_DATA_TYPE_STRING, 9, "MYIPDBREC"},
{7, "VsgName", CM_DATA_TYPE_STRING, 7, "general"},
{11, "RecordType", CM_DATA_TYPE_STRING, 6, "single"},
{10, "IPAddr", CM_DATA_TYPE_IPADDR, 7, "1.2.3.4"}
}
;
struct cm_array_of_nv_pair nv_pair_array2 = { 4, nv_pairs2 };
struct cm_command Command2 = { CM_CMD_ADD_PARAMS, "IGD.VSG{general}.NetObj.IPDB",
nv_pair_array2
};
struct cm_array_of_nv_pair *out_array_of_nv_pair_arr_p = NULL;
struct cm_nv_pair key_nv_pairs[2] = {
{6, "IPName", CM_DATA_TYPE_STRING, 9, "MYIPDBREC"},
{7, "VsgName", CM_DATA_TYPE_STRING, 7, "general"}
}
;
struct cm_array_of_nv_pair KeysArray = { 2, key_nv_pairs };
uint32_t count_ui = 1, uiCnt = 0, uiNvCnt = 0, i;
struct cm_dm_role_permission RolePerm = { "MyRole", CM_PERMISSION_READ_WRITE };
struct cm_dm_role_permission RolePerm2 = { "MyInstanceRole", CM_PERMISSION_READ_ONLY };
struct cm_dm_array_of_role_permissions *role_perm_ary_p;
/* Start the Transport connection with JE */
if ((tnsprt_channel_p = cm_tnsprt_create_channel (CM_IPPROTO_TCP, 0, 0,
UCMJE_CONFIGREQUEST_PORT)) ==
NULL)
{
CM_TRANS_DEBUG_PRINT ("%s :: Cannot create socket\n\r", __FUNCTION__);
exit (1);
}
#if 0
/* POST Request */
pConfigSess =
(struct cm_je_config_session *) cm_config_session_start (CM_CLI_MGMT_ENGINE_ID,
&role_info, tnsprt_channel_p);
if (!pConfigSess)
{
CM_TRANS_DEBUG_PRINT ("%s :: cm_config_session_start failed\n\r",
__FUNCTION__);
exit (1);
}
return_value = cm_config_session_update_cmd (pConfigSess, &Command, &result_p);
if (return_value == OF_SUCCESS)
{
cm_config_session_end (pConfigSess, CM_CMD_CONFIG_SESSION_COMMIT, &result_p);
}
else
{
cm_config_session_end (pConfigSess, CM_CMD_CONFIG_SESSION_REVOKE, &result_p);
}
of_free (pConfigSess);
pConfigSess = NULL;
of_free (result_p);
result_p = NULL;
UCMFreeUCMResult (CM_COMMAND_CONFIG_SESSION_START, CM_CMD_ADD_PARAMS,
result_p);
result_p = NULL;
/* POST Request */
pConfigSess =
(struct cm_je_config_session *) cm_config_session_start (CM_CLI_MGMT_ENGINE_ID,
&role_info, tnsprt_channel_p);
if (!pConfigSess)
{
CM_TRANS_DEBUG_PRINT ("%s :: cm_config_session_start failed\n\r",
__FUNCTION__);
exit (1);
}
return_value = cm_config_session_update_cmd (pConfigSess, &Command2, &result_p);
if (return_value == OF_SUCCESS)
{
cm_config_session_end (pConfigSess, CM_CMD_CONFIG_SESSION_COMMIT, &result_p);
}
else
{
cm_config_session_end (pConfigSess, CM_CMD_CONFIG_SESSION_REVOKE, &result_p);
}
of_free (pConfigSess);
pConfigSess = NULL;
UCMFreeUCMResult (CM_COMMAND_CONFIG_SESSION_START, CM_CMD_ADD_PARAMS,
result_p);
result_p = NULL;
/* GET Request */
cm_get_first_n_records (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"Admin", "IGD.VSG{general}.NetObj.IPDB",
&KeysArray, &count_ui, &out_array_of_nv_pair_arr_p);
if (out_array_of_nv_pair_arr_p)
{
CM_TRANS_DEBUG_PRINT ("\r\n %s():: printint output ", __FUNCTION__);
for (uiCnt = 0; uiCnt < count_ui; uiCnt++)
{
for (uiNvCnt = 0; uiNvCnt < out_array_of_nv_pair_arr_p[uiCnt].count_ui;
uiNvCnt++)
{
CM_TRANS_DEBUG_PRINT ("\r\n %s():: Name = %s Value = %s ",
__FUNCTION__,
out_array_of_nv_pair_arr_p[uiCnt].nv_pairs[uiNvCnt].
name_p,
(char *) out_array_of_nv_pair_arr_p[uiCnt].
nv_pairs[uiNvCnt].value_p);
}
}
}
#endif
#ifdef CM_ROLES_PERM_SUPPORT
if (cm_dm_set_role_permissions_by_role (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG", CM_DM_DEFAULT_ROLE,
&RolePerm,NULL) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT ("UCMDM_Setrole_permissions Failed");
}
else
{
CM_TRANS_DEBUG_PRINT ("permissions succesfull");
}
RolePerm.permissions=0;
if (cm_dm_get_role_permissions_by_role (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG", CM_DM_DEFAULT_ROLE,
&RolePerm) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT ("GetPermissions ByRole Failed");
}
else
{
CM_TRANS_DEBUG_PRINT (" name = %s perms = %d", RolePerm.role, RolePerm.permissions);
}
if (cm_dm_get_role_permissions (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG", CM_DM_DEFAULT_ROLE,
&role_perm_ary_p) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT (" 1GetPermissions Failed");
}
else
{
CM_TRANS_DEBUG_PRINT ("Number of Roles %u at IGD.VSG", role_perm_ary_p->count_ui);
for (i = 0; i < role_perm_ary_p->count_ui; i++)
{
CM_TRANS_DEBUG_PRINT ("Role=%s Perm=%u",
role_perm_ary_p->role_permissions[i].role,
role_perm_ary_p->role_permissions[i].permissions);
}
of_free(role_perm_ary_p->role_permissions);
of_free(role_perm_ary_p);
role_perm_ary_p = NULL;
}
if (cm_dm_set_instance_role_permissions_by_role (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG{general}", CM_DM_DEFAULT_ROLE,
&RolePerm2) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT ("UCMDM_Setrole_permissions Failed");
}
else
{
CM_TRANS_DEBUG_PRINT ("permissions succesfull");
}
RolePerm2.permissions=0;
if (cm_dm_get_instance_role_permissions_by_role (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG{general}", CM_DM_DEFAULT_ROLE,
&RolePerm2) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT ("GetPermissions ByRole Failed");
}
else
{
CM_TRANS_DEBUG_PRINT (" name = %s perms = %d", RolePerm2.role, RolePerm2.permissions);
}
if (cm_dm_get_instance_role_permissions (tnsprt_channel_p, CM_CLI_MGMT_ENGINE_ID,
"IGD.VSG{general}", CM_DM_DEFAULT_ROLE,
&role_perm_ary_p) != OF_SUCCESS)
{
CM_TRANS_DEBUG_PRINT ("GetPermissions Failed");
}
else
{
CM_TRANS_DEBUG_PRINT ("Number of Roles %u at IGD.VSG{general}", role_perm_ary_p->count_ui);
for (i = 0; i < role_perm_ary_p->count_ui; i++)
{
CM_TRANS_DEBUG_PRINT ("Role=%s Perm=%u",
role_perm_ary_p->role_permissions[i].role,
role_perm_ary_p->role_permissions[i].permissions);
}
of_free(role_perm_ary_p->role_permissions);
of_free(role_perm_ary_p);
role_perm_ary_p = NULL;
}
#endif
}
/**************************************************************************
Function Name :
Input Args :
Output Args :
Description :
Return Values :
*************************************************************************/
int32_t igwCMDM_TestGetNodeAndChildInfo (uint32_t * pTestCount,
uint32_t * pFailCount)
{
uint32_t i;
int32_t return_value;
struct cm_dm_node_info *attrib_p;
uint32_t RootID = CM_DM_ROOT_NODE_ID;
struct cm_array_of_structs *child_attrib_arr_p;
struct cm_array_of_uints PathIDs;
of_memset (TestPath, 0, CM_DM_MAX_PATH_LEN + 1);
*pTestCount = *pTestCount + 1;
printf ("Test Extracting Node&Child Info By Name...");
return_value = cm_dm_get_node_and_child_info (CM_DM_TEST_ROOT_PATH,
&attrib_p, &child_attrib_arr_p);
if (return_value == OF_SUCCESS)
{
if ((!attrib_p) || (!child_attrib_arr_p))
{
if (attrib_p)
{
of_free (attrib_p);
}
if (child_attrib_arr_p)
{
of_free (child_attrib_arr_p);
}
*pFailCount = *pFailCount + 1;
return OF_FAILURE;
}
// printf("Parent Info :\n");
// igwCMDM_PrintAttribs(attrib_p);
of_free (attrib_p);
// printf("Children Info : \n");
attrib_p = (struct cm_dm_node_info *) child_attrib_arr_p->struct_arr_p;
for (i = 0; i < child_attrib_arr_p->count_ui; i++)
{
// igwCMDM_PrintAttribs((struct cm_dm_node_info*)(child_attrib_arr_p->struct_arr_p[i]));
if (igwCMDM_TestCompareAttribs (&(attrib_p[i]),
&(VsgChildNodes[i])) != OF_SUCCESS)
{
of_strncpy (TestPath, CM_DM_TEST_ROOT_PATH, CM_DM_MAX_PATH_LEN);
of_strcat (TestPath, VsgChildNodes[i].name_p);
printf (" Failed to retrieve info about node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
}
}
printf ("\n");
cm_dm_cleanup_array_of_node_attribs (child_attrib_arr_p);
*pTestCount = *pTestCount + 1;
printf ("Test Extracting Complete Node Info using Path IDs...");
PathIDs.count_ui = 1;
PathIDs.uint_arr_p = &RootID;
return_value = UCMCMDM_GetNodeAndChildInfoByPathIDs (&PathIDs,
&attrib_p, &child_attrib_arr_p);
if (return_value == OF_SUCCESS)
{
if ((!attrib_p) || (!child_attrib_arr_p))
{
if (attrib_p)
{
of_free (attrib_p);
}
if (child_attrib_arr_p)
{
of_free (child_attrib_arr_p);
}
*pFailCount = *pFailCount + 1;
return OF_FAILURE;
}
printf ("Parent Info :\n");
igwCMDM_PrintAttribs (attrib_p);
of_free (attrib_p);
printf ("Children Info : \n");
attrib_p = (struct cm_dm_node_info *) child_attrib_arr_p->struct_arr_p;
for (i = 0; i < child_attrib_arr_p->count_ui; i++)
{
igwCMDM_PrintAttribs (&attrib_p[i]);
if (igwCMDM_TestCompareAttribs (&(attrib_p[i]),
&(VsgChildNodes[i])) != OF_SUCCESS)
{
printf (" Failed to retrieve info about nodeID : %d\n", attrib_p->id_ui);
*pFailCount = *pFailCount + 1;
}
}
}
cm_dm_cleanup_array_of_node_attribs (child_attrib_arr_p);
printf ("... OK\n");
return OF_SUCCESS;
}
/****************************************************************************
** FunctionName : UCMJEFrameAndSendLogMsg
** Description : This Function frames JE Log message and send it.
** Input : ulMsgId:
** Output : NONE
** Return value : OF_SUCCESS/OF_FAILURE
*****************************************************************************/
void UCMJEFrameAndSendLogMsg (uint32_t ulMsgId,char *admin_name_p,char * admin_role_p,
uint32_t command_ui, char * dm_path_p, char * pInstance,struct cm_array_of_nv_pair *arr_nv_pair_p)
{
UCMLogMessage_t *pJELogMessage = NULL;
UCMJELogInfo_t *pJESpecificInfo = NULL;
UCMMSGSThrtMsgIdInfo_t *pJEMsgIdInfo = NULL;
struct cm_dm_data_element *pDMNode = NULL;
FILE *fp;
char aSysCmd[128];
int32_t iMsgRetVal;
uint32_t uiNvCnt, uiLen=0;
char *name_p = NULL;
pDMNode = (struct cm_dm_data_element *)
cmi_dm_get_dm_node_from_instance_path (dm_path_p, of_strlen (dm_path_p));
if (!pDMNode)
{
CM_JE_DEBUG_PRINT ("pDMNode is NULL");
return ;
}
pJEMsgIdInfo =
(UCMMSGSThrtMsgIdInfo_t *) of_calloc (1, sizeof (UCMMSGSThrtMsgIdInfo_t));
if (!pJEMsgIdInfo)
{
CM_JE_DEBUG_PRINT ("Memory Allocation Failed for pJEMsgIdInfo");
return;
}
iMsgRetVal = JEMsgsGetMsgInfo (ulMsgId, pJEMsgIdInfo);
if (iMsgRetVal != OF_SUCCESS) /* if MsgId not get the message Info */
{
CM_JE_DEBUG_PRINT ("Message Id Not found in defined messages");
of_free (pJEMsgIdInfo);
return;
}
if (pJEMsgIdInfo->usSeverity > JE_LOG_LEVEL)
{
CM_JE_DEBUG_PRINT ("Message loglevel >");
of_free (pJEMsgIdInfo);
return;
}
switch (pJEMsgIdInfo->ulMsgFamilyId)
{
case CM_LOG_FAMILY_JE:
{
pJELogMessage = (UCMLogMessage_t *)UCMAllocLogMessageBuf (sizeof (UCMJELogInfo_t));
if (NULL == pJELogMessage)
{
of_free (pJEMsgIdInfo);
return;
}
pJESpecificInfo =
(UCMJELogInfo_t *) pJELogMessage->MessageFamilySpecificInfo;
if (admin_name_p)
{
of_strncpy (pJESpecificInfo->admin_name, admin_name_p,
CM_JE_LOGDB_FIELD_UCMADMIN_LEN);
}
if (admin_role_p)
{
of_strncpy (pJESpecificInfo->admin_role, admin_role_p,
CM_JE_LOGDB_FIELD_UCMROLE_LEN);
}
if (dm_path_p)
{
of_strncpy (pJESpecificInfo->dmpath_a, dm_path_p,
CM_JE_LOGDB_FIELD_DMPATH_LEN);
}
if (pInstance)
{
of_strncpy (pJESpecificInfo->aInstance, pInstance,
CM_JE_LOGDB_FIELD_DMINSTANCE_LEN);
}
if(arr_nv_pair_p)
{
#ifdef CM_JE_DISPLAY_FRIENDLY_NAMES_IN_LOGMESGS
if(dm_path_p)
{
if( JEPrepareLogMessageCfgData(dm_path_p, arr_nv_pair_p, pJESpecificInfo) != OF_SUCCESS)
CM_JE_DEBUG_PRINT(" JEPrepareLogMessageCfgData failed");
}
else
#endif
{
for(uiNvCnt=0; uiNvCnt < arr_nv_pair_p->count_ui; uiNvCnt++)
{
uiLen += arr_nv_pair_p->nv_pairs[uiNvCnt].name_length + 1;
uiLen += arr_nv_pair_p->nv_pairs[uiNvCnt].value_length + 1;
if(uiLen >= CM_JE_LOGDB_FIELD_NVPAIRS_LEN)
{
CM_JE_DEBUG_PRINT("Exceeded Max Log Message Length");
break;
}
if(arr_nv_pair_p->nv_pairs[uiNvCnt].name_length > 0 )
{
of_strncat(pJESpecificInfo->aCfgData,name_p,of_strlen((char *)name_p));
of_strncat(pJESpecificInfo->aCfgData,"=",1);
}
if(arr_nv_pair_p->nv_pairs[uiNvCnt].value_length > 0 )
{
of_strncat(pJESpecificInfo->aCfgData,arr_nv_pair_p->nv_pairs[uiNvCnt].value_p,
of_strlen((char *)arr_nv_pair_p->nv_pairs[uiNvCnt].value_p));
}
of_strncat(pJESpecificInfo->aCfgData,";",1);
}
}
}
switch (command_ui)
{
case CM_CMD_ADD_PARAMS:
of_strncpy (pJESpecificInfo->aCommand, "Add",
CM_JE_LOGDB_FIELD_COMMAND_LEN);
break;
case CM_CMD_SET_PARAMS:
of_strncpy (pJESpecificInfo->aCommand, "Modify",
CM_JE_LOGDB_FIELD_COMMAND_LEN);
break;
case CM_CMD_DEL_PARAMS:
of_strncpy (pJESpecificInfo->aCommand, "Delete",
CM_JE_LOGDB_FIELD_COMMAND_LEN);
break;
}
if (bIpFound == FALSE)
{
sprintf(aSysCmd,"cat /var/state/dhcp/dhclient.leases | grep fixed-address | cut -d \" \" -f 4 | cut -d \";\" -f 1 >%s", CM_VORTIQA_DEVIP_FILE);
system(aSysCmd);
fp = fopen (CM_VORTIQA_DEVIP_FILE, "r");
if (!fp)
{
perror ("fopen");
CM_JE_DEBUG_PRINT("device ip file open failed");
}
else
{
fgets(aIpAddress_g,128,fp);
if (aIpAddress_g[0] != '\0')
{
CM_JE_DEBUG_PRINT("Ip address %s found", aIpAddress_g);
bIpFound=TRUE;
}
fclose(fp);
}
}
if (bIpFound== TRUE)
{
of_strncpy (pJESpecificInfo->aIpAddress, aIpAddress_g,
CM_JE_LOGDB_FIELD_COMMAND_LEN);
}
CM_JE_DEBUG_PRINT("Ip=%s Admin=%s Role=%s Cmd=%s DMPath=%s Instance=%s ",
pJESpecificInfo->aIpAddress,pJESpecificInfo->admin_name,
pJESpecificInfo->admin_role, pJESpecificInfo->aCommand,
pJESpecificInfo->dmpath_a, pJESpecificInfo->aInstance);
if(pDMNode->friendly_name_p != NULL)
of_strncpy(pJESpecificInfo->aTableName,pDMNode->friendly_name_p,of_strlen(pDMNode->friendly_name_p));
else
of_strncpy(pJESpecificInfo->aTableName,pDMNode->name_p,of_strlen(pDMNode->name_p));
}
break;
}
if (pJELogMessage)
{
// pJELogMessage->usSeverity = pJEMsgIdInfo->usSeverity;
pJELogMessage->usCategory = pJEMsgIdInfo->usCategory;
pJELogMessage->ulMsgId = pJEMsgIdInfo->ulMsgId;
pJELogMessage->ulMsgFamily = pJEMsgIdInfo->ulMsgFamilyId;
pJELogMessage->ulMsgSubFamily = pJEMsgIdInfo->ulSubFamilyId;
if (of_strlen (pJEMsgIdInfo->ucMsgDesc) > 0)
{
of_strncpy (pJELogMessage->pMesgDesc, pJEMsgIdInfo->ucMsgDesc,
CM_JE_LOGDB_FIELD_MSGDESC_LEN);
}
CM_JE_DEBUG_PRINT("Id=%d Msg=%s MsgSize=%d",pJELogMessage->ulMsgId, pJEMsgIdInfo->ucMsgDesc,
pJELogMessage->ulFamilySize);
UCMLogMessage (pJELogMessage);
}
of_free (pJEMsgIdInfo);
return;
}
int32_t HttpsSaveCerts( void )
{
uint32_t ulReclen = 0, ulTotalLen = 0, ulLen = 0;
int32_t ii, iIndex = 0, iRetVal = 0;
unsigned char cTempBuf[25], *pNextAddr;
unsigned char *pFlash, *pFlashBuffer;
uint32_t ulCheckSum = 0, ulFlashCheckSum = 0;
HTTPS_mblk_t *pmblk;
int32_t CertHandle = 0;
uint32_t ulCmgrPrmFlshHdl = -1; /* certificate's primary flash handler */
uint32_t ulCmgrSecFlshHdl = -1; /* certificate's secondary flash handler */
do
{
if (bHttpsNeedBkp)
{
if ((CertHandle = cm_file_open(iHttpsPrmFsId, pHCertPath,
UCMFILE_MODE_READ)) < 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: Unable to open file for Primary\n\r");
#endif /*HTTPD_DEBUG*/
break;
}
ulCmgrPrmFlshHdl = CertHandle;
CertHandle = 0;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_INFO,
"1. Destroying snd file system\n\r");
#endif /*HTTPD_DEBUG*/
if ((iHttpsSndFsId = HttpsNewFileSystem(TRUE, 1)) < 0)
{
return OF_FAILURE;
}
if ((CertHandle = cm_file_open(iHttpsSndFsId, pHCertBackupPath,
UCMFILE_MODE_WRITE)) < 0)
{
if ((CertHandle = cm_file_create(iHttpsSndFsId,
pHCertBackupPath)) < 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: Unable to create file for Secondry\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
break;
}
}
ulCmgrSecFlshHdl = CertHandle;
CertHandle = 0;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"\nSaving from Flash1 to Flash2.....\n");
#endif /*HTTPD_DEBUG*/
iRetVal = cm_file_read(iHttpsPrmFsId, ulCmgrPrmFlshHdl, cTempBuf, 8);
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: reading from Flash1 failed #1\n");
#endif /*HTTPD_DEBUG*/
break;
}
pNextAddr = cTempBuf;
of_memcpy(&ulTotalLen, pNextAddr, 4);
if (ulTotalLen > (64*1024))
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: flash1 seems to be corrupted\n");
#endif /*HTTPD_DEBUG*/
break;
}
if ((pFlashBuffer = (unsigned char *) of_calloc(1,
(ulTotalLen +10))) == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: memory allocation failed\n");
#endif /*HTTPD_DEBUG*/
break;
}
cm_file_seek(iHttpsPrmFsId, ulCmgrPrmFlshHdl, UCMFILE_SEEK_BEG,
0);
iRetVal = cm_file_read(iHttpsPrmFsId, ulCmgrPrmFlshHdl, pFlashBuffer,
(ulTotalLen+8));
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: reading from Flash1 failed #2\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
break;
}
pFlash = pFlashBuffer + 8;
of_memcpy(&ulFlashCheckSum, pNextAddr+4, 4);
for (ii = 0; ii < ulTotalLen; ii++)
{
ulCheckSum += pFlash[ii];
}
if (ulFlashCheckSum != ulCheckSum)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: check sum failed for Flash 1\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
break;
}
if (cm_file_write(iHttpsSndFsId, ulCmgrSecFlshHdl, pFlashBuffer,
(ulTotalLen+8)) < 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for secondary #1\n\r");
#endif /*HTTPD_DEBUG*/
}
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"Saved certificate from Flash1 to Flash2\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
cm_file_flush(iHttpsSndFsId, ulCmgrSecFlshHdl);
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
} /*if (bHttpsNeedBkp) */
} while (FALSE);
ulTotalLen = 0;
ulCheckSum = 0;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_INFO,
"Destroying PRM file system\n\r");
#endif /*HTTPD_DEBUG*/
if ((iHttpsPrmFsId = HttpsNewFileSystem(TRUE, 0)) < 0)
{
return OF_FAILURE;
}
if ((CertHandle = cm_file_open(iHttpsPrmFsId, pHCertPath,
UCMFILE_MODE_WRITE)) < 0)
{
if ((CertHandle = cm_file_create(iHttpsPrmFsId,
pHCertPath)) == OF_FAILURE)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: Unable to create file for Primary\n\r");
#endif /*HTTPD_DEBUG*/
return OF_FAILURE;
}
}
ulCmgrPrmFlshHdl = CertHandle;
cm_file_seek(iHttpsPrmFsId, ulCmgrPrmFlshHdl, UCMFILE_SEEK_BEG, 8);
of_memset(cTempBuf, 0, 25);
pNextAddr = cTempBuf;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"\nSaving Trusted Certificates into File...\n\r");
#endif /*HTTPD_DEBUG*/
for (iIndex = 0; iIndex < HTTPS_MAX_NUM_OF_CA_CERT; iIndex++)
{
if (HttpsCACert[iIndex].bValid == TRUE)
{
/* *((uint32_t*)pNextAddr) = ulReclen = HttpsCACert[iIndex].uicertcnt;*/
ulReclen = HttpsCACert[iIndex].uicertcnt;
of_memcpy(pNextAddr, &ulReclen, 4);
*(pNextAddr + 4) = 'c';
*(pNextAddr + 5) = HttpsCACert[iIndex].val.ucsigntype;
*(pNextAddr + 6) = HttpsCACert[iIndex].val.ucenctype;
*(pNextAddr + 7) = HttpsCACert[iIndex].val.ucdefcert;
*(pNextAddr + 8) = HttpsCACert[iIndex].val.uctype;
of_memcpy((pNextAddr + 12), HttpsCACert[iIndex].IdName, 8);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pNextAddr, 20) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #2\n\r");
#endif /*HTTPD_DEBUG*/
}
for (ii = 0; ii < 20; ii++)
{
ulCheckSum += pNextAddr[ii];
}
ulTotalLen += 20;
HttpsSeek(ulCmgrPrmFlshHdl, 20);
pmblk = HttpsCACert[iIndex].phead;
while (ulReclen > 0)
{
if (pmblk == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"Error - mblk pointer is NULL\n");
#endif /*HTTPD_DEBUG*/
return OF_FAILURE;
}
ulLen = MIN(ulReclen, 1024);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pmblk->pRptr, ulLen) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for Primary #4\n\r");
#endif /*HTTPD_DEBUG*/
}
ulReclen -= ulLen;
ulTotalLen += ulLen;
HttpsSeek(ulCmgrPrmFlshHdl, ulLen);
for (ii = 0; ii < ulLen; ii++)
{
ulCheckSum += pmblk->pRptr[ii];
}
pmblk = pmblk->pCont;
}
}
}
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"Saving Self Certificates into File...\n\r");
#endif /*HTTPD_DEBUG*/
for (iIndex = 0; iIndex < HTTPS_MAX_NUM_OF_KEY_CERT; iIndex++)
{
if (HttpsKeyCertPair[iIndex].bValid == TRUE)
{
/* *((uint32_t*)pNextAddr) = ulReclen = HttpsKeyCertPair[iIndex].uikeycnt; */
ulReclen = HttpsKeyCertPair[iIndex].uikeycnt;
of_memcpy(pNextAddr, &ulReclen, 4);
*(pNextAddr + 4) = 'p';
*(pNextAddr + 5) = HttpsKeyCertPair[iIndex].val.ucsigntype;
*(pNextAddr + 6) = HttpsKeyCertPair[iIndex].val.ucenctype;
*(pNextAddr + 7) = HttpsKeyCertPair[iIndex].val.ucdefcert;
*(pNextAddr + 8) = HttpsKeyCertPair[iIndex].val.uctype;
of_memcpy((pNextAddr + 12), HttpsKeyCertPair[iIndex].IdName, 8);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pNextAddr, 20) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #5\n\r");
#endif /*HTTPD_DEBUG*/
}
for (ii = 0; ii < 20; ii++)
{
ulCheckSum += pNextAddr[ii];
}
ulTotalLen += 20;
HttpsSeek(ulCmgrPrmFlshHdl, 20);
pmblk = HttpsKeyCertPair[iIndex].pkey;
while (ulReclen > 0)
{
if (pmblk == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "Error - mblk pointer is NULL\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
return OF_SUCCESS;
}
ulLen = MIN(ulReclen, 1024);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pmblk->pRptr, ulLen) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #6\n\r");
#endif /*HTTPD_DEBUG*/
}
ulReclen -= ulLen;
ulTotalLen += ulLen;
HttpsSeek(ulCmgrPrmFlshHdl, ulLen);
for (ii = 0; ii < ulLen; ii++)
{
ulCheckSum += pmblk->pRptr[ii];
}
pmblk = pmblk->pCont;
}
if ((pmblk = HttpsKeyCertPair[iIndex].pcert) != NULL)
{
/* *((uint32_t*)pNextAddr) = ulReclen =
HttpsKeyCertPair[iIndex].uicertcnt; */
ulReclen = HttpsKeyCertPair[iIndex].uicertcnt;
of_memcpy(pNextAddr, &ulReclen, 4);
*(pNextAddr + 4) = 'c';
*(pNextAddr + 8) = HttpsKeyCertPair[iIndex].val.uctype;
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pNextAddr, 20) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #7\n\r");
#endif /*HTTPD_DEBUG*/
}
for (ii = 0; ii < 20; ii++)
{
ulCheckSum += pNextAddr[ii];
}
ulTotalLen += 20;
HttpsSeek(ulCmgrPrmFlshHdl, 20);
while (ulReclen > 0)
{
if (pmblk == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "Error - mblk pointer is NULL\n");
#endif /*HTTPD_DEBUG*/
/* return OF_FAILURE; */
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
return OF_SUCCESS;
}
ulLen = MIN(ulReclen, 1024);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl,
pmblk->pRptr, ulLen) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #8\n\r");
#endif /*HTTPD_DEBUG*/
}
ulReclen -= ulLen;
ulTotalLen += ulLen;
HttpsSeek(ulCmgrPrmFlshHdl, ulLen);
for (ii = 0; ii < ulLen; ii++)
{
ulCheckSum += pmblk->pRptr[ii];
}
pmblk = pmblk->pCont;
}
}
}
}
/**
* Writing the total length and checksum now.
*/
pNextAddr = cTempBuf;
of_memset(pNextAddr, 0, sizeof(cTempBuf));
of_memcpy(pNextAddr, &ulTotalLen, 4);
of_memcpy(pNextAddr+4, &ulCheckSum, 4);
cm_file_seek(iHttpsPrmFsId, ulCmgrPrmFlshHdl, UCMFILE_SEEK_BEG, 0);
if (cm_file_write(iHttpsPrmFsId, ulCmgrPrmFlshHdl, pNextAddr, 8) <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsSaveCerts: cm_file_write failed for primary #9\n\r");
#endif /*HTTPD_DEBUG*/
}
cm_file_flush(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
bHttpsNeedBkp = TRUE;
return OF_SUCCESS;
} /* HttpsSaveCerts() */
/**************************************************************************
Function Name :
Input Args :
Output Args :
Description :
Return Values :
*************************************************************************/
int32_t igwCMDM_TestGetNodeInfo (uint32_t * pTestCount, uint32_t * pFailCount)
{
uint32_t i;
int32_t return_value;
struct cm_dm_node_info *attrib_p;
struct cm_array_of_uints ArrayOfUints;
uint32_t uiNodeCount = sizeof (VsgChildNodes) / sizeof (struct cm_dm_data_element);
of_memset (TestPath, 0, CM_DM_MAX_PATH_LEN + 1);
printf ("Test Extracting Node Information...");
/* Retrieve valid node information */
for (i = 0; i < uiNodeCount; i++)
{
*pTestCount = *pTestCount + 1;
of_strcpy (TestPath, "/vsg/");
of_strncat (TestPath, VsgChildNodes[i].name_p,
(CM_DM_MAX_PATH_LEN - of_strlen (TestPath)));
attrib_p = NULL;
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
// igwCMDM_PrintAttribs(attrib_p);
if (igwCMDM_TestCompareAttribs (attrib_p, &(VsgChildNodes[i])) !=
OF_SUCCESS)
{
printf (" Failed to extract info about node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
of_free (attrib_p);
}
else
{
*pFailCount = *pFailCount + 1;
}
}
/* Retrieve Invalid Node information */
*pTestCount = *pTestCount + 1;
of_strncpy (TestPath, "trash", CM_DM_MAX_PATH_LEN);
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
printf (" Failed to identify invalid node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
/* Retrieve Invalid Node information */
*pTestCount = *pTestCount + 1;
of_strcpy (TestPath, "/");
of_strcat (TestPath, "trash");
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
printf (" Failed to identify invalid node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
/* Retrieve Invalid Node information */
*pTestCount = *pTestCount + 1;
of_strncpy (TestPath, CM_DM_TEST_ROOT_PATH, CM_DM_MAX_PATH_LEN);
of_strcat (TestPath, "/trash");
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
printf (" Failed to identify invalid node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
/* Retrieve Invalid Node information */
*pTestCount = *pTestCount + 1;
of_strncpy (TestPath, CM_DM_TEST_ROOT_PATH, CM_DM_MAX_PATH_LEN);
of_strcat (TestPath, "/fw/trash");
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
printf (" Failed to identify invalid node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
/* Retrieve Invalid Node information */
*pTestCount = *pTestCount + 1;
of_strcpy (TestPath, "/vsg/");
of_strcat (TestPath, "fw///trash");
return_value = UCMCMDM_GetNodeInfo (TestPath, &attrib_p);
if (return_value == OF_SUCCESS)
{
printf (" Failed to identify invalid node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
/* Retrieve node info by path IDs */
ArrayOfUints.uint_arr_p = (uint32_t *) of_calloc (2, sizeof (uint32_t));
if (ArrayOfUints.uint_arr_p == NULL)
{
return OF_FAILURE;
}
ArrayOfUints.count_ui = 2;
ArrayOfUints.uint_arr_p[0] = CM_DM_ROOT_NODE_ID;
for (i = 0; i < uiNodeCount; i++)
{
*pTestCount = *pTestCount + 1;
ArrayOfUints.uint_arr_p[1] = VsgChildNodes[i].id_ui;
attrib_p = NULL;
return_value = UCMCMDM_GetNodeInfoByPathIDs (&ArrayOfUints, &attrib_p);
if (return_value == OF_SUCCESS)
{
// igwCMDM_PrintAttribs(attrib_p);
if (igwCMDM_TestCompareAttribs (attrib_p, &(VsgChildNodes[i])) !=
OF_SUCCESS)
{
printf (" Failed to extract info about node : %s\n", TestPath);
*pFailCount = *pFailCount + 1;
}
of_free (attrib_p);
}
else
{
*pFailCount = *pFailCount + 1;
}
}
of_free (ArrayOfUints.uint_arr_p);
printf ("... OK\n");
return OF_SUCCESS;
}
int32_t nsrm_selection_rule_attribute_addrec (void * config_trans_p,
struct cm_array_of_iv_pairs * pMandParams,
struct cm_array_of_iv_pairs * pOptParams,
struct cm_app_result ** result_p)
{
struct cm_app_result *attribute_result = NULL;
struct nsrm_attribute_name_value_pair nsrm_attribute_name_value_info= {};
char* selection_rule_name_p;
char* nschainset_object_name_p;
int32_t ret_value;
CM_CBK_DEBUG_PRINT("Entered");
selection_rule_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
nschainset_object_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
if((nsrm_selection_rule_attribute_ucm_setmandparams (
pMandParams,
selection_rule_name_p,nschainset_object_name_p,
&nsrm_attribute_name_value_info,
&attribute_result)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
fill_app_result_struct (&attribute_result, NULL, CM_GLU_SET_MAND_PARAM_FAILED);
*result_p = attribute_result;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
ret_value = nsrm_add_attribute_to_nschain_selection_rule(selection_rule_name_p,nschainset_object_name_p,
&nsrm_attribute_name_value_info);
if (ret_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Service Attribute Addition Failed");
fill_app_result_struct (&attribute_result, NULL, CM_GLU_ATTRIBUTE_ADD_FAILED);
*result_p = attribute_result;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("Attribute added succesfully");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_SUCCESS;
}
int32_t nsrm_bypassrule_getexactrec(struct cm_array_of_iv_pairs * key_iv_pairs_p,
struct cm_array_of_iv_pairs ** pIvPairArr)
{
struct cm_array_of_iv_pairs *result_iv_pairs_p = NULL;
struct nsrm_nwservice_bypass_rule_key *nsrm_bypassrule_key_info;
uint32_t uiRecCount = 0;
int32_t iRes = OF_FAILURE;
struct nsrm_nwservice_bypass_rule_record *bypassrule_object_config_info;
struct nsrm_nwservice_bypass_rule_config_info* nsrm_bypass_config_info;
struct nsrm_nschain_object_key* nschain_object_key_p;
CM_CBK_DEBUG_PRINT ("Entered");
nsrm_bypassrule_key_info = (struct nsrm_nwservice_bypass_rule_key*)
of_calloc(1, sizeof(struct nsrm_nwservice_bypass_rule_key));
nsrm_bypass_config_info = (struct nsrm_nwservice_bypass_rule_config_info *)
of_calloc(NSRM_MAX_BYPASS_RULE_CONFIG_PARAMETERS, sizeof(struct nsrm_nwservice_bypass_rule_config_info));
nschain_object_key_p = (struct nsrm_nschain_object_key *)
of_calloc(1, sizeof(struct nsrm_nschain_object_key));
bypassrule_object_config_info = (struct nsrm_nwservice_bypass_rule_record *) of_calloc(1, sizeof(struct nsrm_nwservice_bypass_rule_record));
bypassrule_object_config_info->info = (struct nsrm_nwservice_bypass_rule_config_info*)of_calloc(NSRM_MAX_BYPASS_RULE_CONFIG_PARAMETERS,sizeof(struct nsrm_nwservice_bypass_rule_config_info));
bypassrule_object_config_info->key.name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
bypassrule_object_config_info->key.tenant_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
bypassrule_object_config_info->key.nschain_object_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
bypassrule_object_config_info->info[8].value.relative_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
if((nsrm_bypassrule_ucm_setmandparams(key_iv_pairs_p, nsrm_bypassrule_key_info,
nschain_object_key_p, nsrm_bypass_config_info)) !=OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
iRes = nsrm_get_exact_bypass_rule_from_nschain_object (nschain_object_key_p, nsrm_bypassrule_key_info,
bypassrule_object_config_info);
if (iRes != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Error: Appliacne doesn't exists with name %s",nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("Exact matching record found");
result_iv_pairs_p =
(struct cm_array_of_iv_pairs *) of_calloc (1, sizeof (struct cm_array_of_iv_pairs));
if (result_iv_pairs_p == NULL)
{
CM_CBK_DEBUG_PRINT ("Failed to allocate memory for result_iv_pairs_p");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
nsrm_bypassrule_ucm_getparams(bypassrule_object_config_info, &result_iv_pairs_p[uiRecCount]);
*pIvPairArr = result_iv_pairs_p;
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_SUCCESS;
}
int32_t nsrm_selection_rule_attribute_getfirstnrecs(struct cm_array_of_iv_pairs * keys_arr_p,
uint32_t * count_p,
struct cm_array_of_iv_pairs ** array_of_iv_pair_arr_p)
{
struct cm_array_of_iv_pairs *result_iv_pairs_p = NULL;
struct nsrm_attribute_name_value_pair nsrm_attribute_name_value_info= {};
struct nsrm_attribute_name_value_output_info nsrm_attribute_output= {};
char* selection_rule_name_p ;
char* nschainset_object_name_p;
int32_t return_value = OF_FAILURE;
uint32_t uiRecCount = 0;
selection_rule_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
nschainset_object_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
if((nsrm_selection_rule_attribute_ucm_setmandparams (keys_arr_p,selection_rule_name_p, nschainset_object_name_p,
&nsrm_attribute_name_value_info,NULL)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
nsrm_attribute_output.name_p = of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_attribute_output.value_p = of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_attribute_output.attr_length = NSRM_MAX_NAME_LENGTH -1;
nsrm_attribute_output.val_length = NSRM_MAX_NAME_LENGTH -1;
return_value = nsrm_get_first_selection_rule_attribute(
selection_rule_name_p,
nschainset_object_name_p,
&nsrm_attribute_output);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Unable to get first n attribute records!");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
of_free(nsrm_attribute_output.name_p );
of_free(nsrm_attribute_output.value_p);
return OF_FAILURE;
}
result_iv_pairs_p = (struct cm_array_of_iv_pairs *)of_calloc(1,sizeof(struct cm_array_of_iv_pairs));
if (result_iv_pairs_p == NULL)
{
CM_CBK_DEBUG_PRINT ("Memory allocation failed for result_iv_pairs_p");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
of_free(nsrm_attribute_output.name_p );
of_free(nsrm_attribute_output.value_p);
return OF_FAILURE;
}
nsrm_selection_rule_attribute_getparams(&nsrm_attribute_output, &result_iv_pairs_p[uiRecCount]);
uiRecCount++;
*array_of_iv_pair_arr_p = result_iv_pairs_p;
*count_p = uiRecCount;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
of_free(nsrm_attribute_output.name_p );
of_free(nsrm_attribute_output.value_p);
return NSRM_SUCCESS;
}
int32_t nsrm_selection_rule_attribute_getexactrec (struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_array_of_iv_pairs ** pIvPairArr)
{
struct cm_array_of_iv_pairs *result_iv_pairs_p = NULL;
struct nsrm_attribute_name_value_pair nsrm_attribute_name_value_info= {};
struct nsrm_attribute_name_value_output_info nsrm_attribute_output= {};
char* selection_rule_name_p ;
char* nschainset_object_name_p;
int32_t return_value = OF_FAILURE;
CM_CBK_DEBUG_PRINT ("Entered");
result_iv_pairs_p =
(struct cm_array_of_iv_pairs *) of_calloc (1, sizeof (struct cm_array_of_iv_pairs));
if (result_iv_pairs_p == NULL)
{
CM_CBK_DEBUG_PRINT ("Failed to allocate memory for result_iv_pairs_p");
return OF_FAILURE;
}
selection_rule_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
nschainset_object_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
CM_CBK_DEBUG_PRINT ("nschainset_object_name_p : %s",nschainset_object_name_p);
if ((nsrm_selection_rule_attribute_ucm_setmandparams (keys_arr_p,selection_rule_name_p,nschainset_object_name_p,
&nsrm_attribute_name_value_info,NULL)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
nsrm_attribute_output.name_p = of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_attribute_output.value_p = of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_attribute_output.attr_length = NSRM_MAX_NAME_LENGTH -1;
nsrm_attribute_output.val_length = NSRM_MAX_NAME_LENGTH -1;
return_value = nsrm_get_exact_selection_rule_attribute(
selection_rule_name_p,nschainset_object_name_p,
nsrm_attribute_name_value_info.attribute_name_p,
&nsrm_attribute_output
);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Unable to find exact attribute record!");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
of_free(nsrm_attribute_output.name_p );
of_free(nsrm_attribute_output.value_p);
return OF_FAILURE;
}
nsrm_selection_rule_attribute_getparams(&nsrm_attribute_output, result_iv_pairs_p);
*pIvPairArr = result_iv_pairs_p;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
of_free(nsrm_attribute_output.name_p );
of_free(nsrm_attribute_output.value_p);
return return_value;
}
int32_t nsrm_selection_rule_attribute_delrec (void * config_transaction_p,
struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_app_result ** result_p)
{
struct cm_app_result *attribute_result = NULL;
struct nsrm_attribute_name_value_pair nsrm_attribute_name_value_info= {};
char* selection_rule_name_p;
char* nschainset_object_name_p;
int32_t ret_value;
selection_rule_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
nschainset_object_name_p = (char*)of_calloc(1,NSRM_MAX_NAME_LENGTH);
if((nsrm_selection_rule_attribute_ucm_setmandparams (
keys_arr_p,
selection_rule_name_p,nschainset_object_name_p,
&nsrm_attribute_name_value_info,
&attribute_result)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
fill_app_result_struct (&attribute_result, NULL, CM_GLU_SET_MAND_PARAM_FAILED);
*result_p = attribute_result;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
ret_value = nsrm_del_attribute_from_nschain_selection_rule(selection_rule_name_p,nschainset_object_name_p,
nsrm_attribute_name_value_info.attribute_name_p);
if (ret_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Delete attribute record failed");
fill_app_result_struct (&attribute_result, NULL, CM_GLU_ATTRIBUTE_DEL_FAILED);
*result_p = attribute_result;
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("service attribute deleted succesfully");
of_free(selection_rule_name_p);
of_free(nschainset_object_name_p);
of_free(nsrm_attribute_name_value_info.attribute_name_p);
of_free(nsrm_attribute_name_value_info.attribute_value_p);
return OF_SUCCESS;
}
static int do_oftree(int argc, char *argv[])
{
struct fdt_header *fdt = NULL;
void *fdt_free = NULL;
int size;
int opt;
char *file = NULL;
const char *node = "/";
int dump = 0;
int probe = 0;
int load = 0;
int save = 0;
int free_of = 0;
int ret;
while ((opt = getopt(argc, argv, "dpfn:ls")) > 0) {
switch (opt) {
case 'l':
load = 1;
break;
case 'd':
dump = 1;
break;
case 'p':
if (IS_ENABLED(CONFIG_CMD_OFTREE_PROBE)) {
probe = 1;
} else {
printf("oftree device probe support disabled\n");
return COMMAND_ERROR_USAGE;
}
break;
case 'f':
free_of = 1;
break;
case 'n':
node = optarg;
break;
case 's':
save = 1;
break;
}
}
if (free_of) {
struct device_node *root = of_get_root_node();
if (root)
of_free(root);
return 0;
}
if (optind < argc)
file = argv[optind];
if (!dump && !probe && !load && !save)
return COMMAND_ERROR_USAGE;
if (save) {
if (!file) {
printf("no file given\n");
ret = -ENOENT;
goto out;
}
fdt = of_get_fixed_tree(NULL);
if (!fdt) {
printf("no devicetree available\n");
ret = -EINVAL;
goto out;
}
ret = write_file(file, fdt, fdt_totalsize(fdt));
goto out;
}
if (file) {
fdt = read_file(file, &size);
if (!fdt) {
printf("unable to read %s\n", file);
return 1;
}
fdt_free = fdt;
}
if (load) {
if (!fdt) {
printf("no fdt given\n");
ret = -ENOENT;
goto out;
}
ret = of_unflatten_dtb(fdt);
if (ret) {
printf("parse oftree: %s\n", strerror(-ret));
goto out;
}
}
if (dump) {
if (fdt) {
ret = fdt_print(fdt, node);
} else {
struct device_node *n = of_find_node_by_path(node);
if (!n) {
ret = -ENOENT;
goto out;
}
of_print_nodes(n, 0);
ret = 0;
}
goto out;
}
if (probe) {
ret = of_probe();
if (ret)
goto out;
}
ret = 0;
out:
free(fdt_free);
return ret;
}
int32_t nsrm_bypassrule_modrec (void * config_trans_p,
struct cm_array_of_iv_pairs * pMandParams,
struct cm_array_of_iv_pairs * pOptParams,
struct cm_app_result ** result_p)
{
struct cm_app_result *nsrm_bypassrule_result = NULL;
int32_t return_value = OF_FAILURE;
struct nsrm_nwservice_bypass_rule_key *nsrm_bypassrule_key_info = NULL;
struct nsrm_nwservice_bypass_rule_config_info *nsrm_bypassrule_config_info = NULL;
struct nsrm_nschain_object_key* nschain_object_key_p = NULL;
CM_CBK_DEBUG_PRINT ("Entered(nsrm_category_addrec)");
nschain_object_key_p = (struct nsrm_nschain_object_key *)
of_calloc(1, sizeof(struct nsrm_nschain_object_key));
nsrm_bypassrule_key_info = (struct nsrm_nwservice_bypass_rule_key*)
of_calloc(1, sizeof(struct nsrm_nwservice_bypass_rule_key));
nsrm_bypassrule_config_info = (struct nsrm_nwservice_bypass_rule_config_info *)
of_calloc(NSRM_MAX_BYPASS_RULE_CONFIG_PARAMETERS, sizeof(struct nsrm_nwservice_bypass_rule_config_info));
if ((nsrm_bypassrule_ucm_setmandparams (pMandParams, nsrm_bypassrule_key_info,
nschain_object_key_p, nsrm_bypassrule_config_info)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
fill_app_result_struct (&nsrm_bypassrule_result, NULL, CM_GLU_SET_MAND_PARAM_FAILED);
*result_p=nsrm_bypassrule_result;
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
if ((nsrm_bypassrule_ucm_setoptparams (pOptParams, nsrm_bypassrule_key_info,
nsrm_bypassrule_config_info)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Optional Parameters Failed");
fill_app_result_struct (&nsrm_bypassrule_result, NULL, CM_GLU_SET_OPT_PARAM_FAILED);
*result_p=nsrm_bypassrule_result;
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
return_value = nsrm_modify_nwservice_bypass_rule (nsrm_bypassrule_key_info, 2,
nsrm_bypassrule_config_info);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("nsrm bypassrule modify Failed");
fill_app_result_struct (&nsrm_bypassrule_result, NULL, CM_GLU_BYPASS_RULE_MOD_FAILED);
*result_p = nsrm_bypassrule_result;
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
CM_CBK_DEBUG_PRINT ("NSRM bypassrule modified successfully");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_SUCCESS;
}
/******************************************************************************
* Function Name : cm_tnsprt_create_channel
* Description : This API is used to create a Transport Channel
* Input params : trans_protocol_ui - Transport Protocol
* src_port_ui - Source Port
* addr_ui - IP Address
* dest_port_ui - Destination Port
* Output params : NONE
* Return value : Return pointer to Transport channel on successful creation of
* socket and connecting to the Server.
* NULL Pointer on failure.
*****************************************************************************/
void * cm_tnsprt_create_channel (uint8_t trans_protocol_ui, uint32_t addr_ui,
uint16_t src_port_ui, uint16_t dest_port_ui)
{
struct cm_tnsprt_channel *tnsprt_channel_p;
if(addr_ui == 0)
{
/*
* if the user does not specify the IP Address,
* consider the loopback address.
*/
addr_ui = CM_LOOPBACK_ADDR;
}
/* Allocate transport channel node */
tnsprt_channel_p =
(struct cm_tnsprt_channel *) of_calloc (1, sizeof (struct cm_tnsprt_channel));
if (unlikely (tnsprt_channel_p == NULL))
{
CM_TRANS_DEBUG_PRINT ("Unable to allocate memory");
return NULL;
}
/* Create Socket */
tnsprt_channel_p->sock_fd_i = cm_socket_create (trans_protocol_ui);
if (unlikely (tnsprt_channel_p->sock_fd_i == OF_FAILURE))
{
CM_TRANS_DEBUG_PRINT ("Failed to create socket");
of_free (tnsprt_channel_p);
tnsprt_channel_p = NULL;
return NULL;
}
/* Bind to local port, if requested */
if (src_port_ui)
{
if (cm_socket_bind (tnsprt_channel_p->sock_fd_i, addr_ui, src_port_ui)
== OF_FAILURE)
{
CM_TRANS_DEBUG_PRINT ("Unable to bind to port %d", src_port_ui);
cm_socket_close (tnsprt_channel_p->sock_fd_i);
of_free (tnsprt_channel_p);
tnsprt_channel_p = NULL;
return NULL;
}
}
/* Now connect to UCM infrastructure */
if (trans_protocol_ui == CM_IPPROTO_TCP)
{
if (cm_socket_connect (tnsprt_channel_p->sock_fd_i, addr_ui,
dest_port_ui) == OF_FAILURE)
{
CM_TRANS_DEBUG_PRINT ("Unable to connect to loopback port %d", dest_port_ui);
cm_socket_close (tnsprt_channel_p->sock_fd_i);
of_free (tnsprt_channel_p);
tnsprt_channel_p = NULL;
return NULL;
}
}
return ((void *) tnsprt_channel_p);
}
int32_t HttpsLoadCerts( void )
{
int32_t theError = OF_SUCCESS;
HX509Cert_t *pX509Cert = NULL;
EVP_PKEY *pPrivKey = NULL;
uint32_t ulReclen, ulKeyType, ulTotalLen;
int32_t iRetVal = -1, ii;
unsigned char *pCertOrKey;
unsigned char ucEncType, ucDefCert;
unsigned char ucRecType, ucSignType, ucCertType;
unsigned char *pFlashBuffer=NULL, cTempBuf[25], *pNextAddr, *pFlash;
bool bReadFromCert2 = FALSE;
uint32_t ulCheckSum = 0, ulFlashCheckSum = 0;
int16_t iRSAIndex = 0;
unsigned char aIdName[8];
int32_t CertHandle = 0;
/**
* Certificate's primary flash handler.
*/
uint32_t ulCmgrPrmFlshHdl = -1;
/**
* Certificate's secondary flash handler.
*/
uint32_t ulCmgrSecFlshHdl = -1;
bool bPrmExist = TRUE;
of_memset(cTempBuf, 0, sizeof(cTempBuf));
if ((CertHandle = cm_file_open(iHttpsPrmFsId, pHCertPath,
UCMFILE_MODE_READ)) < 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Unable to open file for Primary\n\r");
#endif /*HTTPD_DEBUG*/
bPrmExist = FALSE;
}
ulCmgrPrmFlshHdl = CertHandle;
if (!bPrmExist)
{
if ((CertHandle = cm_file_open(iHttpsSndFsId, pHCertBackupPath,
UCMFILE_MODE_READ)) <= OF_FAILURE)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Unable to open file for Backup\n\r");
#endif /*HTTPD_DEBUG*/
return OF_FAILURE;
}
bReadFromCert2 = TRUE;
ulCmgrSecFlshHdl = CertHandle;
}
else
{
cm_file_seek(iHttpsPrmFsId, ulCmgrPrmFlshHdl, UCMFILE_SEEK_BEG, 0);
iRetVal = cm_file_read(iHttpsPrmFsId, ulCmgrPrmFlshHdl, cTempBuf, 8);
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: reading from Flash1 failed #1\n\r");
#endif /*HTTPD_DEBUG*/
bReadFromCert2 = TRUE;
}
pNextAddr = cTempBuf;
of_memcpy(&ulTotalLen, pNextAddr, 4);
do
{
if (bReadFromCert2 == TRUE)
{
break;
}
if (ulTotalLen > (64*1024))
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Flash1 seems to be corrupted\n");
#endif /*HTTPD_DEBUG*/
bReadFromCert2 = TRUE;
break;
}
if ((pFlashBuffer = (unsigned char *) of_calloc(1,
(ulTotalLen +10))) == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: memory allocation failed\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
if (ulCmgrSecFlshHdl >= 0)
{
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
}
bHttpsNeedBkp = TRUE;
return OF_FAILURE;
}
cm_file_seek(iHttpsPrmFsId, ulCmgrPrmFlshHdl, UCMFILE_SEEK_BEG,
0);
iRetVal = cm_file_read(iHttpsPrmFsId, ulCmgrPrmFlshHdl, pFlashBuffer,
(ulTotalLen+8));
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: reading from flash1 failed #2\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
bReadFromCert2 = TRUE;
bHttpsNeedBkp = FALSE;
break;
}
pFlash = pFlashBuffer + 8;
of_memcpy(&ulFlashCheckSum, pNextAddr+4, 4);
for (ii = 0; ii < ulTotalLen; ii++)
{
ulCheckSum += pFlash[ii];
}
if (ulFlashCheckSum != ulCheckSum)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: check sum failed for Flash 1\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
bReadFromCert2 = TRUE;
bHttpsNeedBkp = FALSE;
break;
}
bHttpsNeedBkp = TRUE;
} while (FALSE);
cm_file_close(iHttpsPrmFsId, ulCmgrPrmFlshHdl);
} /* if (!bPrmExist) */
if ((bReadFromCert2) &&
(ulCmgrSecFlshHdl >= 0))
{
iRetVal = cm_file_read(iHttpsSndFsId, ulCmgrSecFlshHdl, cTempBuf, 8);
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: reading from Flash2 failed #1\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
return OF_FAILURE;
}
pNextAddr = cTempBuf;
of_memcpy(&ulTotalLen, pNextAddr, 4);
if (ulTotalLen > (64*1024))
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: reading from Flash2 failed #2\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
return OF_FAILURE;
}
if ((pFlashBuffer = (unsigned char *) of_calloc(1,
(ulTotalLen +10))) == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: memory allocation failed\n");
#endif /*HTTPD_DEBUG*/
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
return OF_FAILURE;
}
cm_file_seek(iHttpsSndFsId, ulCmgrSecFlshHdl, UCMFILE_SEEK_BEG, 0);
iRetVal = cm_file_read(iHttpsSndFsId, ulCmgrSecFlshHdl, pFlashBuffer,
(ulTotalLen+8));
if (iRetVal <= 0)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: reading from flash2 failed #3\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
return OF_FAILURE;
}
cm_file_close(iHttpsSndFsId, ulCmgrSecFlshHdl);
pFlash = pFlashBuffer + 8;
of_memcpy(&ulFlashCheckSum, pNextAddr+4, 4);
ulCheckSum = 0;
for (ii = 0; ii < ulTotalLen; ii++)
{
ulCheckSum += pFlash[ii];
}
if (ulFlashCheckSum != ulCheckSum)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: check sum failed for flash 2\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
return OF_FAILURE;
}
}
pNextAddr = pFlashBuffer + 8;
while (ulTotalLen > 0)
{
of_memcpy(&ulReclen, pNextAddr, 4);
if ((pCertOrKey = (unsigned char *) of_calloc(1, (ulReclen + 2))) == NULL)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: memory allocation failed\n");
#endif /*HTTPD_DEBUG*/
of_free(pFlashBuffer);
return OF_FAILURE;
}
ucRecType = *((unsigned char*)(pNextAddr+4));
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "\ncert or key type = %c\n",
ucRecType);
#endif /*HTTPD_DEBUG*/
ucSignType = *((unsigned char *)(pNextAddr+5));
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "Signature type = %c\n", ucSignType);
#endif /*HTTPD_DEBUG*/
ucCertType = *((unsigned char *)(pNextAddr+8));
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "certificate type = %c\n", ucCertType);
#endif /*HTTPD_DEBUG*/
ucEncType = *((unsigned char *)(pNextAddr+6));
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "encoding type = %c\n", ucEncType);
#endif /*HTTPD_DEBUG*/
ucDefCert = *((unsigned char *)(pNextAddr+7));
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE, "is default = %c\n", ucDefCert);
#endif /*HTTPD_DEBUG*/
of_memcpy(pCertOrKey, pNextAddr+ 20, ulReclen);
switch (ucCertType)
{
case 't':
of_memset(aIdName, 0, 8);
theError = HttpsFlashWriteTrust(ucCertType, ucRecType, ucEncType,
ucDefCert, ucSignType, pCertOrKey,
ulReclen, aIdName);
if (theError != OF_SUCCESS)
{
theError = HTTPS_READ_FILE_FAILED;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Error in putting encoded cert in memory\n");
#endif /*HTTPD_DEBUG*/
break;
}
theError = HttpsReadFromFile(pCertOrKey, HTTPS_CERT,
(void**)&pX509Cert, ucSignType);
if (theError != OF_SUCCESS)
{
theError = HTTPS_READ_FILE_FAILED;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Error in extracting X509cert\n");
#endif /*HTTPD_DEBUG*/
break;
}
if (HttpsVerifyTrustedCert(pX509Cert) != OF_SUCCESS)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Verify cert failed.\n");
#endif /*HTTPD_DEBUG*/
}
ulKeyType = OBJ_obj2nid(pX509Cert->cert_info->key->algor->algorithm);
if ((ulKeyType == EVP_PKEY_RSA) ||
(ulKeyType == EVP_PKEY_RSA2))
{
sk_push(/*(STACK *)*/(_STACK *) HttpsRSATrustedCACerts, (char *)pX509Cert);
#if 0
#ifdef IGW_UCM_DP_CHANNEL_SUPPORT
sk_push((STACK *) HttpsRSATrustedCACerts, (char *)pX509Cert);
#else
sk_push((_STACK *) HttpsRSATrustedCACerts, (char *)pX509Cert);
#endif
#endif
}
else
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Cert Type invalid\n");
#endif /*HTTPD_DEBUG*/
of_free(pCertOrKey);
of_free(pFlashBuffer);
/* return OF_FAILURE; */
return OF_SUCCESS;
}
HttpsMaxCAs++;
break;
case 's':
of_memcpy(aIdName, pNextAddr + 12, 8);
theError = HttpsFlashWrite(ucCertType, ucRecType, ucEncType,
ucDefCert, ucSignType, pCertOrKey,
ulReclen, aIdName);
if (theError != OF_SUCCESS)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Copying the encoded cert in memory failed\n");
#endif /*HTTPD_DEBUG*/
break;
}
switch (ucRecType)
{
case 'p':
if ((*(pNextAddr + ulReclen + 24) == 'c') &&
(!memcmp((pNextAddr + ulReclen + 32), aIdName, 8)))
{
theError = HttpsReadFromFile(pCertOrKey, HTTPS_PRIV_KEY,
(void**)&pPrivKey, ucSignType);
if (theError != OF_SUCCESS)
{
theError = HTTPS_READ_FILE_FAILED;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: HttpsReadFromFile failed #1\n");
#endif /*HTTPD_DEBUG*/
break;
}
if ((ucSignType == 'r') ||
(ucSignType == 'R'))
{
of_memcpy(HttpsRSAKeyPairs[iRSAIndex].aIDName, aIdName, 8);
HttpsRSAKeyPairs[iRSAIndex].pMyPrivKey = pPrivKey;
HttpsRSAKeyPairs[iRSAIndex].bUsed = TRUE;
iRSAIndex++;
}
}
break;
case 'c':
pX509Cert = NULL;
theError = HttpsReadFromFile(pCertOrKey, HTTPS_CERT,
(void**)&pX509Cert, ucSignType);
if (theError != OF_SUCCESS)
{
theError = HTTPS_READ_FILE_FAILED;
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: HttpsReadFromFile failed #2\n");
#endif /*HTTPD_DEBUG*/
break;
}
if (HttpsVerifySelfCert(pX509Cert) != OF_SUCCESS)
{
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: VerifyCert returned error\n");
#endif /*HTTPD_DEBUG*/
}
ulKeyType=OBJ_obj2nid(pX509Cert->cert_info->key->algor->algorithm);
if ((ulKeyType == EVP_PKEY_RSA) ||
(ulKeyType == EVP_PKEY_RSA2))
{
for (ii = 0; ii < 10; ii++)
{
if (!memcmp(HttpsRSAKeyPairs[ii].aIDName, aIdName, 8))
{
break;
}
}
if (ii != 10)
{
HttpsRSAKeyPairs[ii].pMyCert = pX509Cert;
}
}
break;
default:
#ifdef HTTPD_DEBUG
Trace(HTTPS_ID, TRACE_SEVERE,
"HttpsLoadCerts: Strange - record type is other than key/cert\n");
#endif /*HTTPD_DEBUG*/
break;
}
break;
}
of_free(pCertOrKey);
if (theError != OF_SUCCESS)
{
of_free(pFlashBuffer);
return theError;
}
pNextAddr += (ulReclen + 20);
ulTotalLen -= (ulReclen + 20);
}
of_free(pFlashBuffer);
return OF_SUCCESS;
} /* HttpsLoadCerts() */
/**************************************************************************
Function Name :cm_ldsv_flush
Input Args :
pTransportChannel: Pointer to Transport Channel.
pCommand: Pointer to Command.
uiMgmtEngineID: Management engine id.
pRoleInfo: Pointer to user roles.
Output Args :
ppResult: Pointer of pointer to the result message.
Description :This method is used to flush configuration data
Return Values :OF_SUCCESS/OF_FAILURE
**************************************************************************/
int32_t cm_ldsv_flush (void * pTransportChannel,
struct cm_command * pCommand,
struct cm_result ** ppResult,
uint32_t uiMgmtEngineID,
struct cm_role_info * pRoleInfo)
{
unsigned char *pSocketBuf = NULL;
struct cm_msg_generic_header UCMGenericHeader = { };
struct cm_request_msg *pUCMRequestMsg = NULL;
struct cm_result *pFactResult = NULL;
uint32_t uiMsgLen = 0;
/* Setting Generic Header Values */
cm_fill_generic_header (uiMgmtEngineID, CM_COMMAND_LDSV_REQUEST,
pRoleInfo, &UCMGenericHeader);
/* Memory Allocation for Request Message */
pUCMRequestMsg = (struct cm_request_msg *) of_calloc (1, sizeof (struct cm_request_msg));
if (pUCMRequestMsg == NULL)
{
CM_LDSVWRAP_DEBUG_PRINT ("Memory Allocation for Request Message failed");
return OF_FAILURE;
}
/*Fill Request Message Structure */
cm_fill_request_message (pUCMRequestMsg, pCommand->command_id,
(unsigned char * )pCommand->dm_path_p, 0, NULL, NULL, &uiMsgLen);
/* Allocate Memory for Send Buffer */
pSocketBuf = (unsigned char *) of_calloc (1, uiMsgLen);
if (!pSocketBuf)
{
CM_LDSVWRAP_DEBUG_PRINT (" Memory allocation failed");
of_free (pUCMRequestMsg);
return OF_FAILURE;
}
/* Convert Request Message Structure into flat Buffer */
cm_frame_tnsprt_request (pUCMRequestMsg, pSocketBuf);
/*Send Message through Transport Channel */
if ((cm_tnsprt_send_message (pTransportChannel, &UCMGenericHeader,
(char *) pSocketBuf, uiMsgLen)) != OF_SUCCESS)
{
CM_LDSVWRAP_DEBUG_PRINT ("Sending through transport channel failed");
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_FAILURE;
}
/*Sending Request Message is done. So freeing it */
memset (&UCMGenericHeader, 0, sizeof (struct cm_msg_generic_header));
/*Recive response through Transport Channel */
uiMsgLen = 0;
of_free (pSocketBuf);
if ((cm_tnsprt_recv_message (pTransportChannel,
&UCMGenericHeader, &pSocketBuf,
&uiMsgLen)) == OF_FAILURE)
{
CM_LDSVWRAP_DEBUG_PRINT ("cm_tnsprt_recv_message failed");
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_FAILURE;
}
/*Memory Allocation for Result Structure */
(pFactResult) = (struct cm_result *) of_calloc (1, sizeof (struct cm_result));
if (pFactResult == NULL)
{
CM_LDSVWRAP_DEBUG_PRINT (" Memory Allocation failed for Result Structure");
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_FAILURE;
}
if ((cm_extract_ldsv_response_from_buffer (CM_CMD_FLUSH_CONFIG,
(char *) pSocketBuf, &uiMsgLen,
pFactResult)) != OF_SUCCESS)
{
CM_LDSVWRAP_DEBUG_PRINT ("Fill Response Msg struct Failed");
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_FAILURE;
}
if (pFactResult->result_code == CM_JE_FAILURE)
{
*ppResult = pFactResult;
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_FAILURE;
}
*ppResult = pFactResult;
of_free (pUCMRequestMsg);
of_free (pSocketBuf);
return OF_SUCCESS;
}
int32_t nsrm_bypassrule_getnextnrecs (struct cm_array_of_iv_pairs * keys_arr_p,
struct cm_array_of_iv_pairs *prev_record_key_p, uint32_t * count_p,
struct cm_array_of_iv_pairs ** next_n_record_data_p)
{
struct cm_array_of_iv_pairs *result_iv_pairs_p = NULL;
int32_t return_value = OF_FAILURE;
uint32_t uiRecCount = 0;
int32_t uiRequestedCount = 1, uiReturnedCnt=0;
struct nsrm_nwservice_bypass_rule_key *nsrm_bypassrule_key_info;
struct nsrm_nwservice_bypass_rule_record *nsrm_bypassrule_config_info;
struct nsrm_nwservice_bypass_rule_config_info* nsrm_bypass_config_info;
struct nsrm_nschain_object_key* nschain_object_key_p;
CM_CBK_DEBUG_PRINT ("Entered");
nschain_object_key_p = (struct nsrm_nschain_object_key *)
of_calloc(1, sizeof(struct nsrm_nschain_object_key));
nsrm_bypassrule_key_info = (struct nsrm_nwservice_bypass_rule_key*) of_calloc(1,
sizeof(struct nsrm_nwservice_bypass_rule_key));
nsrm_bypass_config_info = (struct nsrm_nwservice_bypass_rule_config_info *)
of_calloc(NSRM_MAX_BYPASS_RULE_CONFIG_PARAMETERS, sizeof(struct nsrm_nwservice_bypass_rule_config_info));
nsrm_bypassrule_config_info = (struct nsrm_nwservice_bypass_rule_record *) of_calloc(1, sizeof(struct nsrm_nwservice_bypass_rule_record));
nsrm_bypassrule_config_info->info = (struct nsrm_nwservice_bypass_rule_config_info *)of_calloc(NSRM_MAX_BYPASS_RULE_CONFIG_PARAMETERS,sizeof(struct nsrm_nwservice_bypass_rule_config_info));
nsrm_bypassrule_config_info->key.name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_bypassrule_config_info->key.tenant_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_bypassrule_config_info->key.nschain_object_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_bypassrule_config_info->info[8].value.relative_name_p = (char *) of_calloc(1,NSRM_MAX_NAME_LENGTH);
nsrm_bypassrule_ucm_setmandparams (keys_arr_p, nsrm_bypassrule_key_info,
nschain_object_key_p, nsrm_bypass_config_info);
if ((nsrm_bypassrule_ucm_setmandparams (prev_record_key_p, nsrm_bypassrule_key_info,
nschain_object_key_p, nsrm_bypass_config_info)) != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Set Mandatory Parameters Failed");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
return_value = nsrm_get_next_bypass_rules_from_nschain_object (nsrm_bypassrule_key_info,
nschain_object_key_p,
uiRequestedCount, &uiReturnedCnt,
nsrm_bypassrule_config_info);
if (return_value != OF_SUCCESS)
{
CM_CBK_DEBUG_PRINT ("Get next record failed for NSRM appl Table");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
result_iv_pairs_p = (struct cm_array_of_iv_pairs *) of_calloc (1, sizeof (struct cm_array_of_iv_pairs));
if (result_iv_pairs_p == NULL)
{
CM_CBK_DEBUG_PRINT ("Memory allocation failed for result_iv_pairs_p");
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_FAILURE;
}
nsrm_bypassrule_ucm_getparams (nsrm_bypassrule_config_info, &result_iv_pairs_p[uiRecCount]);
uiRecCount++;
*next_n_record_data_p = result_iv_pairs_p;
*count_p = uiRecCount;
of_free(nsrm_bypassrule_key_info->name_p);
of_free(nsrm_bypassrule_key_info->tenant_name_p);
of_free(nsrm_bypassrule_key_info->nschain_object_name_p);
of_free(nsrm_bypassrule_key_info);
return OF_SUCCESS;
}
