static axis2_http_header_t *
axis2_libcurl_get_first_header(
axis2_libcurl_t *curl,
const axutil_env_t * env,
const axis2_char_t * str)
{
axis2_http_header_t *tmp_header = NULL;
axis2_char_t *tmp_header_str = NULL;
axis2_char_t *tmp_name = NULL;
int i = 0;
int count = 0;
axutil_array_list_t *header_group = NULL;
AXIS2_PARAM_CHECK(env->error, curl, NULL);
AXIS2_PARAM_CHECK(env->error, str, NULL);
header_group = curl->alist;
if (!header_group)
{
return NULL;
}
if (0 == axutil_array_list_size(header_group, env))
{
return NULL;
}
count = axutil_array_list_size(header_group, env);
for (i = 0; i < count; i++)
{
tmp_header_str = (axis2_char_t *) axutil_array_list_get(header_group,
env, i);
if(!tmp_header_str)
{
continue;
}
tmp_header = (axis2_http_header_t *) axis2_http_header_create_by_str(env, tmp_header_str);
if(!tmp_header)
{
continue;
}
tmp_name = axis2_http_header_get_name(tmp_header, env);
if (0 == axutil_strcasecmp(str, tmp_name))
{
return tmp_header;
}
else
{
axis2_http_header_free( tmp_header, env );
}
}
return NULL;
}
int get_test_main()
{
remote_registry_t *remote_registry = NULL;
const axutil_env_t *env = NULL;
axis2_char_t *path = "/test/10000.txt";
remote_registry_resource_t *res = NULL;
remote_registry_resource_t *resource = NULL;
axis2_status_t status;
axis2_char_t *content = NULL;
int i = 0;
axutil_array_list_t *child_paths = NULL;
int res_len = 0;
env = axutil_env_create_all("test.log", AXIS2_LOG_LEVEL_TRACE);
remote_registry = remote_registry_create(env, "http://localhost:9762/registry", "admin", "admin");
// getting the resource
resource = remote_registry_get(remote_registry, env, path, NULL);
content = remote_registry_resource_get_content(resource, env);
printf("%s\n", content);
resource = remote_registry_get(remote_registry, env, path, NULL);
content = remote_registry_resource_get_content(resource, env);
printf("%s\n", content);
path = "/test/";
resource = remote_registry_get(remote_registry, env, path, NULL);
child_paths = remote_registry_resource_get_children(resource, env);
for(i = 0; i < axutil_array_list_size(child_paths, env); i ++)
{
axis2_char_t *child_path = axutil_array_list_get(child_paths, env, i);
printf("%d: %s\n", i, child_path);
}
resource = remote_registry_get(remote_registry, env, path, NULL);
child_paths = remote_registry_resource_get_children(resource, env);
for(i = 0; i < axutil_array_list_size(child_paths, env); i ++)
{
axis2_char_t *child_path = axutil_array_list_get(child_paths, env, i);
printf("%d: %s\n", i, child_path);
}
return 0;
}
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;
}
void
test_array_list(
const axutil_env_t * env)
{
axutil_array_list_t *al;
a *entry = NULL;
int size;
al = axutil_array_list_create(env, 1);
printf("list size %d\n", axutil_array_list_size(al, env));
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value1");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value2");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value3");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value4");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value5");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value6");
axutil_array_list_add(al, env, (void *) entry);
entry = (a *) AXIS2_MALLOC(env->allocator, sizeof(a));
entry->value = axutil_strdup(env, "value7");
axutil_array_list_set(al, env, 3, (void *) entry);
axutil_array_list_remove(al, env, 2);
entry = (a *) axutil_array_list_get(al, env, 0);
printf("entry->value:%s\n", entry->value);
entry = (a *) axutil_array_list_get(al, env, 2);
printf("entry->value:%s\n", entry->value);
size = axutil_array_list_size(al, env);
printf("list size %d\n", axutil_array_list_size(al, env));
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_svc_is_module_engaged(
axis2_svc_t * svc,
const axutil_env_t * env,
axutil_qname_t * module_qname)
{
int i = 0, size = 0;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_is_module_engaged");
size = axutil_array_list_size(svc->engaged_module_list, env);
for(i = 0; i < size; i++)
{
const axutil_qname_t *module_qname_l = NULL;
axis2_module_desc_t *module_desc_l = NULL;
module_desc_l = (axis2_module_desc_t *)axutil_array_list_get(svc->engaged_module_list, env,
i);
module_qname_l = axis2_module_desc_get_qname(module_desc_l, env);
if(axutil_qname_equals(module_qname, env, module_qname_l))
{
return AXIS2_TRUE;
}
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_is_module_engaged");
return AXIS2_FALSE;
}
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 int AXIS2_CALL
axis2_phase_get_handler_count(
const axis2_phase_t * phase,
const axutil_env_t * env)
{
return axutil_array_list_size(phase->handlers, env);
}
static axis2_status_t
axis2_phase_remove_unique(
const axutil_env_t * env,
axutil_array_list_t * list,
axis2_handler_t * handler)
{
int i = 0, size = 0;
axis2_bool_t remove_handler = AXIS2_FALSE;
const axutil_string_t *handler_name = NULL;
handler_name = axis2_handler_get_name(handler, env);
size = axutil_array_list_size(list, env);
for(i = 0; i < size; i++)
{
axis2_handler_t *obj = NULL;
const axutil_string_t *obj_name = NULL;
obj = (axis2_handler_t *)axutil_array_list_get(list, env, i);
obj_name = axis2_handler_get_name(obj, env);
if(obj == handler)
{
remove_handler = AXIS2_TRUE;
break;
}
else if(!axutil_strcmp(axutil_string_get_buffer(handler_name, env),
axutil_string_get_buffer(obj_name, env)))
{
remove_handler = AXIS2_TRUE;
break;
}
}
if(remove_handler)
axutil_array_list_remove(list, env, i);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_engine_invoke_phases(
axis2_engine_t * engine,
const axutil_env_t * env,
axutil_array_list_t * phases,
axis2_msg_ctx_t * msg_ctx)
{
int i = 0;
int count = 0;
axis2_status_t status = AXIS2_SUCCESS;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Start:axis2_engine_invoke_phases");
AXIS2_PARAM_CHECK(env->error, phases, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
if(phases)
count = axutil_array_list_size(phases, env);
for(i = 0; (i < count && !(axis2_msg_ctx_is_paused(msg_ctx, env))); i++)
{
axis2_phase_t *phase = (axis2_phase_t *)axutil_array_list_get(phases, env, i);
status = axis2_phase_invoke(phase, env, msg_ctx);
if(status != AXIS2_SUCCESS)
{
const axis2_char_t *phase_name = axis2_phase_get_name(phase, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invoking phase %s failed", phase_name);
return status;
}
}
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "End:axis2_engine_invoke_phases");
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL
axis2_ws_info_list_get_file_item(
axis2_ws_info_list_t * ws_info_list,
const axutil_env_t * env,
axis2_char_t * file_name)
{
int i = 0;
int size = 0;
AXIS2_PARAM_CHECK(env->error, file_name, NULL);
size = axutil_array_list_size(ws_info_list->ws_info_list, env);
for(i = 0; i < size; i++)
{
axis2_ws_info_t *ws_info = NULL;
axis2_char_t *file_name_l = NULL;
ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);
file_name_l = axis2_ws_info_get_file_name(ws_info, env);
if(!axutil_strcmp(file_name_l, file_name))
{
return ws_info;
}
}
return NULL;
}
axis2_status_t AXIS2_CALL
x509_token_process_alternatives(
const axutil_env_t *env,
neethi_all_t *all,
rp_x509_token_t *x509_token)
{
neethi_operator_t *operator = NULL;
axutil_array_list_t *arraylist = NULL;
neethi_assertion_t *assertion = NULL;
neethi_assertion_type_t type;
int i = 0;
arraylist = neethi_all_get_policy_components(all, env);
for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
{
operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
type = neethi_assertion_get_type(assertion, env);
if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC10)
{
rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC10);
}
else if(type == ASSERTION_TYPE_REQUIRE_DERIVED_KEYS_SC13)
{
rp_x509_token_set_derivedkey(x509_token, env, DERIVEKEY_NEEDED);
rp_x509_token_set_derivedkey_version(x509_token, env, DERIVEKEY_VERSION_SC13);
}
else if(type == ASSERTION_TYPE_REQUIRE_KEY_IDENTIFIRE_REFERENCE)
{
rp_x509_token_set_require_key_identifier_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_ISSUER_SERIAL_REFERENCE)
{
rp_x509_token_set_require_issuer_serial_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_EMBEDDED_TOKEN_REFERENCE)
{
rp_x509_token_set_require_embedded_token_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_REQUIRE_THUMBPRINT_REFERENCE)
{
rp_x509_token_set_require_thumb_print_reference(x509_token, env, AXIS2_TRUE);
}
else if(type == ASSERTION_TYPE_WSS_X509_V1_TOKEN_10)
{
rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V1_TOKEN_10);
}
else if(type == ASSERTION_TYPE_WSS_X509_V3_TOKEN_10)
{
rp_x509_token_set_token_version_and_type(x509_token, env, RP_WSS_X509_V3_TOKEN_10);
}
else
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
}
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;
}
static axis2_bool_t
axiom_soap_fault_reason_lang_exists(
axiom_soap_fault_reason_t * fault_reason,
const axutil_env_t * env,
axis2_char_t * lang)
{
int size = 0;
int i = 0;
if (!lang || (axutil_strcmp(lang, "") == 0) || !fault_reason->fault_texts)
{
return AXIS2_FALSE;
}
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)
{
axis2_char_t *text_lang = NULL;
fault_text = (axiom_soap_fault_text_t *) value;
text_lang = axiom_soap_fault_text_get_lang(fault_text, env);
if (text_lang && (axutil_strcmp(lang, text_lang) == 0))
{
return AXIS2_TRUE;
}
}
}
return AXIS2_FALSE;
}
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;
}
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 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_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 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;
}
/**
* setter for portFolioItem
*/
axis2_status_t AXIS2_CALL
axis2_PortFolio_set_portFolioItem(
axis2_PortFolio_t* PortFolio,
const axutil_env_t *env,
axutil_array_list_t* param_portFolioItem)
{
int size = 0;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(!PortFolio)
{
return AXIS2_FAILURE;
}
size = axutil_array_list_size( param_portFolioItem, env);
if ( size < 0 )
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "portFolioItem has less than minOccurs(0)"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
return AXIS2_FAILURE;
}
PortFolio-> attrib_portFolioItem = param_portFolioItem;
return AXIS2_SUCCESS;
}
static uri_prefix_element_t *
axis2_libxml2_writer_wrapper_find_prefix_in_context(
axutil_array_list_t * context,
const axutil_env_t * env,
axis2_char_t * uri)
{
int size = 0;
int i = 0;
if(!context)
{
return NULL;
}
size = axutil_array_list_size(context, env);
for(i = 0; i < size; i++)
{
uri_prefix_element_t *ele = NULL;
void *value = NULL;
value = axutil_array_list_get(context, env, i);
if(value)
{
ele = (uri_prefix_element_t *)value;
if(ele->uri && axutil_strcmp(uri, ele->uri))
{
return ele;
}
}
}
return NULL;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
neethi_exactlyone_add_policy_components(
neethi_exactlyone_t *exactlyone,
axutil_array_list_t *arraylist,
const axutil_env_t *env)
{
int size = axutil_array_list_size(arraylist, env);
int i = 0;
if(axutil_array_list_ensure_capacity(exactlyone->policy_components, env, size + 1)
!= AXIS2_SUCCESS)
{
return AXIS2_FAILURE;
}
for(i = 0; i < size; i++)
{
void *value = NULL;
value = axutil_array_list_get(arraylist, env, i);
neethi_operator_increment_ref((neethi_operator_t *)value, env);
axutil_array_list_add(exactlyone->policy_components, env, value);
}
return AXIS2_SUCCESS;
}
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 axiom_soap_fault_text_t *AXIS2_CALL
axiom_soap_fault_reason_get_soap_fault_text(
axiom_soap_fault_reason_t * fault_reason,
const axutil_env_t * env,
axis2_char_t * lang)
{
int status = AXIS2_SUCCESS;
int size = 0;
int i = 0;
AXIS2_PARAM_CHECK(env->error, fault_reason, NULL);
if (!lang || (axutil_strcmp(lang, "") == 0))
{
return NULL;
}
/** Here we have to build the soap fault reason element completly */
if (!fault_reason->fault_texts)
{
if (fault_reason->soap_builder &&
!(axiom_node_is_complete(fault_reason->om_ele_node, env)))
{
while (!(axiom_node_is_complete(fault_reason->om_ele_node, env)))
{
status =
axiom_soap_builder_next(fault_reason->soap_builder, env);
if (status == AXIS2_FAILURE)
{
return NULL;
}
}
}
}
if (!fault_reason->fault_texts)
{
return NULL;
}
/** iterate the array list */
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)
{
axis2_char_t *fault_lang = NULL;
fault_text = (axiom_soap_fault_text_t *) value;
fault_lang = axiom_soap_fault_text_get_lang(fault_text, env);
if (fault_lang && axutil_strcmp(lang, fault_lang) == 0)
{
return fault_text;
}
}
}
return NULL;
}
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;
}
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;
}
/**
* setter for return
*/
axis2_status_t AXIS2_CALL
adb_listExternalUsersResponse_set_return(
adb_listExternalUsersResponse_t* _listExternalUsersResponse,
const axutil_env_t *env,
axutil_array_list_t* arg_return)
{
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, AXIS2_FAILURE);
if(_listExternalUsersResponse->is_valid_return &&
arg_return == _listExternalUsersResponse->property_return)
{
return AXIS2_SUCCESS;
}
size = axutil_array_list_size(arg_return, env);
if (size < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "return has less than minOccurs(0)");
return AXIS2_FAILURE;
}
for(i = 0; i < size; i ++ )
{
if(NULL != axutil_array_list_get(arg_return, env, i))
{
non_nil_exists = AXIS2_TRUE;
break;
}
}
adb_listExternalUsersResponse_reset_return(_listExternalUsersResponse, env);
if(NULL == arg_return)
{
/* We are already done */
return AXIS2_SUCCESS;
}
_listExternalUsersResponse->property_return = arg_return;
if(non_nil_exists)
{
_listExternalUsersResponse->is_valid_return = AXIS2_TRUE;
}
return AXIS2_SUCCESS;
}
/**
* setter for extraElement
*/
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_set_extraElement(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
const axutil_env_t *env,
axutil_array_list_t* arg_extraElement)
{
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE);
if(_CanonicalizationMethodType->is_valid_extraElement &&
arg_extraElement == _CanonicalizationMethodType->property_extraElement)
{
return AXIS2_SUCCESS;
}
size = axutil_array_list_size(arg_extraElement, env);
if (size < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "extraElement has less than minOccurs(0)");
return AXIS2_FAILURE;
}
for(i = 0; i < size; i ++ )
{
if(NULL != axutil_array_list_get(arg_extraElement, env, i))
{
non_nil_exists = AXIS2_TRUE;
break;
}
}
adb_CanonicalizationMethodType_reset_extraElement(_CanonicalizationMethodType, env);
if(NULL == arg_extraElement)
{
/* We are already done */
return AXIS2_SUCCESS;
}
_CanonicalizationMethodType->property_extraElement = arg_extraElement;
if(non_nil_exists)
{
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_TRUE;
}
return AXIS2_SUCCESS;
}
/**
* setter for controlOperations
*/
axis2_status_t AXIS2_CALL
adb_OperationMetaDataWrapper_set_controlOperations(
adb_OperationMetaDataWrapper_t* _OperationMetaDataWrapper,
const axutil_env_t *env,
axutil_array_list_t* arg_controlOperations)
{
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _OperationMetaDataWrapper, AXIS2_FAILURE);
if(_OperationMetaDataWrapper->is_valid_controlOperations &&
arg_controlOperations == _OperationMetaDataWrapper->property_controlOperations)
{
return AXIS2_SUCCESS;
}
size = axutil_array_list_size(arg_controlOperations, env);
if (size < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "controlOperations has less than minOccurs(0)");
return AXIS2_FAILURE;
}
for(i = 0; i < size; i ++ )
{
if(NULL != axutil_array_list_get(arg_controlOperations, env, i))
{
non_nil_exists = AXIS2_TRUE;
break;
}
}
adb_OperationMetaDataWrapper_reset_controlOperations(_OperationMetaDataWrapper, env);
if(NULL == arg_controlOperations)
{
/* We are already done */
return AXIS2_SUCCESS;
}
_OperationMetaDataWrapper->property_controlOperations = arg_controlOperations;
if(non_nil_exists)
{
_OperationMetaDataWrapper->is_valid_controlOperations = AXIS2_TRUE;
}
return AXIS2_SUCCESS;
}
/**
* setter for contentFormat
*/
axis2_status_t AXIS2_CALL
adb_supportedContentFormats_type0_set_contentFormat(
adb_supportedContentFormats_type0_t* _supportedContentFormats_type0,
const axutil_env_t *env,
axutil_array_list_t* arg_contentFormat)
{
int size = 0;
int i = 0;
axis2_bool_t non_nil_exists = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _supportedContentFormats_type0, AXIS2_FAILURE);
if(_supportedContentFormats_type0->is_valid_contentFormat &&
arg_contentFormat == _supportedContentFormats_type0->property_contentFormat)
{
return AXIS2_SUCCESS;
}
size = axutil_array_list_size(arg_contentFormat, env);
if (size < 0)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "contentFormat has less than minOccurs(0)");
return AXIS2_FAILURE;
}
for(i = 0; i < size; i ++ )
{
if(NULL != axutil_array_list_get(arg_contentFormat, env, i))
{
non_nil_exists = AXIS2_TRUE;
break;
}
}
adb_supportedContentFormats_type0_reset_contentFormat(_supportedContentFormats_type0, env);
if(NULL == arg_contentFormat)
{
/* We are already done */
return AXIS2_SUCCESS;
}
_supportedContentFormats_type0->property_contentFormat = arg_contentFormat;
if(non_nil_exists)
{
_supportedContentFormats_type0->is_valid_contentFormat = AXIS2_TRUE;
}
return AXIS2_SUCCESS;
}
axis2_char_t *
wsf_util_get_http_headers_from_op_client (
axis2_op_client_t * op_client,
axutil_env_t * env,
axis2_wsdl_msg_labels_t msg_label)
{
if (op_client) {
const axis2_msg_ctx_t *msg_ctx = NULL;
axutil_property_t *client_property = NULL;
axis2_http_client_t *client = NULL;
axis2_http_simple_response_t *response = NULL;
axutil_array_list_t *list = NULL;
axis2_http_header_t *header = NULL;
int i;
char *header_buf = NULL;
msg_ctx = axis2_op_client_get_msg_ctx (op_client, env, msg_label);
if (!msg_ctx)
return NULL;
client_property =
(axutil_property_t *) axis2_msg_ctx_get_property (msg_ctx, env,
AXIS2_HTTP_CLIENT);
if (client_property)
client =
(axis2_http_client_t *)
axutil_property_get_value (client_property, env);
else
return NULL;
if (client && (msg_label == AXIS2_WSDL_MESSAGE_LABEL_OUT)) {
response = axis2_http_client_get_response (client, env);
if (response)
list = axis2_http_simple_response_get_headers (response, env);
else
return NULL;
}
if (list) {
header_buf = malloc (500);
if (!axutil_array_list_is_empty (list, env)) {
for (i = 0; i < axutil_array_list_size (list, env); i++) {
header =
(axis2_http_header_t *) axutil_array_list_get (list,
env, i);
strcat (header_buf,
axis2_http_header_to_external_form (header, env));
}
return header_buf;
}
}
}
return NULL;
}
