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