/**
* auto generated function definition signature
* for "getSecurityConfigData|http://service.config.security.carbon.wso2.org" operation.
* @param env environment ( mandatory)* @param MessageContext the outmessage context
* @param _getSecurityConfigData of the adb_getSecurityConfigData_t*
*
* @return adb_getSecurityConfigDataResponse_t*
*/
adb_getSecurityConfigDataResponse_t* axis2_skel_SecurityAdminService_getSecurityConfigData(const axutil_env_t *env , axis2_msg_ctx_t *msg_ctx,
adb_getSecurityConfigData_t* _getSecurityConfigData,
axis2_skel_SecurityAdminService_getSecurityConfigData_fault *fault )
{
adb_getSecurityConfigDataResponse_t* response = NULL;
adb_SecurityConfigData_t* data = NULL;
axutil_array_list_t* key_stores = NULL;
axutil_array_list_t* user_groups = NULL;
/* Create data */
key_stores = axutil_array_list_create(env, 1);
axutil_array_list_add(key_stores, env, axutil_string_get_buffer(
axutil_string_create(env, "test"), env));
user_groups = axutil_array_list_create(env, 1);
axutil_array_list_add(user_groups, env, axutil_string_get_buffer(
axutil_string_create(env, "admin"), env));
axutil_array_list_add(user_groups, env, axutil_string_get_buffer(
axutil_string_create(env, "everyone"), env));
data = adb_SecurityConfigData_create(env);
adb_SecurityConfigData_set_privateStore(data, env, "test");
adb_SecurityConfigData_set_trustedKeyStores(data, env, key_stores);
adb_SecurityConfigData_set_userGroups(data, env, user_groups);
/* Create response */
response = adb_getSecurityConfigDataResponse_create(env);
adb_getSecurityConfigDataResponse_set_return(response, env, data);
return response;
}
/**
* auto generated function definition signature
* for "getSystemPermissionOfUser|http://authentication.services.core.carbon.wso2.org" operation.
* @param env environment ( mandatory)* @param MessageContext the outmessage context
* @param _getSystemPermissionOfUser of the adb_getSystemPermissionOfUser_t*
*
* @return adb_getSystemPermissionOfUserResponse_t*
*/
adb_getSystemPermissionOfUserResponse_t*
axis2_skel_AuthenticationAdminService_getSystemPermissionOfUser(
const axutil_env_t *env ,
axis2_msg_ctx_t *msg_ctx,
adb_getSystemPermissionOfUser_t* _getSystemPermissionOfUser,
axis2_skel_AuthenticationAdminService_getSystemPermissionOfUser_fault *fault )
{
adb_getSystemPermissionOfUserResponse_t* response = NULL;
axutil_array_list_t *list = NULL;
/* TODO fill this with the necessary business logic */
list = axutil_array_list_create(env, 0);
axutil_array_list_add(list, env, axutil_strdup(env, "login"));
axutil_array_list_add(list, env, axutil_strdup(env, "manage-configuration"));
axutil_array_list_add(list, env, axutil_strdup(env, "manage-security"));
axutil_array_list_add(list, env, axutil_strdup(env, "upload-services"));
axutil_array_list_add(list, env, axutil_strdup(env, "manage-services"));
axutil_array_list_add(list, env, axutil_strdup(env, "manage-lc-configuration"));
axutil_array_list_add(list, env, axutil_strdup(env, "manage-mediation"));
axutil_array_list_add(list, env, axutil_strdup(env, "monitor-system"));
axutil_array_list_add(list, env, axutil_strdup(env, "delegate-identity"));
response = adb_getSystemPermissionOfUserResponse_create_with_values(env, list);
return response;
}
static axis2_status_t
axiom_mime_part_write_body_part_to_list(
const axutil_env_t *env,
axutil_array_list_t *list,
axiom_mime_body_part_t *part,
axis2_char_t *boundary)
{
axiom_mime_part_t *crlf1 = NULL;
axiom_mime_part_t *crlf2 = NULL;
axis2_status_t status = AXIS2_SUCCESS;
/* We are adding accoarding to the following format here.
* --MimeBoundary
* mime_header1
* mime_header2
* mime_header3 */
status = axiom_mime_part_write_mime_boundary(env, list, boundary);
if(status != AXIS2_SUCCESS)
{
return status;
}
/* Then we will add the new line charator after
* the mime_boundary */
crlf1 = axiom_mime_part_create(env);
crlf1->part = (axis2_byte_t *)axutil_strdup(env, AXIS2_CRLF);
crlf1->part_size = 2;
crlf1->type = AXIOM_MIME_PART_BUFFER;
axutil_array_list_add(list, env, crlf1);
/*This method will fill the list with mime_headers and
*if there is an attachment with attachment details*/
axiom_mime_body_part_write_to_list(part, env, list);
/* Then add the next \r\n after the attachment */
crlf2 = axiom_mime_part_create(env);
crlf2->part = (axis2_byte_t *)axutil_strdup(env, AXIS2_CRLF);
crlf2->part_size = 2;
crlf2->type = AXIOM_MIME_PART_BUFFER;
axutil_array_list_add(list, env, crlf2);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_header_set_header_block(
axiom_soap_header_t * soap_header,
const axutil_env_t * env,
struct axiom_soap_header_block * header_block)
{
axis2_char_t *key = NULL;
AXIS2_PARAM_CHECK(env->error, header_block, AXIS2_FAILURE);
key = (axis2_char_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 10);
if(!key)
{
return AXIS2_FAILURE;
}
sprintf(key, "%d", soap_header->hbnumber++);
if(soap_header->header_blocks)
{
axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, header_block);
}
else
{
soap_header->header_blocks = axutil_hash_make(env);
axutil_hash_set(soap_header->header_blocks, key, AXIS2_HASH_KEY_STRING, header_block);
}
if(soap_header->header_block_keys)
{
axutil_array_list_add(soap_header->header_block_keys, env, key);
}
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
load_policy_array(
axutil_array_list_t * arraylist,
axiom_node_t * root,
const axutil_env_t * env)
{
axiom_element_t *root_ele = NULL;
if (root)
{
if (axiom_node_get_node_type(root, env) == AXIOM_ELEMENT)
{
root_ele =
(axiom_element_t *) axiom_node_get_data_element(root, env);
if (root_ele)
{
neethi_policy_t *neethi_policy = NULL;
neethi_policy = neethi_engine_get_policy(env, root, root_ele);
if (!neethi_policy)
{
printf("Policy Creation fails\n");
return AXIS2_FAILURE;
}
axutil_array_list_add(arraylist, env, neethi_policy);
}
}
}
return AXIS2_SUCCESS;
}
/**
* Add to return.
*/
axis2_status_t AXIS2_CALL
adb_listExternalUsersResponse_add_return(
adb_listExternalUsersResponse_t* _listExternalUsersResponse,
const axutil_env_t *env,
const axis2_char_t* arg_return)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, AXIS2_FAILURE);
if(NULL == arg_return)
{
return AXIS2_SUCCESS;
}
if(_listExternalUsersResponse->property_return == NULL)
{
_listExternalUsersResponse->property_return = axutil_array_list_create(env, 10);
}
if(_listExternalUsersResponse->property_return == NULL)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for return");
return AXIS2_FAILURE;
}
axutil_array_list_add(_listExternalUsersResponse->property_return , env, axutil_strdup(env, arg_return));
_listExternalUsersResponse->is_valid_return = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_endpoint_ref_add_extension(
axis2_endpoint_ref_t * endpoint_ref,
const axutil_env_t * env,
axiom_node_t * extension_node)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!(endpoint_ref->extension_list))
{
endpoint_ref->extension_list = axutil_array_list_create(env, 0);
if (!(endpoint_ref->extension_list))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
if (endpoint_ref->extension_list && extension_node)
{
return axutil_array_list_add(endpoint_ref->extension_list, env,
extension_node);
}
return AXIS2_FAILURE;
}
static axis2_status_t
axis2_phase_add_unique(
const axutil_env_t * env,
axutil_array_list_t * list,
axis2_handler_t * handler)
{
int i = 0, size = 0;
axis2_bool_t add_handler = AXIS2_TRUE;
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)
{
add_handler = AXIS2_FALSE;
break;
}
else if(!axutil_strcmp(axutil_string_get_buffer(handler_name, env),
axutil_string_get_buffer(obj_name, env)))
{
add_handler = AXIS2_FALSE;
break;
}
}
if(add_handler)
axutil_array_list_add(list, env, handler);
return AXIS2_SUCCESS;
}
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;
}
/**
* Add to reservationStatuses.
*/
axis2_status_t AXIS2_CALL
adb_getReservationStatusesResponse_add_reservationStatuses(
adb_getReservationStatusesResponse_t* _getReservationStatusesResponse,
const axutil_env_t *env,
adb_ReservationStatus_t* arg_reservationStatuses)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _getReservationStatusesResponse, AXIS2_FAILURE);
if(NULL == arg_reservationStatuses)
{
return AXIS2_SUCCESS;
}
if(_getReservationStatusesResponse->property_reservationStatuses == NULL)
{
_getReservationStatusesResponse->property_reservationStatuses = axutil_array_list_create(env, 10);
}
if(_getReservationStatusesResponse->property_reservationStatuses == NULL)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for reservationStatuses");
return AXIS2_FAILURE;
}
axutil_array_list_add(_getReservationStatusesResponse->property_reservationStatuses , env, arg_reservationStatuses);
_getReservationStatusesResponse->is_valid_reservationStatuses = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Add to extraElement.
*/
axis2_status_t AXIS2_CALL
adb_CanonicalizationMethodType_add_extraElement(
adb_CanonicalizationMethodType_t* _CanonicalizationMethodType,
const axutil_env_t *env,
axiom_node_t* arg_extraElement)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE);
if(NULL == arg_extraElement)
{
return AXIS2_SUCCESS;
}
if(_CanonicalizationMethodType->property_extraElement == NULL)
{
_CanonicalizationMethodType->property_extraElement = axutil_array_list_create(env, 10);
}
if(_CanonicalizationMethodType->property_extraElement == NULL)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for extraElement");
return AXIS2_FAILURE;
}
axutil_array_list_add(_CanonicalizationMethodType->property_extraElement , env, arg_extraElement);
_CanonicalizationMethodType->is_valid_extraElement = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
/**
* Add to contentFormat.
*/
axis2_status_t AXIS2_CALL
adb_supportedContentFormats_type0_add_contentFormat(
adb_supportedContentFormats_type0_t* _supportedContentFormats_type0,
const axutil_env_t *env,
const axis2_char_t* arg_contentFormat)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _supportedContentFormats_type0, AXIS2_FAILURE);
if(NULL == arg_contentFormat)
{
return AXIS2_SUCCESS;
}
if(_supportedContentFormats_type0->property_contentFormat == NULL)
{
_supportedContentFormats_type0->property_contentFormat = axutil_array_list_create(env, 10);
}
if(_supportedContentFormats_type0->property_contentFormat == NULL)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for contentFormat");
return AXIS2_FAILURE;
}
axutil_array_list_add(_supportedContentFormats_type0->property_contentFormat , env, axutil_strdup(env, arg_contentFormat));
_supportedContentFormats_type0->is_valid_contentFormat = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_endpoint_ref_add_metadata_attribute(
axis2_endpoint_ref_t * endpoint_ref,
const axutil_env_t * env,
axiom_attribute_t * attr)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!(endpoint_ref->meta_attribute_list))
{
endpoint_ref->meta_attribute_list = axutil_array_list_create(env, 0);
if (!(endpoint_ref->meta_attribute_list))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
if (endpoint_ref->meta_attribute_list && attr)
{
return axutil_array_list_add(endpoint_ref->meta_attribute_list, env,
attr);
}
return AXIS2_FAILURE;
}
/**
* Add to publishedOperations.
*/
axis2_status_t AXIS2_CALL
adb_OperationMetaDataWrapper_add_publishedOperations(
adb_OperationMetaDataWrapper_t* _OperationMetaDataWrapper,
const axutil_env_t *env,
adb_OperationMetaData_t* arg_publishedOperations)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, _OperationMetaDataWrapper, AXIS2_FAILURE);
if(NULL == arg_publishedOperations)
{
return AXIS2_SUCCESS;
}
if(_OperationMetaDataWrapper->property_publishedOperations == NULL)
{
_OperationMetaDataWrapper->property_publishedOperations = axutil_array_list_create(env, 10);
}
if(_OperationMetaDataWrapper->property_publishedOperations == NULL)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for publishedOperations");
return AXIS2_FAILURE;
}
axutil_array_list_add(_OperationMetaDataWrapper->property_publishedOperations , env, arg_publishedOperations);
_OperationMetaDataWrapper->is_valid_publishedOperations = AXIS2_TRUE;
return AXIS2_SUCCESS;
}
axutil_array_list_t* AXIS2_CALL
remote_registry_comment_load_from_feed(
const axutil_env_t *env,
axis2_char_t *buffer)
{
axiom_children_iterator_t *node_it = NULL;
axiom_node_t *feed_node = NULL;
axiom_element_t *feed_ele = NULL;
axutil_array_list_t *comment_list = NULL;
feed_node = axiom_node_create_from_buffer(env, buffer);
if(!feed_node)
{
return NULL;
}
comment_list = axutil_array_list_create(env, 10);
if(!comment_list)
{
return NULL;
}
feed_ele = axiom_node_get_data_element(feed_node, env);
node_it = axiom_element_get_children(feed_ele, env, feed_node);
/* iterate all the children */
while(axiom_children_iterator_has_next(node_it, env))
{
axiom_node_t *child = NULL;
axiom_element_t *child_ele = NULL;
axis2_char_t *local_name = NULL;
child = axiom_children_iterator_next(node_it, env);
if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT)
{
continue;
}
child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env);
local_name = axiom_element_get_localname(child_ele, env);
/* retriving the attribute one by one */
if(!axutil_strcmp(local_name, "entry"))
{
remote_registry_comment_t *comment = NULL;
comment = remote_registry_comment_create_from_entry_node(env, child);
axutil_array_list_add(comment_list, env, comment);
}
}
return comment_list;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
sandesha2_report_add_to_outgoing_seq_list(
sandesha2_report_t *report,
const axutil_env_t *env,
axis2_char_t *out_seq_id)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
axutil_array_list_add(report->outgoing_seq_list, env, out_seq_id);
return AXIS2_SUCCESS;
}
void
axis2_addr_in_create_fault_envelope(
const axutil_env_t * env,
const axis2_char_t * header_name,
const axis2_char_t * addr_ns_str,
axis2_msg_ctx_t * msg_ctx)
{
axiom_soap_envelope_t *envelope = NULL;
axutil_array_list_t *sub_codes = NULL;
int soap_version = AXIOM_SOAP12;
axiom_node_t *text_om_node = NULL;
axiom_element_t *text_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
if (axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
{
soap_version = AXIOM_SOAP11;
}
ns1 = axiom_namespace_create(env, addr_ns_str, AXIS2_WSA_DEFAULT_PREFIX);
text_om_ele =
axiom_element_create(env, NULL, "ProblemHeaderQName", ns1,
&text_om_node);
axiom_element_set_text(text_om_ele, env, header_name, text_om_node);
sub_codes = axutil_array_list_create(env, 2);
if (sub_codes)
{
axutil_array_list_add(sub_codes, env, "wsa:InvalidAddressingHeader");
axutil_array_list_add(sub_codes, env, "wsa:InvalidCardinality");
}
envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env,
"soapenv:Sender",
"A header representing a Message Addressing Property is not valid and the message cannot be processed",
soap_version,
sub_codes,
text_om_node);
axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, envelope);
axis2_msg_ctx_set_wsa_action(msg_ctx, env,
"http://www.w3.org/2005/08/addressing/fault");
return;
}
AXIS2_EXTERN int AXIS2_CALL saml_attr_query_add_designators(saml_attr_query_t *attr_query, const axutil_env_t *env,
saml_attr_desig_t *desig)
{
if(!attr_query->attr_desigs)
{
axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
}
axutil_array_list_add(attr_query->attr_desigs, env, desig);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rp_signed_encrypted_parts_add_header(
rp_signed_encrypted_parts_t * signed_encrypted_parts,
const axutil_env_t * env,
rp_header_t * header)
{
AXIS2_PARAM_CHECK(env->error, header, AXIS2_FAILURE);
axutil_array_list_add(signed_encrypted_parts->headers, env, header);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
neethi_assertion_add_operator(
neethi_assertion_t *neethi_assertion,
const axutil_env_t *env,
neethi_operator_t *operator)
{
neethi_operator_increment_ref(operator, env);
axutil_array_list_add(neethi_assertion->policy_components, env, operator);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
sandesha2_seq_report_add_completed_msg(
sandesha2_seq_report_t *report,
const axutil_env_t *env,
long *msg_no)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
axutil_array_list_add(report->completed_msgs, env, msg_no);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rp_signed_encrypted_items_add_element(
rp_signed_encrypted_items_t * signed_encrypted_items,
const axutil_env_t * env,
rp_element_t * element)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, element, AXIS2_FAILURE);
axutil_array_list_add(signed_encrypted_items->elements, env, element);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rp_signed_encrypted_elements_add_expression(
rp_signed_encrypted_elements_t * signed_encrypted_elements,
const axutil_env_t * env,
axis2_char_t * expression)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, expression, AXIS2_FAILURE);
axutil_array_list_add(signed_encrypted_elements->xpath_expressions, env, expression);
return AXIS2_SUCCESS;
}
/* Initialize the service */
int AXIS2_CALL
echo_init(axis2_svc_skeleton_t *svc_skeleton,
const axutil_env_t *env)
{
svc_skeleton->func_array = axutil_array_list_create(env, 0);
/* Add the implemented operation names of the service to
* the array list of functions
*/
axutil_array_list_add(svc_skeleton->func_array, env, "echoString");
/* Any initialization stuff of echo service should go here */
return AXIS2_SUCCESS;
}
int AXIS2_CALL
axis2_svc_skel_TraderExchange_init(axis2_svc_skeleton_t *svc_skeleton,
const axutil_env_t *env)
{
svc_skeleton->func_array = axutil_array_list_create(env, 10);
axutil_array_list_add(svc_skeleton->func_array, env, "update");
/* Any initialization stuff of axis2_skel_TraderExchange goes here */
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_output_write_optimized(
axiom_output_t * om_output,
const axutil_env_t * env,
axiom_text_t * om_text)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if(om_output->binary_node_list)
{
axutil_array_list_add(om_output->binary_node_list, env, om_text);
}
else
{
om_output->binary_node_list = axutil_array_list_create(env, 5);
if(!(om_output->binary_node_list))
{
return AXIS2_FAILURE;
}
axutil_array_list_add(om_output->binary_node_list, env, om_text);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_module_qname(
axis2_svc_t * svc,
const axutil_env_t * env,
const axutil_qname_t * module_qname)
{
axutil_qname_t *qmodule_qname_l = NULL;
AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE);
qmodule_qname_l = axutil_qname_clone((axutil_qname_t *)module_qname, env);
return axutil_array_list_add(svc->module_list, env, qmodule_qname_l);
}
axis2_status_t AXIS2_CALL
sandesha2_property_bean_add_msg_type_to_drop(
sandesha2_property_bean_t *bean,
const axutil_env_t *env,
int msg_type)
{
int *_msg_type = NULL;
if(!bean->msg_types_to_drop)
return AXIS2_FAILURE;
_msg_type = AXIS2_MALLOC(env->allocator, sizeof(int));
axutil_array_list_add(bean->msg_types_to_drop, env, _msg_type);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rp_supporting_tokens_add_token(
rp_supporting_tokens_t * supporting_tokens,
const axutil_env_t * env,
rp_property_t * token)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, token, AXIS2_FAILURE);
rp_property_increment_ref(token, env);
axutil_array_list_add(supporting_tokens->tokens, env, token);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_soap_fault_reason_add_soap_fault_text(
axiom_soap_fault_reason_t * fault_reason,
const axutil_env_t * env,
axiom_soap_fault_text_t * fault_text)
{
if (!fault_text)
{
return AXIS2_FAILURE;
}
if (!(fault_reason->fault_texts))
{
fault_reason->fault_texts = axutil_array_list_create(env, 1);
if (!fault_reason->fault_texts)
{
return AXIS2_FAILURE;
}
axutil_array_list_add(fault_reason->fault_texts, env, fault_text);
}
else
{
axis2_char_t *lang = NULL;
axis2_bool_t is_exists = AXIS2_FALSE;
lang = axiom_soap_fault_text_get_lang(fault_text, env);
if (lang)
{
is_exists =
axiom_soap_fault_reason_lang_exists(fault_reason, env, lang);
if (is_exists == AXIS2_TRUE)
{
return AXIS2_FAILURE;
}
/** this soap_fault text already exists */
}
axutil_array_list_add(fault_reason->fault_texts, env, fault_text);
}
return AXIS2_SUCCESS;
}
