axis2_char_t* AXIS2_CALL sandesha2_rm_elements_get_addr_ns_val_from_env( const axutil_env_t *env, axiom_soap_envelope_t *soap_envelope, axis2_char_t *action) { axiom_soap_header_t *soap_header = NULL; AXIS2_PARAM_CHECK(env->error, soap_envelope, NULL); AXIS2_PARAM_CHECK(env->error, action, NULL); soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if(soap_header) { axutil_array_list_t *headers = NULL; axiom_node_t *soap_header_node = NULL; axiom_element_t *soap_header_element = NULL; axiom_namespace_t *addr_ns = NULL; headers = axiom_soap_header_get_header_blocks_with_namespace_uri( soap_header, env, AXIS2_WSA_NAMESPACE); if(headers && 0 < axutil_array_list_size(headers, env)) { axutil_array_list_free(headers, env); return AXIS2_WSA_NAMESPACE; } headers = axiom_soap_header_get_header_blocks_with_namespace_uri( soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION); if(headers && 0 < axutil_array_list_size(headers, env)) { axutil_array_list_free(headers, env); return AXIS2_WSA_NAMESPACE_SUBMISSION; } if(headers) axutil_array_list_free(headers, env); soap_header_node = axiom_soap_header_get_base_node(soap_header, env); soap_header_element = axiom_node_get_data_element(soap_header_node, env); addr_ns = axiom_element_get_namespace(soap_header_element, env, soap_header_node); if(addr_ns) { axis2_char_t *str_addr_ns = axiom_namespace_get_uri(addr_ns, env); return str_addr_ns; } } return NULL; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL sandesha2_seq_report_set_completed_msgs( sandesha2_seq_report_t *report, const axutil_env_t *env, axutil_array_list_t *completed_msgs) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(report->completed_msgs) { int i = 0, size = 0; size = axutil_array_list_size(report->completed_msgs, env); for(i = 0; i < size; i++) { long *msg_no = NULL; msg_no = axutil_array_list_get(report->completed_msgs, env, i); AXIS2_FREE(env->allocator, msg_no); } axutil_array_list_free(report->completed_msgs, env); report->completed_msgs = NULL; } report->completed_msgs = completed_msgs; return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL axiom_soap_fault_reason_free( axiom_soap_fault_reason_t * fault_reason, const axutil_env_t * env) { if (fault_reason->fault_texts) { int size = 0; int i = 0; size = axutil_array_list_size(fault_reason->fault_texts, env); for (i = 0; i < size; i++) { axiom_soap_fault_text_t *fault_text = NULL; void *value = NULL; value = axutil_array_list_get(fault_reason->fault_texts, env, i); if (value) { fault_text = (axiom_soap_fault_text_t *) value; axiom_soap_fault_text_free(fault_text, env); fault_text = NULL; } } axutil_array_list_free(fault_reason->fault_texts, env); fault_reason->fault_texts = NULL; } AXIS2_FREE(env->allocator, fault_reason); fault_reason = NULL; return; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL sandesha2_seq_report_free( void *seq_report, const axutil_env_t *env) { sandesha2_seq_report_t *report = (sandesha2_seq_report_t *)seq_report; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(report->completed_msgs) { axutil_array_list_free(report->completed_msgs, env); report->completed_msgs = NULL; } if(report->seq_id) { AXIS2_FREE(env->allocator, report->seq_id); report->seq_id = NULL; } if(report) { AXIS2_FREE(env->allocator, report); report = NULL; } return AXIS2_SUCCESS; }
/* free svc info struct */ void wsf_svc_info_free ( wsf_svc_info_t * svc_info, axutil_env_t * env) { if (NULL != svc_info) { if (svc_info->svc_name) { AXIS2_FREE (env->allocator, svc_info->svc_name); svc_info->svc_name = NULL; } if (svc_info->ops_to_functions) { axutil_hash_free (svc_info->ops_to_functions, env); } if (svc_info->ops_to_actions) { axutil_hash_free (svc_info->ops_to_actions, env); } if (svc_info->modules_to_engage) { axutil_array_list_free (svc_info->modules_to_engage, env); } if (svc_info->class_to_args) { axutil_hash_free (svc_info->class_to_args, env); } if (svc_info->op_name != NULL) { AXIS2_FREE (env->allocator, svc_info->op_name); } AXIS2_FREE (env->allocator, svc_info); } }
AXIS2_EXTERN void AXIS2_CALL rp_signed_encrypted_items_free( rp_signed_encrypted_items_t * signed_encrypted_items, const axutil_env_t * env) { AXIS2_ENV_CHECK_VOID(env); if(signed_encrypted_items) { if(signed_encrypted_items->elements) { int i = 0; for(i = 0; i < axutil_array_list_size(signed_encrypted_items->elements, env); i++) { rp_element_t *element = NULL; element = (rp_element_t *)axutil_array_list_get(signed_encrypted_items->elements, env, i); if(element) rp_element_free(element, env); element = NULL; } axutil_array_list_free(signed_encrypted_items->elements, env); signed_encrypted_items->elements = NULL; } AXIS2_FREE(env->allocator, signed_encrypted_items); signed_encrypted_items = NULL; } return; }
AXIS2_EXTERN void AXIS2_CALL neethi_exactlyone_free( neethi_exactlyone_t *neethi_exactlyone, const axutil_env_t *env) { if(neethi_exactlyone) { if(neethi_exactlyone->policy_components) { int i = 0; int size = 0; size = axutil_array_list_size(neethi_exactlyone->policy_components, env); for(i = 0; i < size; i++) { neethi_operator_t *operator = NULL; operator = (neethi_operator_t *)axutil_array_list_get( neethi_exactlyone->policy_components, env, i); if(operator) { neethi_operator_free(operator, env); operator = NULL; } } axutil_array_list_free(neethi_exactlyone->policy_components, env); neethi_exactlyone->policy_components = NULL; } AXIS2_FREE(env->allocator, neethi_exactlyone); neethi_exactlyone = NULL; } return; }
AXIS2_EXTERN void AXIS2_CALL rp_signed_encrypted_parts_free( rp_signed_encrypted_parts_t * signed_encrypted_parts, const axutil_env_t * env) { if(signed_encrypted_parts) { if(--(signed_encrypted_parts->ref) > 0) { return; } if(signed_encrypted_parts->headers) { int i = 0; for(i = 0; i < axutil_array_list_size(signed_encrypted_parts->headers, env); i++) { rp_header_t *header = NULL; header = (rp_header_t *)axutil_array_list_get(signed_encrypted_parts->headers, env, i); if(header) { rp_header_free(header, env); } } axutil_array_list_free(signed_encrypted_parts->headers, env); signed_encrypted_parts->headers = NULL; } AXIS2_FREE(env->allocator, signed_encrypted_parts); signed_encrypted_parts = NULL; } }
AXIS2_EXTERN void AXIS2_CALL saml_autho_decision_query_free(saml_autho_decision_query_t* autho_decision_query, const axutil_env_t *env) { int size = 0, i = 0; saml_action_t *action = NULL; if(autho_decision_query->evidence) { saml_evidence_free(autho_decision_query->evidence, env); } if(autho_decision_query->resource) { AXIS2_FREE(env->allocator, autho_decision_query->resource); } if(autho_decision_query->subject) { saml_subject_free(autho_decision_query->subject, env); } if(autho_decision_query->saml_actions) { size = axutil_array_list_size(autho_decision_query->saml_actions, env); for(i = 0; i < size ; i++) { action = (saml_action_t *)axutil_array_list_get(autho_decision_query->saml_actions, env, i); if(action) saml_action_free(action, env); } axutil_array_list_free(autho_decision_query->saml_actions, env); } AXIS2_FREE(env->allocator, autho_decision_query); autho_decision_query = NULL; }
AXIS2_EXTERN void AXIS2_CALL saml_attr_query_free(saml_attr_query_t *attr_query, const axutil_env_t *env) { int size = 0, i = 0; saml_attr_desig_t *attr_desig = NULL; if(attr_query->resource) { AXIS2_FREE(env->allocator, attr_query->resource); } if(attr_query->subject) { saml_subject_free(attr_query->subject, env); } if(attr_query->attr_desigs) { size = axutil_array_list_size(attr_query->attr_desigs, env); for(i = 0; i < size; i++) { attr_desig = (saml_attr_desig_t*) axutil_array_list_get(attr_query->attr_desigs, env, i); if(attr_desig) saml_attr_desig_free(attr_desig, env); } axutil_array_list_free(attr_query->attr_desigs, env); } AXIS2_FREE(env->allocator, attr_query); attr_query = NULL; }
axis2_status_t AXIS2_CALL axutil_param_set_value_list( axutil_param_t *param, const axutil_env_t *env, axutil_array_list_t *value_list) { AXIS2_PARAM_CHECK(env->error, value_list, AXIS2_FAILURE); if(param->value_list) { int i = 0, size = 0; size = axutil_array_list_size(param->value_list, env); for(i = 0; i < size; i++) { axutil_param_t *param = NULL; param = (axutil_param_t *)axutil_array_list_get(param->value_list, env, i); axutil_param_free(param, env); } axutil_array_list_free(param->value_list, env); } param->value_list = value_list; return AXIS2_SUCCESS; }
void AXIS2_CALL axis2_libcurl_free( axis2_libcurl_t *curl, const axutil_env_t * env) { if (!curl) { return; } if (curl->handler) { curl_easy_cleanup (curl->handler); } if (curl->alist) { axis2_libcurl_free_headers(curl, env); axutil_array_list_free(curl->alist, env); curl->alist = NULL; } if (curl->memory) { AXIS2_FREE(env->allocator, curl->memory); } AXIS2_FREE(env->allocator, curl); }
AXIS2_EXTERN void AXIS2_CALL axis2_arch_file_data_free( axis2_arch_file_data_t * arch_file_data, const axutil_env_t * env) { if (arch_file_data->file) { axutil_file_free(arch_file_data->file, env); } if (arch_file_data->msg_recv) { AXIS2_FREE(env->allocator, arch_file_data->msg_recv); } if (arch_file_data->module_name) { AXIS2_FREE(env->allocator, arch_file_data->module_name); } if (arch_file_data->module_dll_name) { AXIS2_FREE(env->allocator, arch_file_data->module_dll_name); } if (arch_file_data->name) { AXIS2_FREE(env->allocator, arch_file_data->name); } if (arch_file_data->svc_map) { axutil_hash_index_t *hi = NULL; void *val = NULL; for (hi = axutil_hash_first(arch_file_data->svc_map, env); hi; hi = axutil_hash_next(env, hi)) { axis2_svc_t *svc = NULL; axutil_hash_this(hi, NULL, NULL, &val); svc = (axis2_svc_t *) val; if (svc) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name :%s", axis2_svc_get_name(svc, env)); axis2_svc_free(svc, env); } } axutil_hash_free(arch_file_data->svc_map, env); } if (arch_file_data->deployable_svcs) { axutil_array_list_free(arch_file_data->deployable_svcs, env); } if (arch_file_data) { AXIS2_FREE(env->allocator, arch_file_data); } return; }
sandesha2_invoker_bean_t *AXIS2_CALL sandesha2_permanent_invoker_mgr_find_unique( sandesha2_invoker_mgr_t *invoker_mgr, const axutil_env_t *env, sandesha2_invoker_bean_t *bean) { int i = 0; int size = 0; int match_list_size = 0; sandesha2_invoker_bean_t *result = NULL; axutil_array_list_t *match_list = axutil_array_list_create(env, 0); axutil_array_list_t *find_list = NULL; axis2_char_t *sql_find = NULL; sandesha2_permanent_invoker_mgr_t *invoker_mgr_impl = NULL; AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE); invoker_mgr_impl = SANDESHA2_INTF_TO_IMPL(invoker_mgr); sql_find = "select msg_ctx_ref_key,msg_no,seq_id,is_invoked from invoker;"; find_list = sandesha2_permanent_bean_mgr_find(invoker_mgr_impl->bean_mgr, env, sandesha2_invoker_find_callback, sql_find); if(find_list) size = axutil_array_list_size(find_list, env); for(i = 0; i < size; i++) { sandesha2_invoker_bean_t *candidate = NULL; candidate = (sandesha2_invoker_bean_t *) axutil_array_list_get(find_list, env, i); if(sandesha2_permanent_invoker_mgr_match(invoker_mgr, env, bean, candidate)) { match_list_size++; axutil_array_list_add(match_list, env, candidate); } else { sandesha2_invoker_bean_free(candidate, env); } } if(find_list) axutil_array_list_free(find_list, env); if(match_list_size == 1) result = (sandesha2_invoker_bean_t *) axutil_array_list_get( match_list, env, 0); if(match_list) axutil_array_list_free(match_list, env); return result; }
AXIS2_EXTERN void AXIS2_CALL axis2_ws_info_list_free( axis2_ws_info_list_t * ws_info_list, const axutil_env_t * env) { if(ws_info_list->current_info_list) { int list_size = 0; int i = 0; list_size = axutil_array_list_size(ws_info_list->current_info_list, env); for(i = 0; i < list_size; i++) { axis2_char_t *file_name = NULL; file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list->current_info_list, env, i); AXIS2_FREE(env->allocator, file_name); } axutil_array_list_free(ws_info_list->current_info_list, env); } if(ws_info_list->ws_info_list) { int list_size = 0; int i = 0; list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); for(i = 0; i < list_size; i++) { axis2_ws_info_t *ws_info = NULL; ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); axis2_ws_info_free(ws_info, env); } axutil_array_list_free(ws_info_list->ws_info_list, env); } if(ws_info_list) { AXIS2_FREE(env->allocator, ws_info_list); } return; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL sandesha2_report_free( void *rep, const axutil_env_t *env) { sandesha2_report_t *report = (sandesha2_report_t *) rep; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(report->incoming_seq_list) { axutil_array_list_free(report->incoming_seq_list, env); report->incoming_seq_list = NULL; } if(report->outgoing_seq_list) { axutil_array_list_free(report->outgoing_seq_list, env); report->outgoing_seq_list = NULL; } if(report->seq_status_map) { axutil_hash_free(report->seq_status_map, env); report->seq_status_map = NULL; } if(report->no_of_completed_msgs_map) { axutil_hash_free(report->no_of_completed_msgs_map, env); report->no_of_completed_msgs_map = NULL; } if(report->outgoing_internal_seq_id_map) { axutil_hash_free(report->outgoing_internal_seq_id_map, env); report->outgoing_internal_seq_id_map = NULL; } if(report) { AXIS2_FREE(env->allocator, report); report = NULL; } return AXIS2_SUCCESS; }
void AXIS2_CALL axutil_param_free( axutil_param_t *param, const axutil_env_t *env) { void *param_value = NULL; axis2_char_t *param_name = NULL; param_value = axutil_param_get_value(param, env); if(param_value) { if(param && param->value_free) { param->value_free(param_value, env); } else /* we assume that param value is axis2_char_t* */ { AXIS2_FREE(env->allocator, param_value); } } if(param->attrs) { axutil_hash_index_t *i = NULL; void *v = NULL; for(i = axutil_hash_first(param->attrs, env); i; i = axutil_hash_next(env, i)) { axutil_hash_this(i, NULL, NULL, &v); axutil_generic_obj_free(v, env); } axutil_hash_free(param->attrs, env); } if(param->value_list) { int i = 0, size = 0; size = axutil_array_list_size(param->value_list, env); for(i = 0; i < size; i++) { axutil_param_t *param_l = NULL; param_l = (axutil_param_t *)axutil_array_list_get(param->value_list, env, i); if(param_l) { axutil_param_free(param_l, env); } } axutil_array_list_free(param->value_list, env); } param_name = axutil_param_get_name(param, env); AXIS2_FREE(env->allocator, param_name); AXIS2_FREE(env->allocator, param); return; }
AXIS2_EXTERN int AXIS2_CALL saml_attr_query_set_designators(saml_attr_query_t *attr_query, const axutil_env_t *env, axutil_array_list_t *attr_desigs) { if(attr_query->attr_desigs) { axutil_array_list_free(attr_query->attr_desigs, env); } attr_query->attr_desigs = attr_desigs; return AXIS2_SUCCESS; }
AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_set_actions(saml_autho_decision_query_t *autho_dec_query, const axutil_env_t *env, axutil_array_list_t *actions) { if(autho_dec_query->saml_actions) { axutil_array_list_free(autho_dec_query->saml_actions, env); } autho_dec_query->saml_actions = actions; return AXIS2_SUCCESS; }
void AXIS2_CALL axis2_endpoint_ref_free( axis2_endpoint_ref_t * endpoint_ref, const axutil_env_t * env) { AXIS2_ENV_CHECK(env, void); if (endpoint_ref->address) { AXIS2_FREE(env->allocator, endpoint_ref->address); } if (endpoint_ref->ref_param_list) { axutil_array_list_free(endpoint_ref->ref_param_list, env); } if (endpoint_ref->metadata_list) { axutil_array_list_free(endpoint_ref->metadata_list, env); } if (endpoint_ref->ref_attribute_list) { axutil_array_list_free(endpoint_ref->ref_attribute_list, env); } if (endpoint_ref->meta_attribute_list) { axutil_array_list_free(endpoint_ref->meta_attribute_list, env); } if (endpoint_ref->extension_list) { axutil_array_list_free(endpoint_ref->extension_list, env); } AXIS2_FREE(env->allocator, endpoint_ref); return; }
axutil_array_list_t *AXIS2_CALL sandesha2_permanent_invoker_mgr_find( sandesha2_invoker_mgr_t *invoker_mgr, const axutil_env_t *env, sandesha2_invoker_bean_t *bean) { int i = 0; int size = 0; int match_list_size = 0; axutil_array_list_t *match_list = NULL; axutil_array_list_t *find_list = NULL; axis2_char_t *sql_find = NULL; axutil_array_list_t *ret = NULL; sandesha2_permanent_invoker_mgr_t *invoker_mgr_impl = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_permanent_invoker_mgr_find"); invoker_mgr_impl = SANDESHA2_INTF_TO_IMPL(invoker_mgr); sql_find = "select msg_ctx_ref_key,msg_no, seq_id,is_invoked from invoker;"; find_list = sandesha2_permanent_bean_mgr_find(invoker_mgr_impl->bean_mgr, env, sandesha2_invoker_find_callback, sql_find); if(find_list) size = axutil_array_list_size(find_list, env); if(!bean) return find_list; match_list = axutil_array_list_create(env, 0); for(i = 0; i < size; i++) { sandesha2_invoker_bean_t *candidate = NULL; candidate = (sandesha2_invoker_bean_t *) axutil_array_list_get(find_list, env, i); if(sandesha2_permanent_invoker_mgr_match(invoker_mgr, env, bean, candidate)) { match_list_size++; axutil_array_list_add(match_list, env, candidate); } else { sandesha2_invoker_bean_free(candidate, env); } } if(find_list) axutil_array_list_free(find_list, env); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_permanent_invoker_mgr_find"); return ret; }
AXIS2_EXTERN void AXIS2_CALL axiom_soap_header_free( axiom_soap_header_t * soap_header, const axutil_env_t * env) { if(soap_header->header_blocks) { axutil_hash_index_t *hi = NULL; void *val = NULL; for(hi = axutil_hash_first(soap_header->header_blocks, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); if(val) { axiom_soap_header_block_free((axiom_soap_header_block_t *)val, env); val = NULL; } } axutil_hash_free(soap_header->header_blocks, env); } if(soap_header->header_block_keys) { int size = 0; void *val = NULL; int i = 0; size = axutil_array_list_size(soap_header->header_block_keys, env); for(i = 0; i < size; i++) { val = axutil_array_list_get(soap_header->header_block_keys, env, i); if(val) { AXIS2_FREE(env->allocator, (char *)val); val = NULL; } } axutil_array_list_free(soap_header->header_block_keys, env); soap_header->header_block_keys = NULL; } AXIS2_FREE(env->allocator, soap_header); soap_header = NULL; return; }
AXIS2_EXTERN void AXIS2_CALL axiom_soap12_builder_helper_free( axiom_soap12_builder_helper_t * builder_helper, const axutil_env_t * env) { AXIS2_ENV_CHECK(env, void); if (builder_helper->detail_element_names) { axutil_array_list_free(builder_helper->detail_element_names, env); builder_helper->detail_element_names = NULL; } AXIS2_FREE(env->allocator, builder_helper); builder_helper = NULL; return; }
AXIS2_EXTERN void AXIS2_CALL axis2_msg_info_headers_free( struct axis2_msg_info_headers *msg_info_headers, const axutil_env_t * env) { if(msg_info_headers->to) { axis2_endpoint_ref_free(msg_info_headers->to, env); } if(msg_info_headers->from) { axis2_endpoint_ref_free(msg_info_headers->from, env); } if(msg_info_headers->reply_to) { axis2_endpoint_ref_free(msg_info_headers->reply_to, env); } if(msg_info_headers->relates_to) { axis2_relates_to_free(msg_info_headers->relates_to, env); } if(msg_info_headers->fault_to) { axis2_endpoint_ref_free(msg_info_headers->fault_to, env); } if(msg_info_headers->ref_params) { axutil_array_list_free(msg_info_headers->ref_params, env); } if(msg_info_headers->action) { AXIS2_FREE(env->allocator, msg_info_headers->action); } if(msg_info_headers->message_id) { AXIS2_FREE(env->allocator, msg_info_headers->message_id); } AXIS2_FREE(env->allocator, msg_info_headers); return; }
/* Free the resources used */ int AXIS2_CALL savan_subs_mgr_svc_free( axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env) { /* Free the function array */ if(svc_skeleton->func_array) { axutil_array_list_free(svc_skeleton->func_array, env); } /* Free the service skeleton */ if(svc_skeleton) { AXIS2_FREE(env->allocator, svc_skeleton); } return AXIS2_SUCCESS; }
axis2_status_t AXIS2_CALL axis2_PortFolio_free ( axis2_PortFolio_t* PortFolio, const axutil_env_t *env) { int i = 0; int count = 0; void *element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if ( PortFolio->attrib_portFolioItem != NULL) { count = axutil_array_list_size( PortFolio->attrib_portFolioItem, env); for( i = 0; i < count; i ++) { element = axutil_array_list_get( PortFolio->attrib_portFolioItem, env, i); if( element != NULL) { axis2_PortFolioItem_free( (axis2_PortFolioItem_t*)element, env); element = NULL; } } axutil_array_list_free( PortFolio->attrib_portFolioItem, env); } if(PortFolio) { AXIS2_FREE( env->allocator, PortFolio); PortFolio = NULL; } return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL axiom_output_free( axiom_output_t * om_output, const axutil_env_t * env) { AXIS2_ENV_CHECK_VOID(env); if(om_output->xml_version) { AXIS2_FREE(env->allocator, om_output->xml_version); } if(om_output->mime_boundary) { AXIS2_FREE(env->allocator, om_output->mime_boundary); } if(om_output->next_content_id) { AXIS2_FREE(env->allocator, om_output->next_content_id); } if(om_output->root_content_id) { AXIS2_FREE(env->allocator, om_output->root_content_id); } if(om_output->xml_writer) { axiom_xml_writer_free(om_output->xml_writer, env); } if(om_output->binary_node_list) { axutil_array_list_free(om_output->binary_node_list, env); } if(om_output->content_type) { AXIS2_FREE(env->allocator, om_output->content_type); } AXIS2_FREE(env->allocator, om_output); return; }
int AXIS2_CALL axis2_svc_skel_TraderExchange_free(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env) { /* Free the function array */ if (svc_skeleton->func_array) { axutil_array_list_free(svc_skeleton->func_array, env); svc_skeleton->func_array = NULL; } /* Free the service skeleton */ if (svc_skeleton) { AXIS2_FREE(env->allocator, svc_skeleton); svc_skeleton = NULL; } return AXIS2_SUCCESS; }
/** * resetter for return */ axis2_status_t AXIS2_CALL adb_listExternalUsersResponse_reset_return( adb_listExternalUsersResponse_t* _listExternalUsersResponse, const axutil_env_t *env) { int i = 0; int count = 0; void *element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, AXIS2_FAILURE); if (_listExternalUsersResponse->property_return != NULL) { count = axutil_array_list_size(_listExternalUsersResponse->property_return, env); for(i = 0; i < count; i ++) { element = axutil_array_list_get(_listExternalUsersResponse->property_return, env, i); if(element != NULL) { AXIS2_FREE(env-> allocator, (axis2_char_t*)element); element = NULL; } } axutil_array_list_free(_listExternalUsersResponse->property_return, env); } _listExternalUsersResponse->is_valid_return = AXIS2_FALSE; return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL neethi_assertion_free( neethi_assertion_t *neethi_assertion, const axutil_env_t *env) { if(neethi_assertion) { if(neethi_assertion->policy_components) { int i = 0; for(i = 0; i < axutil_array_list_size(neethi_assertion->policy_components, env); i++) { neethi_operator_t *operator = NULL; operator = (neethi_operator_t *)axutil_array_list_get( neethi_assertion->policy_components, env, i); if(operator) neethi_operator_free(operator, env); operator = NULL; } axutil_array_list_free(neethi_assertion->policy_components, env); neethi_assertion->policy_components = NULL; } if(neethi_assertion->value) { if(neethi_assertion->free_func) { neethi_assertion->free_func(neethi_assertion->value, env); } } if(neethi_assertion->node) { axiom_node_free_tree(neethi_assertion->node, env); neethi_assertion->node = NULL; } AXIS2_FREE(env->allocator, neethi_assertion); neethi_assertion = NULL; } return; }