AXIS2_EXTERN axutil_qname_t *AXIS2_CALL axiom_attribute_get_qname( axiom_attribute_t * attribute, const axutil_env_t * env) { axutil_qname_t *qname = NULL; AXIS2_ENV_CHECK(env, NULL); if(!(attribute->qname)) { if(attribute->ns) { qname = axutil_qname_create(env, axutil_string_get_buffer(attribute-> localname, env), axiom_namespace_get_uri(attribute->ns, env), axiom_namespace_get_prefix( attribute-> ns, env)); } else { qname = axutil_qname_create(env, axutil_string_get_buffer(attribute-> localname, env), NULL, NULL); } attribute->qname = qname; return qname; } return attribute->qname; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_serialize_namespace( axiom_text_t * om_text, const axutil_env_t * env, const axiom_namespace_t * om_namespace, axiom_output_t * om_output) { axiom_xml_writer_t *xml_writer = NULL; axis2_char_t *namespace_uri = NULL; axis2_char_t *namespace_prefix = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); (void)om_output; xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); /* What does this code do? */ /* om_namespace = axiom_namespace_create(env, "", ""); if(om_namespace) */ { namespace_uri = axiom_namespace_get_uri(om_text->ns, env); namespace_prefix = axiom_namespace_get_prefix(om_text->ns, env); axiom_xml_writer_write_namespace(xml_writer, env, namespace_prefix, namespace_uri); axiom_xml_writer_set_prefix(xml_writer, env, namespace_prefix, namespace_uri); } return AXIS2_SUCCESS; }
static axis2_status_t AXIS2_CALL axiom_text_serialize_start_part( axiom_text_t * om_text, const axutil_env_t * env, axiom_output_t * om_output) { axis2_char_t *namespace_uri = NULL; axis2_char_t *prefix = NULL; const axis2_char_t *local_name = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); local_name = "Include"; om_text->ns = axiom_namespace_create(env, "http://www.w3.org/2004/08/xop/include", "xop"); if(om_text->ns) { namespace_uri = axiom_namespace_get_uri(om_text->ns, env); if(namespace_uri) { prefix = axiom_namespace_get_prefix(om_text->ns, env); if(prefix) { axiom_output_write(om_output, env, AXIOM_ELEMENT, 3, local_name, namespace_uri, prefix); } else { axiom_output_write(om_output, env, AXIOM_ELEMENT, 2, local_name, namespace_uri); } } else { axiom_output_write(om_output, env, AXIOM_ELEMENT, 1, local_name); } } else { axiom_output_write(om_output, env, AXIOM_TEXT, 1, local_name); } if(om_text->om_attribute) { axiom_attribute_serialize(om_text->om_attribute, env, om_output); } if(om_text->ns) { axiom_namespace_serialize(om_text->ns, env, om_output); axiom_namespace_free(om_text->ns, env); om_text->ns = NULL; } return AXIS2_SUCCESS; }
axis2_char_t* AXIS2_CALL sandesha2_rm_elements_get_addr_ns_val_from_env( const axutil_env_t *env, axiom_soap_envelope_t *soap_envelope, axis2_char_t *action) { axiom_soap_header_t *soap_header = NULL; AXIS2_PARAM_CHECK(env->error, soap_envelope, NULL); AXIS2_PARAM_CHECK(env->error, action, NULL); soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if(soap_header) { axutil_array_list_t *headers = NULL; axiom_node_t *soap_header_node = NULL; axiom_element_t *soap_header_element = NULL; axiom_namespace_t *addr_ns = NULL; headers = axiom_soap_header_get_header_blocks_with_namespace_uri( soap_header, env, AXIS2_WSA_NAMESPACE); if(headers && 0 < axutil_array_list_size(headers, env)) { axutil_array_list_free(headers, env); return AXIS2_WSA_NAMESPACE; } headers = axiom_soap_header_get_header_blocks_with_namespace_uri( soap_header, env, AXIS2_WSA_NAMESPACE_SUBMISSION); if(headers && 0 < axutil_array_list_size(headers, env)) { axutil_array_list_free(headers, env); return AXIS2_WSA_NAMESPACE_SUBMISSION; } if(headers) axutil_array_list_free(headers, env); soap_header_node = axiom_soap_header_get_base_node(soap_header, env); soap_header_element = axiom_node_get_data_element(soap_header_node, env); addr_ns = axiom_element_get_namespace(soap_header_element, env, soap_header_node); if(addr_ns) { axis2_char_t *str_addr_ns = axiom_namespace_get_uri(addr_ns, env); return str_addr_ns; } } return NULL; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_serialize_attribute( axiom_text_t * om_text, const axutil_env_t * env, axiom_output_t * om_output, axiom_attribute_t * om_attribute) { axiom_xml_writer_t *xml_writer = NULL; axiom_namespace_t *om_namespace = NULL; axis2_char_t *namespace_uri = NULL; axis2_char_t *prefix = NULL; axis2_char_t *attribute_local_name = NULL; axis2_char_t *attribute_value = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); (void)om_output; xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); om_namespace = axiom_namespace_create(env, "", ""); namespace_uri = axiom_namespace_get_uri(om_text->ns, env); attribute_local_name = axiom_attribute_get_localname(om_attribute, env); if(om_namespace) { prefix = axiom_namespace_get_prefix(om_text->ns, env); attribute_value = axiom_attribute_get_value(om_attribute, env); if(prefix) { axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value); } else { axiom_xml_writer_write_attribute_with_namespace(xml_writer, env, attribute_local_name, attribute_value, namespace_uri); } } else { axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value); } axiom_namespace_free(om_namespace, env); return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_attribute_serialize( axiom_attribute_t * attribute, const axutil_env_t * env, axiom_output_t * om_output) { int status = AXIS2_SUCCESS; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE); if(attribute->ns) { axis2_char_t *uri = NULL; axis2_char_t *prefix = NULL; uri = axiom_namespace_get_uri(attribute->ns, env); prefix = axiom_namespace_get_prefix(attribute->ns, env); if((uri) && (NULL != prefix) && (axutil_strcmp(prefix, "") != 0)) { status = axiom_output_write(om_output, env, AXIOM_ATTRIBUTE, 4, axutil_string_get_buffer(attribute-> localname, env), axutil_string_get_buffer( attribute-> value, env), uri, prefix); } else if(uri) { status = axiom_output_write(om_output, env, AXIOM_ATTRIBUTE, 3, axutil_string_get_buffer(attribute-> localname, env), axutil_string_get_buffer( attribute-> value, env), uri); } } else { status = axiom_output_write(om_output, env, AXIOM_ATTRIBUTE, 2, axutil_string_get_buffer( attribute-> localname, env), axutil_string_get_buffer(attribute->value, env)); } return status; }
AXIS2_EXTERN int AXIS2_CALL axiom_soap_body_get_soap_version( axiom_soap_body_t * soap_body, const axutil_env_t * env) { axiom_element_t *body_ele = NULL; axiom_namespace_t *om_ns = NULL; axis2_char_t *uri = NULL; if(!soap_body->om_ele_node) { return AXIS2_FAILURE; } body_ele = axiom_node_get_data_element(soap_body->om_ele_node, env); if(!body_ele) { return AXIS2_FAILURE; } om_ns = axiom_element_get_namespace(body_ele, env, soap_body->om_ele_node); if(!om_ns) { return AXIS2_FAILURE; } uri = axiom_namespace_get_uri(om_ns, env); if(uri) { if(axutil_strcmp(uri, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI) == 0) { return AXIOM_SOAP11; } else if(axutil_strcmp(uri, AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI) == 0) { return AXIOM_SOAP12; } } return AXIS2_FAILURE; }
void wsf_util_pack_attachments ( axutil_env_t *env, axiom_node_t *node, VALUE attach_ht, int enable_mtom, char *default_cnt_type) { axiom_element_t *node_element = NULL; axiom_element_t *child_element = NULL; axiom_child_element_iterator_t *child_element_ite = NULL; axiom_node_t *child_node = NULL; int attachment_done = 0; axis2_char_t *element_localname = NULL; axiom_namespace_t *element_namespace = NULL; axis2_char_t *namespace_uri = NULL; if (!node) return; if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { node_element = axiom_node_get_data_element(node, env); if (node_element) { child_element_ite = axiom_element_get_child_elements(node_element, env, node); if (child_element_ite) { child_node = axiom_child_element_iterator_next(child_element_ite, env); attachment_done = 0; while (child_node && !attachment_done) { child_element = axiom_node_get_data_element(child_node, env); element_localname = axiom_element_get_localname(child_element, env); if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0)) { element_namespace = axiom_element_get_namespace(child_element, env, child_node); if (element_namespace) { namespace_uri = axiom_namespace_get_uri(element_namespace, env); if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0)) { axis2_char_t *cnt_type = NULL; axis2_char_t *content_type = NULL; axis2_char_t *href = NULL; axis2_char_t* pos = NULL; cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE); content_type = !cnt_type ? default_cnt_type : cnt_type; href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF); if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:"))) { axis2_char_t* cid = NULL; VALUE content_tmp; void* content = NULL; unsigned int content_length = 0; cid = href + 4; content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid)); content_length = RSTRING(content_tmp)->len; content = malloc(sizeof (char) * content_length); memcpy (content, (const void*)STR2CSTR(content_tmp), content_length); if (content) { void *data_buffer = NULL; axiom_data_handler_t *data_handler = NULL; axiom_node_t *text_node = NULL; axiom_text_t *text = NULL; data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length); if (data_buffer) { memcpy (data_buffer, content, content_length); data_handler = axiom_data_handler_create (env, NULL, content_type); if (data_handler) { axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length); text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node); if (enable_mtom == AXIS2_FALSE) axiom_text_set_optimize (text, env, AXIS2_FALSE); axiom_node_detach (child_node, env); } } attachment_done = 1; } } } } } child_node = axiom_child_element_iterator_next(child_element_ite, env); } } } } // Process child nodes child_node = axiom_node_get_first_child(node, env); while (child_node) { wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type); child_node = axiom_node_get_next_sibling(child_node, env); } }
/** * Traverse thru the node and its children. Check if the element has the * given qname and has a id attribute equal to the given value. * @param env Environment. MUST NOT be NULL, * @param node the node to be searched * @param e_name element name * @param e_ns element namespace. If NULL doesn't consider the namespaces * @param attr_name the attribute name of the node * @param attr_val the attribute value of the node * @param attr_ns the attribute namespace. If NULL doesn't consider namespaces. * @return the node if found, else NULL */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_axiom_get_first_node_by_name_and_attr_val( const axutil_env_t *env, axiom_node_t *node, axis2_char_t *e_name, axis2_char_t *e_ns, axis2_char_t *attr_name, axis2_char_t *attr_val, axis2_char_t *attr_ns) { axis2_char_t *attribute_value = NULL; axis2_char_t *localname = NULL; axiom_namespace_t *nmsp = NULL; axiom_element_t *element = NULL; axis2_bool_t element_match = AXIS2_FALSE; axiom_node_t *temp_node = NULL; if(axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return NULL; } element = axiom_node_get_data_element(node, env); localname = axiom_element_get_localname(element, env); if(localname && !axutil_strcmp(localname, e_name)) { element_match = AXIS2_TRUE; if(e_ns) { nmsp = axiom_element_get_namespace(element, env, node); if(nmsp) { axis2_char_t *namespacea = NULL; namespacea = axiom_namespace_get_uri(nmsp, env); if(axutil_strcmp(e_ns, namespacea)) { element_match = AXIS2_FALSE; } } } /* element is ok. So, we have to check the attribute value */ if(element_match) { if(attr_ns) { axiom_attribute_t *attr = NULL; axutil_qname_t *qname = axutil_qname_create(env, attr_name, attr_ns, NULL); attr = axiom_element_get_attribute(element, env, qname); if(attr) { attribute_value = axiom_attribute_get_value(attr, env); } axutil_qname_free(qname, env); } else { attribute_value = axiom_element_get_attribute_value_by_name( element, env, attr_name); } } if (attribute_value && !axutil_strcmp(attribute_value, attr_val)) { return node; } } /* Doesn't match? Get the children and search */ temp_node = axiom_node_get_first_element(node, env); while (temp_node) { axiom_node_t *res_node = NULL; res_node = oxs_axiom_get_first_node_by_name_and_attr_val( env, temp_node, e_name, e_ns, attr_name, attr_val, attr_ns); if (res_node) { return res_node; } temp_node = axiom_node_get_next_sibling(temp_node, env); } return NULL; }
/** * Traverse thru the node and its descendents. Check if the node has a particular attribute with * name as in @attr and namespace as in @ns. Returns the attribute value. * @param env Environment. MUST NOT be NULL, * @param node the node to be searched * @param attribute_name the attribute name of the node * @param ns namespace of the attribute * @return the attribute value if found, else NULL */ AXIS2_EXTERN axis2_char_t* AXIS2_CALL oxs_axiom_get_attribute_value_of_node_by_name( const axutil_env_t *env, axiom_node_t *node, axis2_char_t *attribute_name, axis2_char_t *ns_uri) { axis2_char_t *found_val = NULL; axiom_element_t *ele = NULL; axutil_hash_t *attr_list = NULL; axutil_hash_index_t *hi = NULL; ele = axiom_node_get_data_element(node, env); /* Get attribute list of the element */ attr_list = axiom_element_extract_attributes(ele, env, node); if(!attr_list) { return NULL; } /* namespace uri can be NULL. In that case, use empty string */ if(!ns_uri) { ns_uri = ""; } /* Traverse thru all the attributes. If both localname and the nsuri matches return the val */ for (hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi)) { void *attr = NULL; axiom_attribute_t *om_attr = NULL; axutil_hash_this(hi, NULL, NULL, &attr); if (attr) { axis2_char_t *this_attr_name = NULL; axis2_char_t *this_attr_ns_uri = NULL; axiom_namespace_t *attr_ns = NULL; om_attr = (axiom_attribute_t*)attr; this_attr_name = axiom_attribute_get_localname(om_attr, env); attr_ns = axiom_attribute_get_namespace(om_attr, env); if(attr_ns) { this_attr_ns_uri = axiom_namespace_get_uri(attr_ns, env); } else { this_attr_ns_uri = ""; } if((!axutil_strcmp(attribute_name, this_attr_name)) && (!axutil_strcmp(ns_uri, this_attr_ns_uri))) { /* Got it !!! */ found_val = axiom_attribute_get_value(om_attr, env); AXIS2_FREE(env->allocator, hi); break; } } } for(hi = axutil_hash_first(attr_list, env); hi; hi = axutil_hash_next(env, hi)) { void *val = NULL; axutil_hash_this(hi, NULL, NULL, &val); if (val) { axiom_attribute_free((axiom_attribute_t *)val, env); val = NULL; } } axutil_hash_free(attr_list, env); attr_list = NULL; return found_val; }
static void ngx_squ_xml_parse_children(squ_State *l, axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_elem) { int n; char *uri, *prefix, *name, *text, *value; axiom_node_t *node; axutil_hash_t *attrs; axiom_element_t *elem; ngx_squ_thread_t *thr; axiom_attribute_t *attr; axiom_namespace_t *ns; axutil_hash_index_t *hi; axiom_child_element_iterator_t *it; thr = ngx_squ_thread(l); ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse children"); it = axiom_element_get_child_elements(parent_elem, env, parent); if (it == NULL) { return; } n = 1; do { node = axiom_child_element_iterator_next(it, env); elem = axiom_node_get_data_element(node, env); name = axiom_element_get_localname(elem, env); squ_createtable(l, 2, 4); squ_pushstring(l, name); squ_setfield(l, -2, "name"); ns = axiom_element_get_namespace(elem, env, node); if (ns != NULL) { uri = axiom_namespace_get_uri(ns, env); if (uri != NULL) { squ_pushstring(l, uri); squ_setfield(l, -2, "uri"); } prefix = axiom_namespace_get_prefix(ns, env); if (prefix != NULL) { squ_pushstring(l, prefix); squ_setfield(l, -2, "prefix"); } } attrs = axiom_element_get_all_attributes(elem, env); if (attrs != NULL) { squ_newtable(l); hi = axutil_hash_first(attrs, env); do { if (hi == NULL) { break; } axutil_hash_this(hi, NULL, NULL, (void **) &attr); name = axiom_attribute_get_localname(attr, env); value = axiom_attribute_get_value(attr, env); squ_pushstring(l, value); squ_setfield(l, -2, name); hi = axutil_hash_next(env, hi); } while (1); squ_setfield(l, -2, "attributes"); } text = axiom_element_get_text(elem, env, node); if (text != NULL) { squ_pushstring(l, text); squ_setfield(l, -2, "text"); } else { squ_newtable(l); ngx_squ_xml_parse_children(l, env, node, elem); squ_setfield(l, -2, "children"); } squ_setfield(l, -2, name); squ_getfield(l, -1, name); squ_rawseti(l, -2, n++); } while (axiom_child_element_iterator_has_next(it, env) == AXIS2_TRUE); }
AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL axiom_soap_header_get_header_blocks_with_namespace_uri( axiom_soap_header_t * soap_header, const axutil_env_t * env, const axis2_char_t * ns_uri) { axutil_array_list_t *header_block_list = NULL; axutil_hash_index_t *hash_index = NULL; axiom_soap_header_block_t *header_block = NULL; axiom_node_t *header_block_om_node = NULL; axiom_element_t *header_block_om_ele = NULL; axiom_namespace_t *ns = NULL; axis2_char_t *hb_namespace_uri = NULL; int found = 0; void *hb = NULL; AXIS2_PARAM_CHECK(env->error, ns_uri, NULL); if(!(soap_header->header_blocks)) { return NULL; } header_block_list = axutil_array_list_create(env, 10); if(!header_block_list) { return NULL; } for(hash_index = axutil_hash_first(soap_header->header_blocks, env); hash_index; hash_index = axutil_hash_next(env, hash_index)) { axutil_hash_this(hash_index, NULL, NULL, &hb); if(hb) { header_block = (axiom_soap_header_block_t *)hb; header_block_om_node = axiom_soap_header_block_get_base_node(header_block, env); if(header_block_om_node) { header_block_om_ele = (axiom_element_t *)axiom_node_get_data_element( header_block_om_node, env); if(header_block_om_ele) { ns = axiom_element_get_namespace(header_block_om_ele, env, header_block_om_node); if(ns) { hb_namespace_uri = axiom_namespace_get_uri(ns, env); if(axutil_strcmp(hb_namespace_uri, ns_uri) == 0) { axutil_array_list_add(header_block_list, env, header_block); found++; } } } } hb = NULL; header_block = NULL; header_block_om_ele = NULL; header_block_om_node = NULL; ns = NULL; hb_namespace_uri = NULL; } } if(found > 0) { return header_block_list; } else { axutil_array_list_free(header_block_list, env); } return NULL; }
axis2_status_t wsclient_get_attachment (const axutil_env_t *env, axiom_node_t *node, axis2_char_t *base_dir, int is_mtom_enabled) { axiom_node_t *child_node = NULL; axiom_element_t *element; if (!node || !env) return AXIS2_FAILURE; if (axiom_node_get_node_type (node, env) == AXIOM_ELEMENT) { axis2_char_t *local_name; axiom_namespace_t *ns; axis2_char_t *ns_uri; element = (axiom_element_t *) axiom_node_get_data_element (node, env); local_name = axiom_element_get_localname (element, env); if (local_name) { if (!strcmp (local_name, "Include")) { ns = axiom_element_get_namespace(element, env, node); if (ns && (ns_uri = axiom_namespace_get_uri (ns, env)) && (!strcmp (ns_uri, "http://www.w3.org/2004/08/xop/include"))) { axiom_node_t *text_node; axiom_text_t *text; axiom_data_handler_t *data_handler; axis2_char_t *write_file = NULL; axis2_char_t *pwd; axis2_char_t *relative; axutil_qname_t *attribute_qname; axiom_attribute_t *href = NULL; axis2_char_t *cid_value; #if defined(WIN32) char path[256]; GetCurrentDirectory(256, path); pwd = path; #else pwd = AXIS2_GETENV ("PWD"); #endif relative = wsclient_get_relative_path (env, pwd, base_dir); attribute_qname = axutil_qname_create (env, "href", NULL, NULL); if (attribute_qname) href = axiom_element_get_attribute (element, env, attribute_qname); else return AXIS2_FAILURE; if (href) { cid_value = axiom_attribute_get_value (href, env); cid_value = cid_value + 4; } else return AXIS2_FAILURE; axiom_attribute_set_value (href, env, relative); text_node = axiom_node_get_first_child (node, env); if (text_node && (axiom_node_get_node_type (text_node, env) == AXIOM_TEXT)) { text = (axiom_text_t *) axiom_node_get_data_element (text_node, env); data_handler = axiom_text_get_data_handler(text, env); if (data_handler && text) { if (base_dir) { int len = 0; len = strlen (base_dir); if (base_dir [len - 1] != '/') strcat (base_dir, "/"); if (cid_value) write_file = strcat (base_dir, cid_value); else return AXIS2_FAILURE; } if (write_file) axiom_data_handler_set_file_name(data_handler, env, write_file); axiom_data_handler_write_to(data_handler, env); } } } } } child_node = axiom_node_get_first_element (node, env); while (child_node) { wsclient_get_attachment (env, child_node, base_dir, is_mtom_enabled); child_node = axiom_node_get_next_sibling (child_node, env); } } else return AXIS2_FAILURE; return AXIS2_SUCCESS; }
axis2_status_t wsclient_set_attachment (const axutil_env_t *env, axiom_node_t *node, axis2_char_t *base_dir, int is_mtom_enabled) { axiom_node_t *child_node = NULL; axiom_element_t *element; if (!node || !env) return AXIS2_FAILURE; if (axiom_node_get_node_type (node, env) == AXIOM_ELEMENT) { axis2_char_t *local_name; axiom_namespace_t *ns; axis2_char_t *ns_uri; element = (axiom_element_t *) axiom_node_get_data_element (node, env); local_name = axiom_element_get_localname (element, env); if (local_name) { if (!strcmp (local_name, "Include")) { ns = axiom_element_get_namespace(element, env, node); if (ns && (ns_uri = axiom_namespace_get_uri (ns, env)) && (!strcmp (ns_uri, "http://www.w3.org/2004/08/xop/include"))) { axis2_char_t *file_path; axiom_data_handler_t *data_handler; axiom_text_t *data_text; axiom_node_t *data_node; axiom_node_t *parent; axutil_uri_t *file_uri = NULL; axutil_uri_t *base_uri = NULL; axutil_uri_t *real_uri = NULL; axis2_char_t *real_path = NULL; parent = axiom_node_get_parent (node, env); axiom_node_detach (node, env); file_path = axiom_element_get_attribute_value_by_name (element, env, "href"); file_uri = axutil_uri_parse_string (env, file_path); if (base_dir) base_uri = axutil_uri_parse_string (env, base_dir); else return AXIS2_FAILURE; if (base_uri) real_uri = axutil_uri_parse_relative (env, base_uri, file_path); else return AXIS2_FAILURE; if (real_uri) real_path = axutil_uri_to_string (real_uri, env, 1); else return AXIS2_FAILURE; if (real_path) data_handler = axiom_data_handler_create (env, real_path, "image/jpeg"); else return AXIS2_FAILURE; if (data_handler) data_text = axiom_text_create_with_data_handler (env, parent, data_handler, &data_node); else return AXIS2_FAILURE; if (data_text) { if (!is_mtom_enabled) axiom_text_set_optimize (data_text, env, AXIS2_FALSE); } } } } child_node = axiom_node_get_first_element (node, env); while (child_node) { wsclient_set_attachment (env, child_node, base_dir, is_mtom_enabled); child_node = axiom_node_get_next_sibling (child_node, env); } } else return AXIS2_FAILURE; return AXIS2_SUCCESS; }