diff options
Diffstat (limited to 'neethi/test/main.c')
| -rw-r--r-- | neethi/test/main.c | 362 |
1 files changed, 362 insertions, 0 deletions
diff --git a/neethi/test/main.c b/neethi/test/main.c new file mode 100644 index 0000000..53ec367 --- /dev/null +++ b/neethi/test/main.c @@ -0,0 +1,362 @@ +#include <axiom.h> +#include <axutil_utils.h> +#include <axutil_env.h> +#include <axutil_log_default.h> +#include <axutil_error_default.h> +#include <stdio.h> +#include <axiom_xml_reader.h> +#include <neethi_engine.h> +#include <axutil_hash.h> + +axis2_status_t AXIS2_CALL om_node_serialize( + axiom_node_t * node, + const axutil_env_t * env); + +/*axis2_status_t AXIS2_CALL +load_policy_array( + axutil_array_list_t *arraylist, + axis2_char_t *file_name, + const axutil_env_t *env); +*/ +axis2_status_t AXIS2_CALL load_policy_array( + axutil_array_list_t * arraylist, + axiom_node_t * root, + const axutil_env_t * env); + +axiom_node_t *return_policy_element( + axis2_char_t * name, + const axutil_env_t * env, + axis2_char_t * wsdl_name); + +axis2_char_t *get_policy_ref( + axiom_node_t * node, + const axutil_env_t * env); + +void get_all_policy( + axis2_char_t * element_name, + const axutil_env_t * env, + axutil_array_list_t * policy_node_list, + axis2_char_t * wsdl_name); + +neethi_policy_t *AXIS2_CALL merge_policylist( + axutil_array_list_t * arraylist, + const axutil_env_t * env); + +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; + +} + +neethi_policy_t *AXIS2_CALL +merge_policylist( + axutil_array_list_t * arraylist, + const axutil_env_t * env) +{ + int i = 0; + neethi_policy_t *policy = NULL; + neethi_policy_t *result = NULL; + + result = (neethi_policy_t *) axutil_array_list_get(arraylist, env, 0); + result = + (neethi_policy_t *) neethi_engine_get_normalize(env, AXIS2_FALSE, + result); + + for (i = 1; i < axutil_array_list_size(arraylist, env); i++) + { + policy = (neethi_policy_t *) axutil_array_list_get(arraylist, env, i); + policy = + (neethi_policy_t *) neethi_engine_get_normalize(env, AXIS2_FALSE, + policy); + result = (neethi_policy_t *) neethi_engine_merge(env, policy, result); + } + return result; +} + +axis2_status_t AXIS2_CALL +om_node_serialize( + axiom_node_t * node, + const axutil_env_t * env) +{ + + axiom_output_t *om_output = NULL; + axiom_xml_writer_t *writer = NULL; + axis2_char_t *output_buffer = NULL; + axis2_status_t status = AXIS2_FAILURE; + + writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, + AXIS2_XML_PARSER_TYPE_BUFFER); + om_output = axiom_output_create(env, writer); + + status = axiom_node_serialize(node, env, om_output); + if (status != AXIS2_SUCCESS) + { + printf("\naxiom_node_serialize failed\n"); + return 0; + } + else + printf("\naxiom_node_serialize success\n"); + /* end serializing stuff */ + + /*axiom_node_free_tree(node1, env); */ + output_buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env); + + printf("\nend test_om_serialize\n"); + +} + +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; +} + +axiom_node_t * +return_policy_element( + axis2_char_t * name, + const axutil_env_t * env, + axis2_char_t * wsdl_name) +{ + axiom_element_t *ele1 = NULL, + *ele2 = NULL; + axiom_document_t *document = NULL; + axiom_node_t *node1 = NULL, + *node2 = NULL, + *policy_node = NULL; + axiom_namespace_t *ns = NULL; + axiom_xml_reader_t *reader = NULL; + axiom_stax_builder_t *builder = NULL; + char *buffer = NULL; + axiom_attribute_t *attr = NULL; + axis2_char_t *value = NULL; + axis2_char_t *val = NULL; + axutil_hash_t *attr_hash = NULL; + axis2_char_t *xml_output = NULL; + axutil_hash_index_t *hi; + +/* + f = fopen(wsdl_name, "r"); + if (!f) + return NULL; + + reader = axiom_xml_reader_create_for_io(env, read_input, NULL , NULL, NULL); +*/ + reader = axiom_xml_reader_create_for_file(env, wsdl_name, NULL); + + if (!reader) + { + printf("ERROR CREATING PULLPARSER"); + return NULL; + } + + builder = axiom_stax_builder_create(env, reader); + + if (!builder) + { + printf("ERROR CREATING PULL PARSER"); + return NULL; + } + + document = axiom_stax_builder_get_document(builder, env); + if (!document) + return NULL; + + node1 = axiom_document_get_root_element(document, env); + if (!node1) + { + printf(" root element null "); + axiom_stax_builder_free(builder, env); + return NULL; + } + + do + { + node2 = axiom_document_build_next(document, env); + + if (!node2) + break; + + if (axiom_node_get_node_type(node2, env) == AXIOM_ELEMENT) + { + ele2 = (axiom_element_t *) axiom_node_get_data_element(node2, env); + attr_hash = axiom_element_get_all_attributes(ele2, env); + if (attr_hash) + { + hi = axutil_hash_first(attr_hash, env); + axutil_hash_this(hi, NULL, NULL, &attr); + + if (axutil_strcmp(axiom_attribute_get_value(attr, env), name) == + 0) + { + policy_node = node2; + } + } + } + } + while (node2); + return policy_node; +} + +axis2_char_t * +get_policy_ref( + axiom_node_t * node, + const axutil_env_t * env) +{ + axiom_element_t *policy_element = NULL; + axiom_children_iterator_t *children_iter = NULL; + axiom_node_t *child_node = NULL; + axutil_qname_t *qname = NULL; + axis2_char_t *value = NULL; + axis2_char_t *val = NULL; + axiom_attribute_t *attr = NULL; + + policy_element = (axiom_element_t *) axiom_node_get_data_element(node, env); + children_iter = axiom_element_get_children(policy_element, env, node); + + while (axiom_children_iterator_has_next(children_iter, env)) + { + child_node = axiom_children_iterator_next(children_iter, env); + if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT) + { + policy_element = + (axiom_element_t *) axiom_node_get_data_element(child_node, + env); + + if (axutil_strcmp + (axiom_element_get_localname(policy_element, env), + "PolicyReference") == 0) + { + qname = axutil_qname_create(env, "URI", NULL, NULL); + attr = axiom_element_get_attribute(policy_element, env, qname); + + if (attr) + { + value = axiom_attribute_get_value(attr, env); + val = axutil_string_substring_starting_at(value, 1); + return val; + } + } + } + } + return NULL; +} + +void +get_all_policy( + axis2_char_t * element_name, + const axutil_env_t * env, + axutil_array_list_t * policy_node_list, + axis2_char_t * wsdl_name) +{ + axutil_hash_t *attr_hash = NULL; + axutil_hash_index_t *hi = NULL; + axiom_element_t *element = NULL; + axiom_attribute_t *attribute = NULL; + axis2_char_t *attribute_val = NULL; + axiom_node_t *parent_policy_node = NULL, + *parent_node = NULL; + + parent_node = return_policy_element(element_name, env, wsdl_name); + if (!parent_node) + return; + + parent_policy_node = + return_policy_element(get_policy_ref(parent_node, env), env, wsdl_name); + axutil_array_list_add(policy_node_list, env, parent_policy_node); + + if (axiom_node_get_node_type(parent_node, env) == AXIOM_ELEMENT) + { + element = + (axiom_element_t *) axiom_node_get_data_element(parent_node, env); + attr_hash = axiom_element_get_all_attributes(element, env); + if (attr_hash) + { + hi = axutil_hash_next(env, axutil_hash_first(attr_hash, env)); + do + { + if (hi) + { + axutil_hash_this(hi, NULL, NULL, &attribute); + attribute_val = axiom_attribute_get_value(attribute, env); + attribute_val = axutil_rindex(attribute_val, ':'); + attribute_val = + axutil_string_substring_starting_at(attribute_val, 1); + get_all_policy(attribute_val, env, policy_node_list, + wsdl_name); + hi = axutil_hash_next(env, hi); + } + } + while (hi); + } + } + return; +} |