axiom_node_t * build_om_programatically( const axutil_env_t * env) { axiom_node_t *version_om_node = NULL; axiom_element_t *version_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axiom_xml_writer_t *xml_writer = NULL; axiom_output_t *om_output = NULL; axis2_char_t *buffer = NULL; ns1 = axiom_namespace_create(env, "urn:aewebservices71", "ns1"); version_om_ele = axiom_element_create(env, NULL, "GetVersion", ns1, &version_om_node); xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, AXIS2_XML_PARSER_TYPE_BUFFER); om_output = axiom_output_create(env, xml_writer); axiom_node_serialize(version_om_node, env, om_output); buffer = (axis2_char_t *) axiom_xml_writer_get_xml(xml_writer, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n", buffer); if (om_output) { axiom_output_free(om_output, env); om_output = NULL; } axiom_namespace_free(ns1, env); return version_om_node; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_programatically( const axutil_env_t * env) { axiom_node_t *notify_om_node = NULL; axiom_element_t *notify_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *buffer = NULL; ns1 = axiom_namespace_create(env, "http://example.org/notify", "m"); notify_om_ele = axiom_element_create(env, NULL, "notify", ns1, ¬ify_om_node); axiom_element_set_text(notify_om_ele, env, "notify5", notify_om_node); buffer = axiom_node_to_string(notify_om_node, env); if (buffer) { printf("\nSending OM node in XML : %s \n", buffer); AXIS2_FREE(env->allocator, buffer); } return notify_om_node; }
axiom_node_t* AXIS2_CALL sandesha2_address_to_om_node( sandesha2_address_t *address, const axutil_env_t *env, void *om_node) { axiom_namespace_t *rm_ns = NULL; axiom_element_t *addr_element = NULL; axiom_node_t *addr_node = NULL; AXIS2_PARAM_CHECK(env->error, om_node, NULL); if(!address->epr || !axis2_endpoint_ref_get_address( address->epr, env) || 0 == axutil_strlen( axis2_endpoint_ref_get_address(address->epr, env))) { AXIS2_ERROR_SET(env->error, (axutil_error_codes_t)SANDESHA2_ERROR_TO_OM_NULL_ELEMENT, AXIS2_FAILURE); return NULL; } rm_ns = axiom_namespace_create(env, address->ns_val, AXIS2_WSA_DEFAULT_PREFIX); if(!rm_ns) { return NULL; } addr_element = axiom_element_create(env, NULL, SANDESHA2_WSA_ADDRESS, rm_ns, &addr_node); if(!addr_element) { return NULL; } axiom_element_set_text(addr_element, env, axis2_endpoint_ref_get_address(address->epr, env), addr_node); axiom_node_add_child((axiom_node_t*)om_node, env, addr_node); return (axiom_node_t*)om_node; }
/** * Creates <wsse:Reference> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_reference_element( const axutil_env_t *env, axiom_node_t *parent, axis2_char_t *ref, axis2_char_t *value_type) { axiom_node_t *reference_node = NULL; axiom_element_t *reference_ele = NULL; axiom_attribute_t *ref_attr = NULL; axiom_attribute_t *value_type_attr = NULL; axiom_namespace_t *ns_obj = NULL; ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE); reference_ele = axiom_element_create(env, parent, OXS_NODE_REFERENCE, ns_obj, &reference_node); if (!reference_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating Reference element."); axiom_namespace_free(ns_obj, env); return NULL; } if(!ref) { ref = ""; } ref_attr = axiom_attribute_create(env, OXS_ATTR_URI , ref, NULL); axiom_element_add_attribute(reference_ele, env, ref_attr, reference_node); if(value_type) { value_type_attr = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE , value_type, NULL); axiom_element_add_attribute(reference_ele, env, value_type_attr, reference_node); } return reference_node; }
/** * Creates <wsc:Nonce> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_nonce_element( const axutil_env_t *env, axiom_node_t *parent, axis2_char_t* nonce_val, axis2_char_t *wsc_ns_uri) { axiom_node_t *nonce_node = NULL; axiom_element_t *nonce_ele = NULL; axis2_status_t ret; axiom_namespace_t *ns_obj = NULL; if(!wsc_ns_uri) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element. SecConv namespace uri is not valid.", OXS_NODE_NONCE); return NULL; } ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC); nonce_ele = axiom_element_create(env, parent, OXS_NODE_NONCE, ns_obj, &nonce_node); if (!nonce_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element.", OXS_NODE_NONCE); axiom_namespace_free(ns_obj, env); return NULL; } if (nonce_val) { ret = axiom_element_set_text(nonce_ele, env, nonce_val, nonce_node); } return nonce_node; }
/** * Creates <wsc:Label> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_label_element( const axutil_env_t *env, axiom_node_t *parent, axis2_char_t *label_val, axis2_char_t *wsc_ns_uri) { axiom_node_t *label_node = NULL; axiom_element_t *label_ele = NULL; axiom_namespace_t *ns_obj = NULL; if(!wsc_ns_uri) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element. SecConv namespace uri is not valid.", OXS_NODE_LABEL); return NULL; } ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC); label_ele = axiom_element_create(env, parent, OXS_NODE_LABEL, ns_obj, &label_node); if(!label_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element.", OXS_NODE_LABEL); axiom_namespace_free(ns_obj, env); return NULL; } if(label_val) { axiom_element_set_text(label_ele, env, label_val, label_node); } return label_node; }
/** * Creates <wsse:BinarySecurityToken> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_binary_security_token_element( const axutil_env_t *env, axiom_node_t *parent, axis2_char_t* id, axis2_char_t* encoding_type, axis2_char_t* value_type, axis2_char_t* data) { axiom_node_t *binary_sec_token_node = NULL; axiom_node_t *first_child_of_parent = NULL; axiom_element_t *binary_security_token_ele = NULL; axiom_attribute_t *encoding_type_att = NULL; axiom_attribute_t *value_type_att = NULL; axiom_attribute_t *id_attr = NULL; axiom_namespace_t *ns_obj = NULL; axiom_namespace_t *ns = NULL; ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE); ns = axiom_namespace_create(env, RAMPART_WSU_XMLNS, OXS_WSU); binary_security_token_ele = axiom_element_create(env, parent, OXS_NODE_BINARY_SECURITY_TOKEN, ns_obj, &binary_sec_token_node); if(!binary_security_token_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s element.", OXS_NODE_BINARY_SECURITY_TOKEN); axiom_namespace_free(ns_obj, env); axiom_namespace_free(ns, env); return NULL; } /* Binary security token must be added as the first child of the paretn */ binary_sec_token_node = axiom_node_detach_without_namespaces(binary_sec_token_node, env); first_child_of_parent = axiom_node_get_first_element(parent, env); if(first_child_of_parent) { /* If there is a child add bst before it */ axiom_node_insert_sibling_before(first_child_of_parent, env, binary_sec_token_node); } else { /* If there are no children just add the bst */ axiom_node_add_child(parent, env, binary_sec_token_node); } if(!id) { id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID); } id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, ns); encoding_type_att = axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL); value_type_att = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL); axiom_element_add_attribute(binary_security_token_ele, env, id_attr, binary_sec_token_node); axiom_element_add_attribute(binary_security_token_ele, env, encoding_type_att, binary_sec_token_node); axiom_element_add_attribute(binary_security_token_ele, env, value_type_att, binary_sec_token_node); if(data) { axiom_element_set_text(binary_security_token_ele, env, data, binary_sec_token_node); } return binary_sec_token_node; }
axiom_node_t* AXIS2_CALL axis2_sellRequest_ex_serialize( axis2_sellRequest_ex_t* sellRequest_ex, const axutil_env_t *env, axiom_node_t* parent, int has_parent) { axiom_namespace_t *ns1 = NULL; axis2_char_t *text_value_1; axis2_char_t *text_value_2; axis2_char_t text_value_3[64]; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; AXIS2_ENV_CHECK(env, NULL); ns1 = axiom_namespace_create (env, "http://www.wso2.org/types", "ns1"); if( parent == NULL) { current_element = axiom_element_create (env, parent, "sell", ns1 , ¤t_node); axiom_element_set_namespace( current_element, env, ns1, current_node); parent = current_node; } if(has_parent) { data_source = axiom_node_get_data_element(parent, env); if (!data_source) return NULL; stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */ if (!stream) return NULL; current_node = parent; } else { data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); } /** * parsing userid element */ start_input_str = "<ns1:userid>"; start_input_str_len = axutil_strlen(start_input_str); end_input_str = "</ns1:userid>"; end_input_str_len = axutil_strlen(end_input_str); text_value_1 = sellRequest_ex->attrib_userid; axutil_stream_write(stream, env, start_input_str, start_input_str_len); axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); axutil_stream_write(stream, env, end_input_str, end_input_str_len); /** * parsing symbol element */ start_input_str = "<ns1:symbol>"; start_input_str_len = axutil_strlen(start_input_str); end_input_str = "</ns1:symbol>"; end_input_str_len = axutil_strlen(end_input_str); text_value_2 = sellRequest_ex->attrib_symbol; axutil_stream_write(stream, env, start_input_str, start_input_str_len); axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2)); axutil_stream_write(stream, env, end_input_str, end_input_str_len); /** * parsing qty element */ start_input_str = "<ns1:qty>"; start_input_str_len = axutil_strlen(start_input_str); end_input_str = "</ns1:qty>"; end_input_str_len = axutil_strlen(end_input_str); sprintf ( text_value_3, "%d", sellRequest_ex->attrib_qty ); axutil_stream_write(stream, env, start_input_str, start_input_str_len); axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3)); axutil_stream_write(stream, env, end_input_str, end_input_str_len); return parent; }
axiom_node_t* AXIS2_CALL adb_listExternalUsersResponse_serialize_obj( adb_listExternalUsersResponse_t* _listExternalUsersResponse, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; int i = 0; int count = 0; void *element = NULL; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _listExternalUsersResponse, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://service.mgt.user.carbon.wso2.org", "n"); axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "listExternalUsersResponse", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://service.mgt.user.carbon.wso2.org", p_prefix)); } if (!_listExternalUsersResponse->is_valid_return) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * Parsing return array */ if (_listExternalUsersResponse->property_return != NULL) { sprintf(start_input_str, "<%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); count = axutil_array_list_size(_listExternalUsersResponse->property_return, env); for(i = 0; i < count; i ++) { element = axutil_array_list_get(_listExternalUsersResponse->property_return, env, i); if(NULL == element) { continue; } /* * parsing return element */ text_value_1 = (axis2_char_t*)element; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); } } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
AXIS2_EXTERN axiom_node_t *AXIS2_CALL remote_registry_resource_serialize( remote_registry_resource_t *resource, const axutil_env_t *env) { axiom_node_t *entry_node = NULL; axiom_element_t *entry_element = NULL; axiom_namespace_t *ns1 = NULL; axiom_namespace_t *ns2 = NULL; axis2_char_t *description = NULL; axis2_char_t *author = NULL; axutil_hash_t *properties = NULL; axis2_char_t *content = NULL; int collection = 0; int content_modified= 0; axis2_char_t *id = NULL; axis2_char_t *title = NULL; axis2_char_t *media_type = NULL; axis2_char_t *parent_path = NULL; axutil_date_time_t *modified_date = NULL; ns1 = axiom_namespace_create(env, REMOTE_REGISTRY_ATOM_NS, REMOTE_REGISTRY_ATOM_NS_PREFIX); ns2 = axiom_namespace_create(env, REMOTE_REGISTRY_REGISTRY_NS, REMOTE_REGISTRY_REGISTRY_NS_PREFIX); if(resource->is_collection) { entry_element = axiom_element_create(env, NULL, REMOTE_REGISTRY_FEED_KEY_FEED, ns1, &entry_node); } else { entry_element = axiom_element_create(env, NULL, REMOTE_REGISTRY_FEED_KEY_ENTRY, ns1, &entry_node); } axiom_element_declare_namespace(entry_element, env, entry_node, ns1); axiom_element_declare_namespace(entry_element, env, entry_node, ns2); /* getting variables from the structure and rendering into an XML */ id = remote_registry_resource_get_id(resource, env); if(id) { axiom_node_t *id_node = NULL; axiom_element_t *id_element = NULL; id_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_ID, ns1, &id_node); axiom_element_set_text(id_element, env, id, id_node); } title = remote_registry_resource_get_title(resource, env); if(title) { axiom_node_t *title_node = NULL; axiom_element_t *title_element = NULL; axiom_attribute_t *type_attr = NULL; title_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_TITLE, ns1, &title_node); axiom_element_set_text(title_element, env, title, title_node); type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE, REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT, NULL); axiom_element_add_attribute(title_element, env, type_attr, title_node); } description = remote_registry_resource_get_description(resource, env); if(description) { axiom_node_t *summary_node = NULL; axiom_element_t *summary_element = NULL; axiom_attribute_t *type_attr = NULL; summary_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_SUMMARY, ns1, &summary_node); axiom_element_set_text(summary_element, env, description, summary_node); type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE, REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT, NULL); axiom_element_add_attribute(summary_element, env, type_attr, summary_node); } author = remote_registry_resource_get_author_name(resource, env); if(author) { axiom_node_t *author_node = NULL; axiom_node_t *name_node = NULL; axiom_element_t *name_ele = NULL; axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_AUTHOR, ns1, &author_node); name_ele = axiom_element_create(env, author_node, REMOTE_REGISTRY_FEED_KEY_NAME, ns1, &name_node); axiom_element_set_text(name_ele, env, author, name_node); } modified_date = remote_registry_resource_get_last_modified_time(resource, env); if(!modified_date) { modified_date = axutil_date_time_create(env); remote_registry_resource_set_last_modified_time(resource, env, modified_date); } if(modified_date) { axiom_node_t *date_node = NULL; axiom_element_t *date_ele = NULL; axis2_char_t *modified_date_str = NULL; modified_date_str = axutil_date_time_serialize_date_time(modified_date, env); date_ele = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_UPDATED, ns1, &date_node); axiom_element_set_text(date_ele, env, modified_date_str, date_node); AXIS2_FREE(env->allocator, modified_date_str); } content = remote_registry_resource_get_content(resource, env); if(content) { axiom_node_t *content_node = NULL; axiom_element_t *content_element = NULL; axiom_attribute_t *type_attr = NULL; axis2_char_t *base64_content = NULL; int base64_len = 0; int content_len = -1; content_len = remote_registry_resource_get_content_len(resource, env); if(content_len == -1) /* which mean we have to derive the content length */ { content_len = axutil_strlen(content); } base64_len = axutil_base64_encode_len(content_len); base64_content = AXIS2_MALLOC(env->allocator, base64_len+ 1); if(base64_content) { axutil_base64_encode(base64_content, content, content_len); base64_content[base64_len] = '\0'; content_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_CONTENT, ns1, &content_node); axiom_element_set_text(content_element, env, base64_content, content_node); type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE, REMOTE_REGISTRY_FEED_ATTR_TYPE_BASE64_VALUE, NULL); axiom_element_add_attribute(content_element, env, type_attr, content_node); AXIS2_FREE(env->allocator, base64_content); } } else if(!resource->is_collection) { axiom_node_t *content_node = NULL; axiom_element_t *content_element = NULL; axiom_attribute_t *type_attr = NULL; content_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_CONTENT, ns1, &content_node); axiom_element_set_text(content_element, env, REMOTE_REGISTRY_FEED_VALUE_EMPTY_CONTENT, content_node); type_attr = axiom_attribute_create(env, REMOTE_REGISTRY_FEED_ATTR_TYPE, REMOTE_REGISTRY_FEED_ATTR_TYPE_TEXT_VALUE, NULL); axiom_element_add_attribute(content_element, env, type_attr, content_node); } properties = remote_registry_resource_get_properties(resource, env); if(properties) { axiom_node_t *properties_node = NULL; axiom_node_t *property_node = NULL; axiom_node_t *name_node = NULL; axiom_node_t *value_node = NULL; axiom_element_t *name_element = NULL; axiom_element_t *value_element = NULL; axutil_hash_index_t *hi; void *val; void *key; int sum = 0; axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_PROPERTIES, ns2, &properties_node); for (hi = axutil_hash_first(resource->properties, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, (const void**)&key, NULL, &val); axiom_element_create(env, properties_node, REMOTE_REGISTRY_FEED_KEY_PROPERTY, ns2, &property_node); name_element = axiom_element_create(env, property_node, REMOTE_REGISTRY_FEED_KEY_PROPERTY_KEY_NAME, ns2, &name_node); axiom_element_set_text(name_element, env, (axis2_char_t*)key, name_node); value_element = axiom_element_create(env, property_node, REMOTE_REGISTRY_FEED_KEY_PROPERTY_KEY_VALUE, ns2, &value_node); axiom_element_set_text(value_element, env, (axis2_char_t*)val, value_node); } } media_type = remote_registry_resource_get_media_type(resource, env); if(media_type) { axiom_element_t *media_element = NULL; axiom_node_t *media_node = NULL; media_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_MEDIA_TYPE, ns2, &media_node); axiom_element_set_text(media_element, env, media_type, media_node); } parent_path = remote_registry_resource_get_parent_path(resource, env); if(parent_path) { axiom_element_t *parent_path_element = NULL; axiom_node_t *parent_path_node = NULL; parent_path_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_PARENT_PATH, ns2, &parent_path_node); if(resource->is_collection) { /* for collection parent path is always sent at the http request header */ parent_path = ""; } axiom_element_set_text(parent_path_element, env, parent_path, parent_path_node); } if(resource->is_collection) { axiom_element_t *content_modified_element = NULL; axiom_node_t *content_modified_node = NULL; content_modified_element = axiom_element_create(env, entry_node, REMOTE_REGISTRY_FEED_KEY_CONTENT_MODIFIED, ns2, &content_modified_node); axiom_element_set_text(content_modified_element, env, REMOTE_REGISTRY_FEED_KEY_TRUE_VALUE, content_modified_node); } return entry_node; }
AXIS2_EXTERN axis2_char_t * AXIS2_CALL savan_client_get_status( savan_client_t *client, const axutil_env_t *env, axis2_svc_client_t *svc_client) { axis2_options_t *wsa_options = NULL; const axis2_char_t *old_action = NULL; axutil_qname_t *qname = NULL; axiom_namespace_t *ns = NULL; axiom_node_t *reply = NULL; axiom_node_t *status_node = NULL; axiom_node_t *expires_node = NULL; axiom_element_t *status_elem = NULL; axiom_element_t *expires_elem = NULL; axis2_char_t *expires = NULL; axis2_char_t *status_elem_localname = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_get_status"); /* Set wsa action as GetStatus. remember the old action */ wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env); old_action = axis2_options_get_action(wsa_options, env); axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_GET_STATUS); /* Create the body of the GetStatus request */ ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX); status_elem = axiom_element_create(env, NULL, ELEM_NAME_GETSTATUS, ns, &status_node); savan_client_add_sub_id_to_soap_header(client, env, svc_client); /* Send the GetStatus request and wait for the response */ reply = axis2_svc_client_send_receive(svc_client, env, status_node); /* Reset the old action */ axis2_options_set_action(wsa_options, env, old_action); if (!reply) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send get status " "request. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } status_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env); /* Check whether we have received a GetStatusResponse */ status_elem_localname = axiom_element_get_localname(status_elem, env); if (axutil_strcmp(ELEM_NAME_GETSTATUS_RESPONSE, status_elem_localname)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve GetStatusResponse"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } /* Now read Expires sub element */ qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL); expires_elem = axiom_element_get_first_child_with_qname(status_elem, env, qname, reply, &expires_node); axutil_qname_free(qname, env); if(!expires_node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } expires_elem = (axiom_element_t *) axiom_node_get_data_element(expires_node, env); expires = axiom_element_get_text(expires_elem, env, expires_node); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_get_status"); return expires; }
axiom_node_t * axis2_sub_sub( const axutil_env_t * env, axiom_node_t * node) { axiom_node_t *param1_node = NULL; axiom_node_t *param1_text_node = NULL; axis2_char_t *param1_str = NULL; long int param1 = 0; axiom_node_t *param2_node = NULL; axiom_node_t *param2_text_node = NULL; axis2_char_t *param2_str = NULL; long int param2 = 0; if (!node) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INPUT_OM_NODE_NULL, AXIS2_FAILURE); printf("Math client request ERROR: input parameter NULL\n"); return NULL; } param1_node = axiom_node_get_first_child(node, env); if (!param1_node) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } param1_text_node = axiom_node_get_first_child(param1_node, env); if (!param1_text_node) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } if (axiom_node_get_node_type(param1_text_node, env) == AXIOM_TEXT) { axiom_text_t *text = (axiom_text_t *) axiom_node_get_data_element(param1_text_node, env); if (text && axiom_text_get_value(text, env)) { param1_str = (axis2_char_t *) axiom_text_get_value(text, env); } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } param2_node = axiom_node_get_next_sibling(param1_node, env); if (!param2_node) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } param2_text_node = axiom_node_get_first_child(param2_node, env); if (!param2_text_node) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } if (axiom_node_get_node_type(param2_text_node, env) == AXIOM_TEXT) { axiom_text_t *text = (axiom_text_t *) axiom_node_get_data_element(param2_text_node, env); if (text && axiom_text_get_value(text, env)) { param2_str = (axis2_char_t *) axiom_text_get_value(text, env); } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_XML_FORMAT_IN_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid XML in request\n"); return NULL; } if (param1_str && param2_str) { long int result = 0; axis2_char_t result_str[255]; axiom_element_t *ele1 = NULL; axiom_node_t *node1 = NULL, *node2 = NULL; axiom_namespace_t *ns1 = NULL; axiom_text_t *text1 = NULL; param1 = strtol(param1_str, NULL, 10); param2 = strtol(param2_str, NULL, 10); result = param1 - param2; sprintf(result_str, "%ld", result); ns1 = axiom_namespace_create(env, "http://axis2/test/namespace1", "ns1"); ele1 = axiom_element_create(env, NULL, "result", ns1, &node1); text1 = axiom_text_create(env, node1, result_str, &node2); return node1; } AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_SKEL_INVALID_OPERATION_PARAMETERS_IN_SOAP_REQUEST, AXIS2_FAILURE); printf("Math service ERROR: invalid parameters\n"); return NULL; }
axiom_node_t* AXIS2_CALL adb_getPermissionsResponse_serialize_obj( adb_getPermissionsResponse_t* _getPermissionsResponse, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _getPermissionsResponse, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://services.resource.ui.mgt.registry.carbon.wso2.org", "n"); axutil_hash_set(namespaces, "http://services.resource.ui.mgt.registry.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "getPermissionsResponse", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://services.resource.ui.mgt.registry.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://services.resource.ui.mgt.registry.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://services.resource.ui.mgt.registry.carbon.wso2.org", p_prefix)); } if (!_getPermissionsResponse->is_valid_return) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing return element */ sprintf(start_input_str, "<%s%sreturn", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); if(!adb_PermissionBean_is_particle()) { axutil_stream_write(stream, env, start_input_str, start_input_str_len); } adb_PermissionBean_serialize(_getPermissionsResponse->property_return, env, current_node, parent_element, adb_PermissionBean_is_particle() || AXIS2_FALSE, namespaces, next_ns_index); if(!adb_PermissionBean_is_particle()) { axutil_stream_write(stream, env, end_input_str, end_input_str_len); } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
static axis2_status_t AXIS2_CALL axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, axis2_msg_ctx_t * new_msg_ctx) { axis2_svc_skeleton_t *svc_obj = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op_desc = NULL; const axis2_char_t *style = NULL; axiom_node_t *om_node = NULL; axiom_element_t *om_element = NULL; axis2_char_t *local_name = NULL; axiom_node_t *result_node = NULL; axiom_node_t *body_content_node = NULL; axiom_element_t *body_content_element = NULL; axiom_soap_envelope_t *default_envelope = NULL; axiom_soap_body_t *out_body = NULL; axiom_soap_header_t *out_header = NULL; axiom_soap_fault_t *soap_fault = NULL; axiom_node_t *out_node = NULL; axis2_status_t status = AXIS2_SUCCESS; axis2_bool_t skel_invoked = AXIS2_FALSE; const axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; int soap_version = AXIOM_SOAP12; axiom_namespace_t *env_ns = NULL; axiom_node_t *fault_node = NULL; axiom_soap_fault_detail_t *fault_detail; axis2_bool_t is_fault = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, new_msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Entry:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); /* get the implementation class for the Web Service */ svc_obj = axis2_msg_recv_make_new_svc_obj(msg_recv, env, msg_ctx); if(!svc_obj) { const axis2_char_t *svc_name = NULL; axis2_svc_t *svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(svc) { svc_name = axis2_svc_get_name(svc, env); } else { svc_name = "unknown"; } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Impl object for service '%s' not set in message receiver. %d :: %s", svc_name, env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); status = AXIS2_FAILURE; } else { op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); op_desc = axis2_op_ctx_get_op(op_ctx, env); style = axis2_op_get_style(op_desc, env); if(0 == axutil_strcmp(AXIS2_STYLE_DOC, style)) { axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); om_node = axiom_soap_body_get_base_node(body, env); om_element = axiom_node_get_data_element(om_node, env); om_node = axiom_node_get_first_element(om_node, env); } else if(0 == axutil_strcmp(AXIS2_STYLE_RPC, style)) { axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; axiom_node_t *op_node = NULL; axiom_element_t *op_element = NULL; envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); op_node = axiom_soap_body_get_base_node(body, env); op_element = axiom_node_get_data_element(op_node, env); if(op_element) { local_name = axiom_element_get_localname(op_element, env); if(local_name) { axutil_array_list_t *function_arr = NULL; int i = 0; int size = 0; axis2_bool_t matches = AXIS2_FALSE; function_arr = svc_obj->func_array; if(function_arr) { size = axutil_array_list_size(function_arr, env); } for(i = 0; i < size; i++) { axis2_char_t *function_name = NULL; function_name = (axis2_char_t *)axutil_array_list_get(function_arr, env, i); if(!axutil_strcmp(function_name, local_name)) { matches = AXIS2_TRUE; } } if(matches) { om_node = axiom_node_get_first_child(op_node, env); om_element = axiom_node_get_data_element(om_node, env); } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_MISMATCH, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OM_ELEMENT_INVALID_STATE, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RPC_NEED_MATCHING_CHILD, AXIS2_FAILURE); status = AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNKNOWN_STYLE, AXIS2_FAILURE); status = AXIS2_FAILURE; } if(status == AXIS2_SUCCESS) { skel_invoked = AXIS2_TRUE; result_node = AXIS2_SVC_SKELETON_INVOKE(svc_obj, env, om_node, new_msg_ctx); } if(result_node) { if(0 == axutil_strcmp(style, AXIS2_STYLE_RPC)) { axiom_namespace_t *ns = NULL; axis2_char_t *res_name = NULL; res_name = axutil_stracat(env, local_name, "Response"); ns = axiom_namespace_create(env, "http://soapenc/", "res"); if(!ns) { status = AXIS2_FAILURE; } else { body_content_element = axiom_element_create(env, NULL, res_name, ns, &body_content_node); axiom_node_add_child(body_content_node, env, result_node); } } else { body_content_node = result_node; } } else { axis2_char_t *mep = (axis2_char_t *)axis2_op_get_msg_exchange_pattern(op_desc, env); if(axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY) && axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY_WSDL2) && axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2)) { status = AXIS2_ERROR_GET_STATUS_CODE(env->error); if(status == AXIS2_SUCCESS) { axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); } else { axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( new_msg_ctx, env)); } /* The new_msg_ctx is passed to the service. The status code must * be taken from here and set to the old message context which is * used by the worker when the request processing fails. */ if(svc_obj->ops->on_fault) { fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); } is_fault = AXIS2_TRUE; } else { /* If we have a in only message result node is NULL. We create fault only if * an error is set */ status = AXIS2_ERROR_GET_STATUS_CODE(env->error); if(status == AXIS2_SUCCESS) { axis2_msg_ctx_set_no_content(new_msg_ctx, env, AXIS2_TRUE); } else { axis2_msg_ctx_set_status_code(msg_ctx, env, axis2_msg_ctx_get_status_code( new_msg_ctx, env)); if((!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY)) || (!axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_IN_ONLY_WSDL2))) { /* The new_msg_ctx is passed to the service. The status code must * be taken from here and set to the old message context which is * used by the worker when the request processing fails. */ if(svc_obj->ops->on_fault) { fault_node = AXIS2_SVC_SKELETON_ON_FAULT(svc_obj, env, om_node); } is_fault = AXIS2_TRUE; } } } } } if(msg_ctx && axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */ soap_version = AXIOM_SOAP11; } if(axis2_msg_ctx_get_soap_envelope(new_msg_ctx, env)) { /* service implementation has set the envelope, useful when setting a SOAP fault. No need to further process */ return AXIS2_SUCCESS; } /* create the soap envelope here */ env_ns = axiom_namespace_create(env, soap_ns, "soapenv"); if(!env_ns) { return AXIS2_FAILURE; } default_envelope = axiom_soap_envelope_create(env, env_ns); axiom_namespace_free(env_ns, env); if(!default_envelope) { return AXIS2_FAILURE; } out_header = axiom_soap_header_create_with_parent(env, default_envelope); if(!out_header) { return AXIS2_FAILURE; } out_body = axiom_soap_body_create_with_parent(env, default_envelope); if(!out_body) { return AXIS2_FAILURE; } out_node = axiom_soap_body_get_base_node(out_body, env); if(!out_node) { return AXIS2_FAILURE; } if(status != AXIS2_SUCCESS || is_fault) { /* something went wrong. set a SOAP Fault */ const axis2_char_t *fault_value_str = "soapenv:Sender"; const axis2_char_t *fault_reason_str = NULL; const axis2_char_t *err_msg = NULL; if(!skel_invoked) { if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP11_FAULT_CODE_RECEIVER; } else { fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; } } err_msg = AXIS2_ERROR_GET_MESSAGE(env->error); if (err_msg && axutil_strcmp(err_msg, "")) { if(!axutil_strcmp(err_msg, "No Error")) { fault_reason_str = "An error has occurred, but could not determine exact details"; } else { fault_reason_str = err_msg; } } else { fault_reason_str = "An error has occurred, but could not determine exact details"; } soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str, fault_reason_str, soap_version); if (fault_node) { axiom_node_t *fault_detail_node = NULL; axis2_char_t *om_str = NULL; fault_detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault); fault_detail_node = axiom_soap_fault_detail_get_base_node(fault_detail, env); om_str = axiom_node_to_string(fault_detail_node, env); if (om_str) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault_detail:%s", om_str); AXIS2_FREE(env->allocator, om_str); } axiom_soap_fault_detail_add_detail_entry(fault_detail, env, fault_node); } } if (body_content_node) { axiom_node_add_child(out_node, env, body_content_node); status = axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); } else if (soap_fault) { axis2_msg_ctx_set_soap_envelope(new_msg_ctx, env, default_envelope); status = AXIS2_SUCCESS; } else { /* we should free the memory as the envelope is not used, one way case */ axiom_soap_envelope_free(default_envelope, env); default_envelope = NULL; } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[axis2]Exit:axis2_raw_xml_in_out_msg_recv_invoke_business_logic_sync"); return status; }
axiom_node_t* AXIS2_CALL adb_subscriberRequest_serialize_obj( adb_subscriberRequest_t* _subscriberRequest, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _subscriberRequest, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://mopevm.ru/axis2/services/types", "n"); axutil_hash_set(namespaces, "http://mopevm.ru/axis2/services/types", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "subscriberRequest", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); p_prefix = NULL; if (!_subscriberRequest->is_valid_number) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property number"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("number"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("number"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing number element */ sprintf(start_input_str, "<%s%snumber>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%snumber>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); sprintf (text_value_1, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _subscriberRequest->property_number); axutil_stream_write(stream, env, start_input_str, start_input_str_len); axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
axis2_status_t create_recipient_node(neethi_options_t *options, const axutil_env_t *env, axiom_node_t *parent_node) { axiom_node_t *rec_token_node = NULL; axiom_node_t *rec_policy_node = NULL; axiom_node_t *x509_node = NULL; axiom_node_t *x509_policy_node = NULL; axiom_node_t *x509_type_node = NULL; axiom_element_t *rec_token_ele = NULL; axiom_element_t *x509_ele = NULL; axiom_element_t *parent_ele = NULL; axiom_attribute_t *attr = NULL; /*axiom_namespace_t *sp_ns = NULL;*/ /*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/ parent_ele = axiom_node_get_data_element(parent_node, env); if(!parent_ele) { return AXIS2_FAILURE; } /*sp_ns = axiom_element_find_namespace( parent_ele, env, parent_node, RP_SP_NS_12, RP_SP_PREFIX);*/ rec_token_ele = axiom_element_create(env, parent_node, RP_RECIPIENT_TOKEN, sp_ns, &rec_token_node); if(!rec_token_ele) { return AXIS2_FAILURE; } rec_policy_node = neethi_options_create_policy_node(env, rec_token_node); x509_ele = axiom_element_create(env, rec_policy_node, RP_X509_TOKEN, sp_ns, &x509_node); if(!x509_ele) { return AXIS2_FAILURE; } attr = axiom_attribute_create(env, RP_INCLUDE_TOKEN, RP_INCLUDE_NEVER, sp_ns); axiom_element_add_attribute(x509_ele, env, attr, x509_node); x509_policy_node = neethi_options_create_policy_node(env, x509_node); if(x509_policy_node) { if(options->keyidentifier && !(options->server_side)) { axiom_node_t *key_identifier_node = NULL; axiom_element_create(env, x509_policy_node, options->keyidentifier, sp_ns, &key_identifier_node); } axiom_element_create(env, x509_policy_node, RP_WSS_X509_V3_TOKEN_10, sp_ns, &x509_type_node); return AXIS2_SUCCESS; } else return AXIS2_FAILURE; }
axiom_node_t* AXIS2_CALL adb_UserNotRegisteredException1_serialize( adb_UserNotRegisteredException1_t* _UserNotRegisteredException1, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t *current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[64]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _UserNotRegisteredException1, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://esb.callbackservice.services.hdviper.psnc.pl/", "n"); axutil_hash_set(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "UserNotRegisteredException", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://esb.callbackservice.services.hdviper.psnc.pl/", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://esb.callbackservice.services.hdviper.psnc.pl/", p_prefix)); } if (!_UserNotRegisteredException1->is_valid_UserNotRegisteredException) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property UserNotRegisteredException"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("UserNotRegisteredException"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("UserNotRegisteredException"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing UserNotRegisteredException element */ sprintf(start_input_str, "<%s%sUserNotRegisteredException", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sUserNotRegisteredException>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); adb_UserNotRegisteredException_serialize(_UserNotRegisteredException1->property_UserNotRegisteredException, env, current_node, parent_element, adb_UserNotRegisteredException_is_particle() || AXIS2_TRUE, namespaces, next_ns_index); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL neethi_options_create_sym_node( neethi_options_t *options, const axutil_env_t *env, axiom_node_t *parent_node) { axiom_node_t *symmetric_om_node = NULL; axiom_node_t *policy_sym_node = NULL; axiom_element_t *symmetric_om_ele = NULL; axis2_status_t status = AXIS2_FAILURE; symmetric_om_ele = axiom_element_create(env, parent_node, RP_SYMMETRIC_BINDING, sp_ns, &symmetric_om_node); if(!symmetric_om_ele) { return AXIS2_FAILURE; } policy_sym_node = neethi_options_create_policy_node(env, symmetric_om_node); if(!policy_sym_node) { return AXIS2_FAILURE; } status = create_protection_node(options, env, policy_sym_node); if(status != AXIS2_SUCCESS) { return AXIS2_FAILURE; } status = create_algo_node(options, env, policy_sym_node); if(status != AXIS2_SUCCESS) { return AXIS2_FAILURE; } status = create_layout_node(options, env, policy_sym_node); if(status != AXIS2_SUCCESS) { return AXIS2_FAILURE; } if(options->include_timestamp) { axiom_node_t *ts_node = NULL; axiom_element_t *ts_ele = NULL; /*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/ ts_ele = axiom_element_create(env, policy_sym_node, RP_INCLUDE_TIMESTAMP, sp_ns, &ts_node); if(!ts_ele) { return AXIS2_FAILURE; } } if(options->encrypt_before_sign) { axiom_node_t *ebs_node = NULL; axiom_element_t *ebs_ele = NULL; /*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/ ebs_ele = axiom_element_create(env, policy_sym_node, RP_ENCRYPT_BEFORE_SIGNING, sp_ns, &ebs_node); if(!ebs_ele) { return AXIS2_FAILURE; } } if(options->signature_protection) { axiom_node_t *sigpro_node = NULL; axiom_element_t *sigpro_ele = NULL; /*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/ sigpro_ele = axiom_element_create(env, policy_sym_node, RP_ENCRYPT_SIGNATURE, sp_ns, &sigpro_node); if(!sigpro_ele) { return AXIS2_FAILURE; } } if(options->token_protection) { axiom_node_t *tokpro_node = NULL; axiom_element_t *tokpro_ele = NULL; /*sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX);*/ tokpro_ele = axiom_element_create(env, policy_sym_node, RP_PROTECT_TOKENS, sp_ns, &tokpro_node); if(!tokpro_ele) { return AXIS2_FAILURE; } } return AXIS2_SUCCESS; }
AXIS2_EXTERN axiom_node_t *AXIS2_CALL neethi_options_get_root_node( neethi_options_t *options, const axutil_env_t *env) { axiom_node_t *root_om_node = NULL; axiom_node_t* exact_om_node = NULL; axiom_node_t *all_om_node = NULL; axiom_element_t *all_om_ele = NULL; axis2_status_t status = AXIS2_SUCCESS; sp_ns = NULL; wsp_ns = NULL; wsp_ns = axiom_namespace_create(env, NEETHI_NAMESPACE, NEETHI_PREFIX); sp_ns = axiom_namespace_create(env, RP_SP_NS_12, RP_SP_PREFIX); axiom_element_create(env, NULL, NEETHI_POLICY, wsp_ns, &root_om_node); axiom_element_create(env, root_om_node, NEETHI_EXACTLYONE, wsp_ns, &exact_om_node); all_om_ele = axiom_element_create(env, exact_om_node, NEETHI_ALL, wsp_ns, &all_om_node); if(all_om_ele) { if(!axutil_strcmp(options->binding, RP_ASYMMETRIC_BINDING)) { status = neethi_options_create_asym_node(options, env, all_om_node); } else { status = neethi_options_create_sym_node(options, env, all_om_node); } if(status != AXIS2_SUCCESS) { return NULL; } if(options->is_username_token) { status = create_username_node(options, env, all_om_node); if(status != AXIS2_SUCCESS) { return NULL; } } status = create_wss10_node(options, env, all_om_node); if(status != AXIS2_SUCCESS) { return NULL; } if(options->sign_body)/* Or if there are headers to be signed*/ { status = neethi_options_create_signed_parts_node(options, env, all_om_node); if(status != AXIS2_SUCCESS) { return NULL; } } if(options->encrypt_body)/*Or if there are headers to be encrypt*/ { status = neethi_options_create_encrypted_parts_node(options, env, all_om_node); if(status != AXIS2_SUCCESS) { return NULL; } } return root_om_node; } else return NULL; }
static void ngx_squ_xml_serialize_table(squ_State *l, axutil_env_t *env, axiom_node_t *parent, char *name, int index) { int top; char *uri, *prefix, *text, *value; axiom_node_t *node; axiom_element_t *elem; ngx_squ_thread_t *thr; axiom_namespace_t *ns; axiom_attribute_t *attr; thr = ngx_squ_thread(l); ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml serialize table"); top = squ_gettop(l); squ_getfield(l, index, "uri"); uri = (char *) squL_optstring(l, -1, NULL); squ_getfield(l, index, "prefix"); prefix = (char *) squL_optstring(l, -1, NULL); if (uri != NULL || prefix != NULL) { ns = axiom_namespace_create(env, uri, prefix); } else { ns = NULL; } elem = axiom_element_create(env, parent, name, ns, &node); squ_getfield(l, index, "attributes"); if (!squ_isnil(l, -1)) { if (!squ_istable(l, -1)) { squL_error(l, "the value of \"attributes\" must be a table"); } squ_pushnil(l); while (squ_next(l, -2)) { name = (char *) squL_checkstring(l, -2); value = (char *) squL_checkstring(l, -1); attr = axiom_attribute_create(env, name, value, NULL); axiom_element_add_attribute(elem, env, attr, node); squ_pop(l, 1); } } squ_getfield(l, index, "text"); text = (char *) squL_optstring(l, -1, NULL); if (text != NULL) { axiom_element_set_text(elem, env, text, node); squ_settop(l, top); return; } squ_getfield(l, index, "children"); if (!squ_isnil(l, -1)) { if (!squ_istable(l, -1)) { squL_error(l, "the value of \"children\" must be a table"); } ngx_squ_xml_serialize_tables(l, env, node); } squ_settop(l, top); }
axiom_node_t* AXIS2_CALL adb_CipherReference_serialize_obj( adb_CipherReference_t* _CipherReference, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axis2_char_t* xsi_prefix = NULL; axiom_namespace_t* xsi_ns = NULL; axiom_attribute_t* xsi_type_attri = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _CipherReference, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://www.w3.org/2001/04/xmlenc#", "n"); axutil_hash_set(namespaces, "http://www.w3.org/2001/04/xmlenc#", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "CipherReference", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/04/xmlenc#", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://www.w3.org/2001/04/xmlenc#", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://www.w3.org/2001/04/xmlenc#", p_prefix)); } if (!_CipherReference->is_valid_CipherReference) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property CipherReference"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("CipherReference"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("CipherReference"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing CipherReference element */ sprintf(start_input_str, "<%s%sCipherReference", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sCipherReference>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); adb_CipherReferenceType_serialize(_CipherReference->property_CipherReference, env, current_node, parent_element, adb_CipherReferenceType_is_particle() || AXIS2_TRUE, namespaces, next_ns_index); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
AXIS2_EXTERN axiom_soap_fault_value_t *AXIS2_CALL axiom_soap_fault_value_create_with_subcode( const axutil_env_t * env, axiom_soap_fault_sub_code_t * parent) { axiom_soap_fault_value_t *fault_value = NULL; axiom_element_t *this_ele = NULL; axiom_node_t *this_node = NULL; axiom_namespace_t *parent_ns = NULL; axiom_node_t *parent_node = NULL; axiom_element_t *parent_ele = NULL; int soap_version = -1; AXIS2_PARAM_CHECK(env->error, parent, NULL); fault_value = axiom_soap_fault_value_create(env); if (!fault_value) { return NULL; } parent_node = axiom_soap_fault_sub_code_get_base_node(parent, env); if (!parent_node) { axiom_soap_fault_value_free(fault_value, env); return NULL; } parent_ele = (axiom_element_t *) axiom_node_get_data_element(parent_node, env); if (!parent_ele) { axiom_soap_fault_value_free(fault_value, env); return NULL; } soap_version = axiom_soap_fault_sub_code_get_soap_version(parent, env); if (soap_version == AXIOM_SOAP12) { parent_ns = axiom_element_get_namespace(parent_ele, env, parent_node); } this_ele = axiom_element_create(env, parent_node, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME, parent_ns, &this_node); if (!this_ele) { axiom_soap_fault_value_free(fault_value, env); return NULL; } fault_value->om_ele_node = this_node; axiom_soap_fault_sub_code_set_value(parent, env, fault_value); return fault_value; }
axiom_node_t* AXIS2_CALL axis2_svc_skel_LoggingAdmin_on_fault(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *node) { axiom_node_t *error_node = NULL; axiom_element_t *error_ele = NULL; axutil_error_codes_t error_code; axis2_svc_skel_LoggingAdmin_t *svc_skeleton_wrapper = NULL; svc_skeleton_wrapper = (axis2_svc_skel_LoggingAdmin_t*)svc_skeleton; error_code = env->error->error_number; if(error_code <= AXIS2_SKEL_LOGGINGADMIN_ERROR_NONE || error_code >= AXIS2_SKEL_LOGGINGADMIN_ERROR_LAST ) { error_ele = axiom_element_create(env, node, "fault", NULL, &error_node); axiom_element_set_text(error_ele, env, "LoggingAdmin|http://service.logging.carbon.wso2.org failed", error_node); } else if(error_code == AXIS2_SKEL_LOGGINGADMIN_RESTOREDEFAULTS_FAULT_EXCEPTION) { /* found which error code */ adb_ExceptionE0_t* adb_obj = NULL; adb_obj = (adb_ExceptionE0_t*)svc_skeleton_wrapper->fault.restoreDefaults_fault.Exception; if(adb_obj) { error_node = adb_ExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_ExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.restoreDefaults_fault.Exception = NULL; } } else if(error_code == AXIS2_SKEL_LOGGINGADMIN_UPDATESYSTEMLOG_FAULT_EXCEPTION) { /* found which error code */ adb_ExceptionE0_t* adb_obj = NULL; adb_obj = (adb_ExceptionE0_t*)svc_skeleton_wrapper->fault.updateSystemLog_fault.Exception; if(adb_obj) { error_node = adb_ExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_ExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.updateSystemLog_fault.Exception = NULL; } } else if(error_code == AXIS2_SKEL_LOGGINGADMIN_GETSYSTEMLOG_FAULT_EXCEPTION) { /* found which error code */ adb_ExceptionE0_t* adb_obj = NULL; adb_obj = (adb_ExceptionE0_t*)svc_skeleton_wrapper->fault.getSystemLog_fault.Exception; if(adb_obj) { error_node = adb_ExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_ExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.getSystemLog_fault.Exception = NULL; } } else if(error_code == AXIS2_SKEL_LOGGINGADMIN_UPDATEALLAPPENDERDATA_FAULT_EXCEPTION) { /* found which error code */ adb_ExceptionE0_t* adb_obj = NULL; adb_obj = (adb_ExceptionE0_t*)svc_skeleton_wrapper->fault.updateAllAppenderData_fault.Exception; if(adb_obj) { error_node = adb_ExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_ExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.updateAllAppenderData_fault.Exception = NULL; } } else if(error_code == AXIS2_SKEL_LOGGINGADMIN_UPDATELOGGERDATA_FAULT_EXCEPTION) { /* found which error code */ adb_ExceptionE0_t* adb_obj = NULL; adb_obj = (adb_ExceptionE0_t*)svc_skeleton_wrapper->fault.updateLoggerData_fault.Exception; if(adb_obj) { error_node = adb_ExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_ExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.updateLoggerData_fault.Exception = NULL; } } return error_node; }
axiom_node_t * build_soap_body_content( const axutil_env_t * env, const axis2_char_t * echo_operation, const axis2_char_t * echo_type, const axis2_char_t * word_to_echo) { axiom_node_t *operation_om_node = NULL; axiom_element_t *operation_om_ele = NULL; axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_attribute_t *attri1 = NULL; axiom_namespace_t *ns0 = NULL, *ns1 = NULL, *ns2 = NULL, *ns3 = NULL, *ns4 = NULL, *ns5 = NULL; axis2_char_t *om_str = NULL; axis2_char_t echo_operation_buff[32]; axis2_char_t input_type_buff[32]; axis2_char_t xsd_type_buff[32]; /*generating the requried parameters */ sprintf(echo_operation_buff, "echo%s", echo_operation); sprintf(input_type_buff, "input%s", echo_operation); sprintf(xsd_type_buff, "xsd:%s", echo_type); ns0 = axiom_namespace_create(env, "http://schemas.xmlsoap.org/soap/envelope/", "soapenv"); ns1 = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance", "xsi"); ns2 = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema", "xsd"); ns3 = axiom_namespace_create(env, "http://schemas.xmlsoap.org/soap/encoding/", "soapenc"); ns4 = axiom_namespace_create(env, "http://soapinterop.org/", "tns"); ns5 = axiom_namespace_create(env, "http://soapinterop.org/encodedTypes", "types"); operation_om_ele = axiom_element_create(env, NULL, echo_operation_buff, ns4, &operation_om_node); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns0); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns1); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns2); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns3); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns4); axiom_element_declare_namespace(operation_om_ele, env, operation_om_node, ns5); attri1 = axiom_attribute_create(env, "encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/", ns0); operation_om_ele = AXIOM_NODE_GET_DATA_ELEMENT(operation_om_node, env); axiom_element_add_attribute(operation_om_ele, env, attri1, operation_om_node); text_om_ele = axiom_element_create(env, operation_om_node, input_type_buff, NULL, &text_om_node); attri1 = axiom_attribute_create(env, "type", xsd_type_buff, ns1); axiom_element_add_attribute(text_om_ele, env, attri1, text_om_node); axiom_element_set_text(text_om_ele, env, word_to_echo, text_om_node); om_str = AXIOM_NODE_TO_STRING(operation_om_node, env); if (om_str) printf("\nSending OM : %s\n", om_str); return operation_om_node; }
axiom_node_t* AXIS2_CALL axis2_svc_skel_SecurityAdminService_on_fault(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *node) { axiom_node_t *error_node = NULL; axiom_element_t *error_ele = NULL; axutil_error_codes_t error_code; axis2_svc_skel_SecurityAdminService_t *svc_skeleton_wrapper = NULL; svc_skeleton_wrapper = (axis2_svc_skel_SecurityAdminService_t*)svc_skeleton; error_code = env->error->error_number; if(error_code <= AXIS2_SKEL_SECURITYADMINSERVICE_ERROR_NONE || error_code >= AXIS2_SKEL_SECURITYADMINSERVICE_ERROR_LAST ) { error_ele = axiom_element_create(env, node, "fault", NULL, &error_node); axiom_element_set_text(error_ele, env, "SecurityAdminService|http://service.config.security.carbon.wso2.org failed", error_node); } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_GETSCENARIOS_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.getScenarios_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.getScenarios_fault.SecurityConfigException = NULL; } } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_APPLYSECURITY_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.applySecurity_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.applySecurity_fault.SecurityConfigException = NULL; } } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_ACTIVATEUSERNAMETOKENAUTHENTICATION_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.activateUsernameTokenAuthentication_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.activateUsernameTokenAuthentication_fault.SecurityConfigException = NULL; } } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_DISABLESECURITYONSERVICE_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.disableSecurityOnService_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.disableSecurityOnService_fault.SecurityConfigException = NULL; } } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_GETSECURITYCONFIGDATA_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.getSecurityConfigData_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.getSecurityConfigData_fault.SecurityConfigException = NULL; } } else if(error_code == AXIS2_SKEL_SECURITYADMINSERVICE_GETSECURITYSCENARIO_FAULT_SECURITYCONFIGEXCEPTION) { /* found which error code */ adb_SecurityConfigExceptionE0_t* adb_obj = NULL; adb_obj = (adb_SecurityConfigExceptionE0_t*)svc_skeleton_wrapper->fault.getSecurityScenario_fault.SecurityConfigException; if(adb_obj) { error_node = adb_SecurityConfigExceptionE0_serialize(adb_obj, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); adb_SecurityConfigExceptionE0_free(adb_obj, env); svc_skeleton_wrapper->fault.getSecurityScenario_fault.SecurityConfigException = NULL; } } return error_node; }
axiom_node_t* AXIS2_CALL axis2_buyResponse_serialize( axis2_buyResponse_t* buyResponse, const axutil_env_t *env, axiom_node_t* parent, int has_parent) { axiom_namespace_t *ns1 = NULL; /*axis2_char_t text_value_1[64];*/ axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; AXIS2_ENV_CHECK(env, NULL); ns1 = axiom_namespace_create (env, "http://www.wso2.org/types", "ns1"); if( parent == NULL) { current_element = axiom_element_create (env, parent, "buyResponse", ns1 , ¤t_node); axiom_element_set_namespace( current_element, env, ns1, current_node); parent = current_node; } if(has_parent) { data_source = axiom_node_get_data_element(parent, env); if (!data_source) return NULL; stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */ if (!stream) return NULL; current_node = parent; } else { data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); } /** * parsing trade_status element */ start_input_str = "<ns1:trade_status xmlns:ns1=\"http://www.wso2.org/types\">"; start_input_str_len = axutil_strlen(start_input_str); end_input_str = "</ns1:trade_status>"; end_input_str_len = axutil_strlen(end_input_str); axutil_stream_write(stream, env, start_input_str, start_input_str_len); axis2_TradeStatus_serialize( buyResponse->attrib_trade_status, env, current_node, AXIS2_TRUE); axutil_stream_write(stream, env, end_input_str, end_input_str_len); return parent; }
axis2_op_t *AXIS2_CALL axis2_rest_disp_find_op( axis2_msg_ctx_t * msg_ctx, const axutil_env_t * env, axis2_svc_t * svc) { axis2_endpoint_ref_t *endpoint_ref = NULL; axis2_op_t *op = NULL; axiom_soap_envelope_t *soap_env = NULL; axiom_soap_body_t *soap_body = NULL; axiom_element_t *body_child = NULL; axiom_node_t *body_child_node = NULL; axiom_node_t *body_element_node = NULL; axis2_bool_t soap_env_exists = AXIS2_TRUE; int i = 0; axutil_array_list_t *param_keys = NULL; axutil_array_list_t *param_values = NULL; AXIS2_PARAM_CHECK(env->error, svc, NULL); if(!axis2_msg_ctx_get_doing_rest(msg_ctx, env)) return NULL; endpoint_ref = axis2_msg_ctx_get_to(msg_ctx, env); if(endpoint_ref) { const axis2_char_t *address = NULL; address = axis2_endpoint_ref_get_address(endpoint_ref, env); if(address) { axis2_char_t **url_tokens = NULL; url_tokens = axutil_parse_request_url_for_svc_and_op(env, address); if(url_tokens) { if(url_tokens[0]) { axis2_char_t *location = NULL; location = strstr(address, url_tokens[0]); if(location) { const axis2_char_t *method = NULL; location += strlen(url_tokens[0]); param_keys = axutil_array_list_create(env, 10); if(!param_keys) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the live rest parameter maps"); return NULL; } param_values = axutil_array_list_create(env, 10); if(!param_values) { axutil_array_list_free(param_keys, env); AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create the live rest parameter maps"); return NULL; } method = axis2_msg_ctx_get_rest_http_method(msg_ctx, env); op = axis2_core_utils_get_rest_op_with_method_and_location(svc, env, method, location, param_keys, param_values); } } if(url_tokens[0]) AXIS2_FREE(env->allocator, url_tokens[0]); if(url_tokens[1]) AXIS2_FREE(env->allocator, url_tokens[1]); AXIS2_FREE(env->allocator, url_tokens); } } } if(!op) { if(param_keys) { for(i = 0; i < axutil_array_list_size(param_keys, env); i++) { void *value = axutil_array_list_get(param_keys, env, i); AXIS2_FREE(env->allocator, value); } axutil_array_list_free(param_keys, env); } if(param_values) { for(i = 0; i < axutil_array_list_size(param_values, env); i++) { void *value = axutil_array_list_get(param_values, env, i); AXIS2_FREE(env->allocator, value); } axutil_array_list_free(param_values, env); } return NULL; } soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_env) { soap_env_exists = AXIS2_FALSE; soap_env = axiom_soap_envelope_create_default_soap_envelope(env, AXIOM_SOAP11); } if(soap_env) { soap_body = axiom_soap_envelope_get_body(soap_env, env); } if(!soap_body) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); if(param_keys) { for(i = 0; i < axutil_array_list_size(param_keys, env); i++) { void *value = axutil_array_list_get(param_keys, env, i); AXIS2_FREE(env->allocator, value); } axutil_array_list_free(param_keys, env); } if(param_values) { for(i = 0; i < axutil_array_list_size(param_values, env); i++) { void *value = axutil_array_list_get(param_values, env, i); AXIS2_FREE(env->allocator, value); } axutil_array_list_free(param_values, env); } return NULL; } body_element_node = axiom_soap_body_get_base_node(soap_body, env); if(body_element_node) { body_child_node = axiom_node_get_first_child(body_element_node, env); } if(!body_child_node) { body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname(op, env), &body_child_node); axiom_soap_body_add_child(soap_body, env, body_child_node); } if(param_keys && param_values) { for(i = 0; i < axutil_array_list_size(param_keys, env); i++) { axis2_char_t *param_key = NULL; axis2_char_t *param_value = NULL; axiom_node_t *node = NULL; axiom_element_t *element = NULL; param_key = axutil_array_list_get(param_keys, env, i); param_value = axutil_array_list_get(param_values, env, i); element = axiom_element_create(env, NULL, param_key, NULL, &node); axiom_element_set_text(element, env, param_value, node); axiom_node_add_child(body_child_node, env, node); AXIS2_FREE(env->allocator, param_key); AXIS2_FREE(env->allocator, param_value); } axutil_array_list_free(param_keys, env); axutil_array_list_free(param_values, env); } if(!soap_env_exists) { axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_env); } return op; }
axiom_node_t* AXIS2_CALL adb_item_serialize_obj( adb_item_t* _item, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axis2_char_t* xsi_prefix = NULL; axiom_namespace_t* xsi_ns = NULL; axiom_attribute_t* xsi_type_attri = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _item, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://www.daisy.org/ns/daisy-online/", "n"); axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "item", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://www.daisy.org/ns/daisy-online/", p_prefix)); } if (!_item->is_valid_item) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property item"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("item"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("item"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing item element */ sprintf(start_input_str, "<%s%sitem>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sitem>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_1 = _item->property_item; text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
axiom_node_t* AXIS2_CALL adb_getOperationRequestCount_serialize_obj( adb_getOperationRequestCount_t* _getOperationRequestCount, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *text_value_2; axis2_char_t *text_value_2_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _getOperationRequestCount, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://org.apache.axis2/xsd", "n"); axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "getOperationRequestCount", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://org.apache.axis2/xsd", p_prefix)); } if (!_getOperationRequestCount->is_valid_serviceName) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("serviceName"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("serviceName"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing serviceName element */ sprintf(start_input_str, "<%s%sserviceName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sserviceName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_1 = _getOperationRequestCount->property_serviceName; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://org.apache.axis2/xsd", p_prefix)); } if (!_getOperationRequestCount->is_valid_operationName) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("operationName"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("operationName"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing operationName element */ sprintf(start_input_str, "<%s%soperationName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%soperationName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_2 = _getOperationRequestCount->property_operationName; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE); if (text_value_2_temp) { axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp)); AXIS2_FREE(env->allocator, text_value_2_temp); } else { axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
axis2_status_t AXIS2_CALL wsf_xml_msg_recv_invoke_business_logic_sync( axis2_msg_recv_t * msg_recv, const axutil_env_t * env, axis2_msg_ctx_t * in_msg_ctx, axis2_msg_ctx_t * out_msg_ctx) { axis2_op_ctx_t *op_ctx = NULL; axis2_op_t *op_desc = NULL; axiom_namespace_t *env_ns = NULL; int soap_version = AXIOM_SOAP12; axis2_status_t status = AXIS2_SUCCESS; axis2_bool_t skel_invoked = AXIS2_FALSE; const axis2_char_t *style = NULL; axis2_char_t *local_name = NULL; axis2_char_t *soap_ns = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; axis2_char_t *operation_name = NULL; char *classname = NULL; axutil_property_t *svc_info_prop = NULL; axutil_property_t *req_info_prop = NULL; wsf_svc_info_t *svc_info = NULL; wsf_request_info_t *req_info = NULL; /** store in_msg_ctx envelope */ axiom_soap_envelope_t *envelope = NULL; axiom_soap_body_t *body = NULL; axiom_node_t *in_body_node = NULL; /* store out_msg_ctx envelope */ axiom_soap_envelope_t *default_envelope = NULL; axiom_soap_body_t *out_body = NULL; axiom_soap_header_t *out_header = NULL; axiom_soap_fault_t *out_soap_fault = NULL; axiom_node_t *result_node = NULL; axiom_node_t *out_body_content_node = NULL; axiom_element_t *out_body_content_element = NULL; axiom_node_t *out_node = NULL; zval **output_headers_zval = NULL; TSRMLS_FETCH(); AXIS2_PARAM_CHECK(env->error, in_msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, out_msg_ctx, AXIS2_FAILURE); op_ctx = axis2_msg_ctx_get_op_ctx(in_msg_ctx, env); op_desc = axis2_op_ctx_get_op(op_ctx, env); style = axis2_op_get_style(op_desc, env); envelope = axis2_msg_ctx_get_soap_envelope(in_msg_ctx, env); body = axiom_soap_envelope_get_body(envelope, env); in_body_node = axiom_soap_body_get_base_node(body, env); if (0 == axutil_strcmp(AXIS2_STYLE_DOC, style)) { local_name = wsf_xml_msg_recv_get_method_name(in_msg_ctx, env); if (!local_name) { return AXIS2_FAILURE; } } else if (0 == axutil_strcmp(AXIS2_STYLE_RPC, style)) { axiom_node_t *op_node = NULL; axiom_element_t *op_element = NULL; op_node = axiom_node_get_first_child(in_body_node, env); if (!op_node) { return AXIS2_FAILURE; } op_element = axiom_node_get_data_element(op_node, env); if (!op_element) { return AXIS2_FAILURE; } local_name = axiom_element_get_localname(op_element, env); if (!local_name) { return AXIS2_FAILURE; } } /** set soap version and soap namespace to local variables */ if (in_msg_ctx && axis2_msg_ctx_get_is_soap_11(in_msg_ctx, env)) { soap_ns = AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI; /* default is 1.2 */ soap_version = AXIOM_SOAP11; } svc_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_SVC_INFO); if (svc_info_prop) { svc_info = (wsf_svc_info_t *) axutil_property_get_value(svc_info_prop, env); if (svc_info) { operation_name = axutil_hash_get(svc_info->ops_to_functions, local_name, AXIS2_HASH_KEY_STRING); if (!operation_name) { return AXIS2_FAILURE; } } else { return AXIS2_FAILURE; } if (svc_info->ops_to_classes) { classname = axutil_hash_get(svc_info->ops_to_classes, local_name, AXIS2_HASH_KEY_STRING); } } req_info_prop = axis2_msg_ctx_get_property(in_msg_ctx, env, WSF_REQ_INFO); if (req_info_prop) { req_info = (wsf_request_info_t *) axutil_property_get_value(req_info_prop, env); if (axis2_msg_ctx_get_doing_rest(in_msg_ctx, env)) { axis2_op_t *op = NULL; axiom_node_t *body_child_node = NULL; axiom_element_t *body_child = NULL; int i = 0; body_child_node = axiom_node_get_first_child(in_body_node, env); if (!body_child_node) { op = axis2_msg_ctx_get_op(in_msg_ctx, env); if (op) { body_child = axiom_element_create_with_qname(env, NULL, axis2_op_get_qname(op, env), &body_child_node); axiom_soap_body_add_child(body, env, body_child_node); } } if (req_info->param_keys && req_info->param_values) { int i = 0; for (i = 0; i < axutil_array_list_size(req_info->param_keys, env); i++) { axiom_node_t *node = NULL; axiom_element_t *element = NULL; axis2_char_t *param_key = NULL; axis2_char_t *param_value = NULL; param_key = axutil_array_list_get(req_info->param_keys, env, i); param_value = axutil_array_list_get(req_info->param_values, env, i); element = axiom_element_create(env, NULL, param_key, NULL, &node); axiom_element_set_text(element, env, param_value, node); axiom_node_add_child(body_child_node, env, node); AXIS2_FREE(env->allocator, param_key); AXIS2_FREE(env->allocator, param_value); } axutil_array_list_free(req_info->param_keys, env); axutil_array_list_free(req_info->param_values, env); } } } if (svc_info->ht_op_params) { zval **tmp; char *function_type = NULL; if (zend_hash_find(svc_info->ht_op_params, operation_name, strlen(operation_name) + 1, (void **) & tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) { function_type = Z_STRVAL_PP(tmp); if (strcmp(function_type, WSF_MIXED) == 0) { result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info, in_msg_ctx, out_msg_ctx, operation_name, classname, &output_headers_zval TSRMLS_CC); } else if (strcmp(function_type, WSF_WSMESSAGE) == 0) { result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name, in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC); } } } else { /* this is where the default value for opParam is set, If the wsdl option is set go for the MIXED mode by default */ if (svc_info->wsdl == NULL || svc_info->omit_wsdl) { result_node = wsf_xml_msg_recv_invoke_wsmsg(env, operation_name, in_msg_ctx, out_msg_ctx, svc_info, classname, req_info->content_type TSRMLS_CC); } else { result_node = wsf_xml_msg_recv_invoke_mixed(env, svc_info, in_msg_ctx, out_msg_ctx, operation_name, classname, &output_headers_zval TSRMLS_CC); } } if (!result_node) { status = AXIS2_ERROR_GET_STATUS_CODE(env->error); } else { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "Response node is not null"); } if (result_node) { if (0 == axutil_strcmp(style, AXIS2_STYLE_RPC)) { axiom_namespace_t *ns = NULL; axis2_char_t *response_name = NULL; response_name = axutil_stracat(env, local_name, "Response"); ns = axiom_namespace_create(env, "http://soapenc/", "res"); if (!ns) { return AXIS2_FAILURE; } out_body_content_element = axiom_element_create(env, NULL, response_name, ns, &out_body_content_node); axiom_node_add_child(out_body_content_node, env, result_node); } else { out_body_content_node = result_node; } } if (axis2_msg_ctx_get_soap_envelope(out_msg_ctx, env)) { /* service implementation has set the envelope, useful when setting a SOAP fault. No need to further process */ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "soap fault is set"); return AXIS2_SUCCESS; } /* create the soap envelope here */ env_ns = axiom_namespace_create(env, soap_ns, AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX); if (!env_ns) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] error seting the namespces for the " AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX); return AXIS2_FAILURE; } default_envelope = axiom_soap_envelope_create(env, env_ns); if (!default_envelope) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap envelope"); return AXIS2_FAILURE; } out_body = axiom_soap_body_create_with_parent(env, default_envelope); if (!out_body) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in creating the response soap body"); return AXIS2_FAILURE; } out_header = axiom_soap_header_create_with_parent(env, default_envelope); if (!out_header) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, WSF_PHP_LOG_PREFIX "failed in creating the response soap headers"); return AXIS2_FAILURE; } if (output_headers_zval) { axiom_node_t *header_base_node = NULL; HashPosition pos; zval **param; char *header_str; axiom_node_t *header_node; for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(output_headers_zval), &pos); zend_hash_get_current_data_ex(Z_ARRVAL_PP(output_headers_zval), (void **) & param, &pos) == SUCCESS; zend_hash_move_forward_ex(Z_ARRVAL_PP(output_headers_zval), &pos)) { if (Z_TYPE_PP(param) == IS_STRING) { header_base_node = axiom_soap_header_get_base_node(out_header, env); if (header_base_node) { header_str = Z_STRVAL_PP(param); header_node = wsf_util_deserialize_buffer(env, header_str); axiom_node_add_child(header_base_node, env, header_node); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap headers node"); return AXIS2_FAILURE; } } } } out_node = axiom_soap_body_get_base_node(out_body, env); if (!out_node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[wsfphp] failed in retrieving the response soap body node"); return AXIS2_FAILURE; } if (status != AXIS2_SUCCESS) { /* something went wrong, set a SOAP Fault */ axis2_char_t *fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_SENDER; axis2_char_t *fault_reason_str = NULL; axis2_char_t *err_msg = NULL; if (!skel_invoked) fault_value_str = AXIOM_SOAP_DEFAULT_NAMESPACE_PREFIX ":" AXIOM_SOAP12_SOAP_FAULT_VALUE_RECEIVER; ; err_msg = (char *) AXIS2_ERROR_GET_MESSAGE(env->error); if (err_msg) { fault_reason_str = err_msg; } else { fault_reason_str = "Error occurred while processing SOAP message"; } out_soap_fault = axiom_soap_fault_create_default_fault(env, out_body, fault_value_str, fault_reason_str, soap_version); } if (out_body_content_node) { axiom_node_add_child(out_node, env, out_body_content_node); status = axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope); } else if (out_soap_fault) { axis2_msg_ctx_set_soap_envelope(out_msg_ctx, env, default_envelope); status = AXIS2_FAILURE; /* if there is a failure we have to return a failure code */ } else { /* we should free the memory as the envelope is not used, one way case */ axiom_soap_envelope_free(default_envelope, env); default_envelope = NULL; } return AXIS2_SUCCESS; }