/**
* 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;
}
int
main(
int argc,
char **argv)
{
axis2_status_t status = AXIS2_FAILURE;
int i = 0;
axutil_array_list_t *policy_list = NULL;
axutil_array_list_t *policy_node_list = NULL;
neethi_policy_t *resultant = NULL;
axutil_allocator_t *allocator = axutil_allocator_init(NULL);
axutil_error_t *error = axutil_error_create(allocator);
const axutil_env_t *env = axutil_env_create_with_error(allocator, error);
policy_list = axutil_array_list_create(env, 0);
policy_node_list = axutil_array_list_create(env, 0);
get_all_policy(argv[1], env, policy_node_list, argv[2]);
for (i = 0; i < axutil_array_list_size(policy_node_list, env); i++)
{
axiom_node_t *node = NULL;
node = (axiom_node_t *) axutil_array_list_get(policy_node_list, env, i);
status = load_policy_array(policy_list, node, env);
}
resultant = merge_policylist(policy_list, env);
if (!resultant)
{
printf("Error Merging\n");
return 0;
}
else
{
axiom_node_t *s_node = NULL;
axis2_char_t *buff = NULL;
s_node = neethi_engine_serialize(resultant, env);
if (!s_node)
{
printf("Serializing failed\n");
return 0;
}
buff = axiom_node_to_string(s_node, env);
printf("\n%s", buff);
}
printf("Successful\n");
return 0;
}
AXIS2_EXTERN axiom_soap_header_t *AXIS2_CALL
axiom_soap_header_create(
const axutil_env_t * env)
{
axiom_soap_header_t *soap_header = NULL;
soap_header = (axiom_soap_header_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_soap_header_t));
if(!soap_header)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create SOAP header");
return NULL;
}
soap_header->om_ele_node = NULL;
soap_header->soap_envelope = NULL;
soap_header->hbnumber = 0;
soap_header->header_blocks = NULL;
/** default value */
soap_header->soap_version = AXIOM_SOAP12;
soap_header->header_block_keys = NULL;
soap_header->header_block_keys = axutil_array_list_create(env, 10);
if(!soap_header->header_block_keys)
{
AXIS2_FREE(env->allocator, soap_header);
return NULL;
}
return soap_header;
}
AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL
axis2_arch_file_data_create(
const axutil_env_t * env)
{
axis2_arch_file_data_t *arch_file_data = NULL;
arch_file_data = (axis2_arch_file_data_t *) AXIS2_MALLOC(env->
allocator,
sizeof
(axis2_arch_file_data_t));
if (!arch_file_data)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
memset ((void *)arch_file_data, 0, sizeof (axis2_arch_file_data_t));
arch_file_data->deployable_svcs = axutil_array_list_create(env, 0);
if (!arch_file_data->deployable_svcs)
{
axis2_arch_file_data_free(arch_file_data, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
return arch_file_data;
}
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;
}
/**
* 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;
}
AXIS2_EXTERN rp_signed_encrypted_items_t *AXIS2_CALL
rp_signed_encrypted_items_create(
const axutil_env_t * env)
{
rp_signed_encrypted_items_t *signed_encrypted_items = NULL;
AXIS2_ENV_CHECK(env, NULL);
signed_encrypted_items = (rp_signed_encrypted_items_t *)AXIS2_MALLOC(env->allocator,
sizeof(rp_signed_encrypted_items_t));
if(signed_encrypted_items == NULL)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
signed_encrypted_items->elements = NULL;
signed_encrypted_items->elements = axutil_array_list_create(env, 0);
if(!(signed_encrypted_items->elements))
{
rp_signed_encrypted_items_free(signed_encrypted_items, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
return signed_encrypted_items;
}
AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL
neethi_exactlyone_create(
const axutil_env_t *env)
{
neethi_exactlyone_t *neethi_exactlyone = NULL;
AXIS2_ENV_CHECK(env, NULL);
neethi_exactlyone = (neethi_exactlyone_t *)AXIS2_MALLOC(env->allocator,
sizeof(neethi_exactlyone_t));
if(neethi_exactlyone == NULL)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
neethi_exactlyone->policy_components = NULL;
neethi_exactlyone->policy_components = axutil_array_list_create(env, 0);
if(!(neethi_exactlyone->policy_components))
{
neethi_exactlyone_free(neethi_exactlyone, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
return neethi_exactlyone;
}
/**
* 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;
}
AXIS2_EXTERN rp_supporting_tokens_t *AXIS2_CALL
rp_supporting_tokens_create(
const axutil_env_t * env)
{
rp_supporting_tokens_t *supporting_tokens = NULL;
AXIS2_ENV_CHECK(env, NULL);
supporting_tokens = (rp_supporting_tokens_t *) AXIS2_MALLOC(env->allocator,
sizeof
(rp_supporting_tokens_t));
if (supporting_tokens == NULL)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
supporting_tokens->tokens = NULL;
supporting_tokens->tokens = axutil_array_list_create(env, 0);
if (!(supporting_tokens->tokens))
{
rp_supporting_tokens_free(supporting_tokens, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
supporting_tokens->algorithmsuite = NULL;
supporting_tokens->signed_parts = NULL;
supporting_tokens->signed_elements = NULL;
supporting_tokens->encrypted_parts = NULL;
supporting_tokens->encrypted_elements = NULL;
supporting_tokens->type = 0;
supporting_tokens->ref = 0;
return supporting_tokens;
}
AXIS2_EXTERN rp_signed_encrypted_parts_t *AXIS2_CALL
rp_signed_encrypted_parts_create(
const axutil_env_t * env)
{
rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
signed_encrypted_parts = (rp_signed_encrypted_parts_t *)AXIS2_MALLOC(env->allocator,
sizeof(rp_signed_encrypted_parts_t));
if(!signed_encrypted_parts)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot create signed_encrypted_parts. Insuficient memory.");
return NULL;
}
signed_encrypted_parts->headers = axutil_array_list_create(env, 0);
if(!signed_encrypted_parts->headers)
{
rp_signed_encrypted_parts_free(signed_encrypted_parts, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[neethi] Cannot create signed_encrypted_parts. Headers array list creation failed.");
return NULL;
}
signed_encrypted_parts->body = AXIS2_FALSE;
signed_encrypted_parts->ref = 0;
signed_encrypted_parts->signedparts = AXIS2_FALSE;
signed_encrypted_parts->attachments = AXIS2_FALSE;
return signed_encrypted_parts;
}
/**
* 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 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;
}
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
neethi_assertion_create(
const axutil_env_t *env)
{
neethi_assertion_t *neethi_assertion = NULL;
AXIS2_ENV_CHECK(env, NULL);
neethi_assertion = (neethi_assertion_t *)AXIS2_MALLOC(env->allocator,
sizeof(neethi_assertion_t));
if(neethi_assertion == NULL)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
neethi_assertion->policy_components = NULL;
neethi_assertion->policy_components = axutil_array_list_create(env, 0);
if(!(neethi_assertion->policy_components))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
neethi_assertion->value = NULL;
neethi_assertion->type = ASSERTION_TYPE_UNKNOWN;
neethi_assertion->element = NULL;
neethi_assertion->is_optional = AXIS2_FALSE;
neethi_assertion->node = NULL;
neethi_assertion->free_func = 0;
return neethi_assertion;
}
/**
* 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;
}
/**
* 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_EXTERN remote_registry_rest_client_t* AXIS2_CALL
remote_registry_rest_client_create(
const axutil_env_t *env,
remote_registry_conf_t *conf)
{
remote_registry_rest_client_t *rest_client = NULL;
AXIS2_PARAM_CHECK(env->error, conf, NULL);
rest_client = (remote_registry_rest_client_t *)AXIS2_MALLOC(env->allocator,
sizeof(remote_registry_rest_client_t));
if(!rest_client)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
/* initializing the values */
rest_client->last_response_status = AXIS2_SUCCESS;
rest_client->last_response_content_type = NULL;
rest_client->conf = conf;
rest_client->cached_entries = axutil_hash_make(env);
rest_client->cached_entries_len = axutil_hash_make(env);
rest_client->etags = axutil_hash_make(env);
rest_client->reverse_cached_order = axutil_hash_make(env);
rest_client->cached_order = axutil_array_list_create(env, 10);
rest_client->cached_order_index = 0;
return rest_client;
}
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 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;
}
/* 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_ws_info_list_t *AXIS2_CALL
axis2_ws_info_list_create_with_dep_engine(
const axutil_env_t * env,
struct axis2_dep_engine *dep_engine)
{
axis2_ws_info_list_t *ws_info_list = NULL;
ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator,
sizeof(axis2_ws_info_list_t));
if(!ws_info_list)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t));
ws_info_list->dep_engine = dep_engine;
ws_info_list->ws_info_list = axutil_array_list_create(env, 0);
if(!(ws_info_list->ws_info_list))
{
axis2_ws_info_list_free(ws_info_list, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
ws_info_list->current_info_list = axutil_array_list_create(env, 0);
if(!(ws_info_list->current_info_list))
{
axis2_ws_info_list_free(ws_info_list, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
return ws_info_list;
}
AXIS2_EXTERN int AXIS2_CALL saml_util_set_sig_ctx_defaults(oxs_sign_ctx_t *sig_ctx, const axutil_env_t *env, axis2_char_t *id)
{
oxs_sign_part_t* sig_part = NULL;
oxs_transform_t *tr = NULL;
axutil_array_list_t *sig_parts = NULL, *trans = NULL;
trans = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
/*create transform sor SAML XML signature with identifier*/
tr = oxs_transforms_factory_produce_transform(env, OXS_HREF_TRANSFORM_ENVELOPED_SIGNATURE);
axutil_array_list_add(trans, env, tr);
/*Create the EXCL-C14N Transformation*/
tr = oxs_transforms_factory_produce_transform(env, OXS_HREF_TRANSFORM_XML_EXC_C14N);
axutil_array_list_add(trans, env, tr);
sig_part = oxs_sign_part_create(env);
oxs_sign_part_set_digest_mtd(sig_part, env, OXS_HREF_SHA1);
oxs_sign_part_set_transforms(sig_part, env, trans);
oxs_sign_part_set_id_name(sig_part, env, id);
/*ns = axiom_namespace_create(env, "", "");
oxs_sign_part_set_sign_namespace(sig_part,env, ns);*/
sig_parts = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
axutil_array_list_add(sig_parts, env, sig_part);
/*create the specific sign context*/
oxs_sign_ctx_set_c14n_mtd(sig_ctx, env, OXS_HREF_XML_EXC_C14N);
oxs_sign_ctx_set_operation(sig_ctx, env, OXS_SIGN_OPERATION_SIGN);
oxs_sign_ctx_set_sign_mtd_algo(sig_ctx, env, OXS_HREF_RSA_SHA1);
oxs_sign_ctx_set_sign_parts(sig_ctx, env, sig_parts);
return AXIS2_SUCCESS;
}
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 int AXIS2_CALL saml_autho_decision_query_add_action(saml_autho_decision_query_t *autho_dec_query,
const axutil_env_t *env,
saml_action_t *action)
{
if(!autho_dec_query->saml_actions)
{
autho_dec_query->saml_actions = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
}
if(autho_dec_query->saml_actions)
{
axutil_array_list_add(autho_dec_query->saml_actions, env, action);
return AXIS2_SUCCESS;
}
return AXIS2_FAILURE;
}
AXIS2_EXTERN saml_attr_query_t* AXIS2_CALL saml_attr_query_create(const axutil_env_t *env)
{
saml_attr_query_t *attribute_query = NULL;
attribute_query = (saml_attr_query_t *)AXIS2_MALLOC(env->allocator,
sizeof(saml_attr_query_t));
if(attribute_query)
{
attribute_query->resource = NULL;
attribute_query->subject = saml_subject_create(env);
attribute_query->attr_desigs = axutil_array_list_create(env, SAML_ARRAY_LIST_DEF);
}
return attribute_query;
}
AXIS2_EXTERN sandesha2_report_t * AXIS2_CALL
sandesha2_report_create(
const axutil_env_t *env)
{
sandesha2_report_t *report = NULL;
AXIS2_ENV_CHECK(env, NULL);
report = AXIS2_MALLOC(env->allocator,
sizeof(sandesha2_report_t));
report->incoming_seq_list = NULL;
report->outgoing_seq_list = NULL;
report->seq_status_map = NULL;
report->no_of_completed_msgs_map = NULL;
report->outgoing_internal_seq_id_map = NULL;
report->incoming_seq_list = axutil_array_list_create(env, 0);
report->outgoing_seq_list = axutil_array_list_create(env, 0);
if(!report->incoming_seq_list ||
!report->outgoing_seq_list)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
report->seq_status_map = axutil_hash_make(env);
report->no_of_completed_msgs_map = axutil_hash_make(env);
report->outgoing_internal_seq_id_map = axutil_hash_make(env);
if(!report->seq_status_map ||
!report->no_of_completed_msgs_map ||
!report->outgoing_internal_seq_id_map)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
return report;
}
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 axis2_phase_t *AXIS2_CALL
axis2_phase_create(
const axutil_env_t * env,
const axis2_char_t * phase_name)
{
axis2_phase_t *phase = NULL;
phase = AXIS2_MALLOC(env->allocator, sizeof(axis2_phase_t));
if(!phase)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
return NULL;
}
phase->name = NULL;
phase->handlers = NULL;
phase->first_handler = NULL;
phase->first_handler_set = AXIS2_FALSE;
phase->last_handler = NULL;
phase->last_handler_set = AXIS2_FALSE;
phase->is_one_handler = AXIS2_FALSE;
phase->ref = 1;
phase->handlers = axutil_array_list_create(env, 10);
if(!(phase->handlers))
{
/** error is already set by last method array list container create */
axis2_phase_free(phase, env);
return NULL;
}
if(phase_name)
{
phase->name = axutil_strdup(env, phase_name);
if(!(phase->name))
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory");
axis2_phase_free(phase, env);
return NULL;
}
}
return phase;
}
