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;
}
