| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #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; |
| } |