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