/* * This method invokes the right service method */ axiom_node_t *AXIS2_CALL mul_invoke( axis2_svc_skeleton_t * svc_skeleton, const axutil_env_t * env, axiom_node_t * node, axis2_msg_ctx_t * msg_ctx) { /* Depending on the function name invoke the * corresponding mul method */ if (node) { if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { axiom_element_t *element = NULL; element = (axiom_element_t *) axiom_node_get_data_element(node, env); if (element) { axis2_char_t *op_name = axiom_element_get_localname(element, env); if (op_name) { if (axutil_strcmp(op_name, "mul") == 0) return axis2_mul_mul(env, node); } } } } printf("Math service ERROR: invalid OM parameters in request\n"); /** Note: return a SOAP fault here */ return node; }
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL rp_algorithmsuite_builder_build( const axutil_env_t *env, axiom_node_t *node, axiom_element_t *element) { rp_algorithmsuite_t *algorithmsuite = NULL; axiom_node_t *child_node = NULL; axiom_node_t *algo_node = NULL; axiom_element_t *algo_element = NULL; neethi_assertion_t *assertion = NULL; (void)element; algorithmsuite = rp_algorithmsuite_create(env); child_node = axiom_node_get_first_element(node, env); if(child_node) { algo_node = axiom_node_get_first_element(child_node, env); if(!algo_node) { return NULL; } } else { return NULL; } if(axiom_node_get_node_type(algo_node, env) == AXIOM_ELEMENT) { algo_element = (axiom_element_t *)axiom_node_get_data_element(algo_node, env); if(algo_element) { axis2_status_t status = AXIS2_FAILURE; axis2_char_t *algosuite_string = NULL; algosuite_string = axiom_element_get_localname(algo_element, env); if(!algosuite_string) { return NULL; } status = rp_algorithmsuite_set_algosuite(algorithmsuite, env, algosuite_string); if(AXIS2_FAILURE == status) { return NULL; } assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_algorithmsuite_free, algorithmsuite, ASSERTION_TYPE_ALGORITHM_SUITE); return assertion; } else return NULL; } else return NULL; }
/** Find the most recent named node. * @param env * @param root_node * @param local_name * @param node_time return parameter, is set the time timePosition of the node. * @return the most recent. */ axiom_node_t *sp_latest_named( const axutil_env_t *env, axiom_node_t *root_node, const axis2_char_t *local_name, time_t *node_time ) { axiom_node_t *ret_node = NULL; axis2_char_t last_time[MAX_LAST_TIMELEN]; strcpy(last_time, "0"); axiom_children_iterator_t *chit = axiom_children_iterator_create (env, axiom_node_get_first_child(root_node, env)); if (NULL != chit) { axiom_node_t *curr_node = NULL; while (axiom_children_iterator_has_next(chit, env)) { curr_node = axiom_children_iterator_next(chit, env); if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT) { axiom_element_t * el = (axiom_element_t *) axiom_node_get_data_element (curr_node, env); axis2_char_t *el_name = axiom_element_get_localname( el, env); if ( 0 == strncasecmp(local_name, el_name, strlen(local_name))) { axiom_node_t *t_node = rp_find_named_child(env, curr_node, "timePosition", 1); const axis2_char_t *txt = sp_get_text_el(t_node, env); if (strncmp(last_time, txt, strlen(last_time)) < 0) { if (strlen(txt) >= MAX_LAST_TIMELEN) { rp_log_error(env, "*WARNING sp_util.c(%s %d):" " timePosition text too long (%d)\n", __FILE__, __LINE__, strlen(txt)); } strncpy(last_time, txt, MAX_LAST_TIMELEN-1); ret_node = curr_node; } } } // if } // while axiom_children_iterator_free (chit, env); } *node_time = sp_parse_time_str(last_time); return ret_node; }
axutil_array_list_t* AXIS2_CALL remote_registry_comment_load_from_feed( const axutil_env_t *env, axis2_char_t *buffer) { axiom_children_iterator_t *node_it = NULL; axiom_node_t *feed_node = NULL; axiom_element_t *feed_ele = NULL; axutil_array_list_t *comment_list = NULL; feed_node = axiom_node_create_from_buffer(env, buffer); if(!feed_node) { return NULL; } comment_list = axutil_array_list_create(env, 10); if(!comment_list) { return NULL; } feed_ele = axiom_node_get_data_element(feed_node, env); node_it = axiom_element_get_children(feed_ele, env, feed_node); /* iterate all the children */ while(axiom_children_iterator_has_next(node_it, env)) { axiom_node_t *child = NULL; axiom_element_t *child_ele = NULL; axis2_char_t *local_name = NULL; child = axiom_children_iterator_next(node_it, env); if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT) { continue; } child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env); local_name = axiom_element_get_localname(child_ele, env); /* retriving the attribute one by one */ if(!axutil_strcmp(local_name, "entry")) { remote_registry_comment_t *comment = NULL; comment = remote_registry_comment_create_from_entry_node(env, child); axutil_array_list_add(comment_list, env, comment); } } return comment_list; }
static int ngx_squ_xml_parse(squ_State *l) { char *name; ngx_str_t xml; axiom_node_t *node; axutil_env_t *env; axutil_log_t *log; axutil_error_t *error; axiom_element_t *elem; axiom_document_t *doc; ngx_squ_thread_t *thr; axutil_allocator_t *a; axiom_xml_reader_t *reader; axiom_stax_builder_t *builder; thr = ngx_squ_thread(l); ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml parse"); xml.data = (u_char *) squL_checklstring(l, -1, &xml.len); squ_createtable(l, 2, 2); a = ngx_squ_axis2c_allocator_create(thr); log = ngx_squ_axis2c_log_create(thr); error = axutil_error_create(a); env = axutil_env_create_with_error_log(a, error, log); reader = axiom_xml_reader_create_for_memory(env, xml.data, xml.len, NULL, AXIS2_XML_PARSER_TYPE_BUFFER); builder = axiom_stax_builder_create(env, reader); doc = axiom_stax_builder_get_document(builder, env); node = axiom_document_get_root_element(doc, env); if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return 1; } elem = axiom_node_get_data_element(node, env); name = axiom_element_get_localname(elem, env); squ_newtable(l); ngx_squ_xml_parse_children(l, env, node, elem); squ_setfield(l, -2, name); return 1; }
AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL rp_layout_builder_build( const axutil_env_t *env, axiom_node_t *node, axiom_element_t *element) { rp_layout_t *layout = NULL; axiom_node_t *child_node = NULL; axiom_node_t *layout_node = NULL; axiom_element_t *layout_element = NULL; neethi_assertion_t *assertion = NULL; layout = rp_layout_create(env); child_node = axiom_node_get_first_element(node, env); if(child_node) { layout_node = axiom_node_get_first_element(child_node, env); if(!layout_node) { return NULL; } } else { return NULL; } if(axiom_node_get_node_type(layout_node, env) == AXIOM_ELEMENT) { layout_element = (axiom_element_t *)axiom_node_get_data_element(layout_node, env); if(layout_element) { axis2_char_t *local_name = NULL; local_name = axiom_element_get_localname(layout_element, env); if(!local_name) return NULL; rp_layout_set_value(layout, env, local_name); assertion = neethi_assertion_create_with_args(env, (AXIS2_FREE_VOID_ARG)rp_layout_free, layout, ASSERTION_TYPE_LAYOUT); return assertion; } else return NULL; } else return NULL; }
/** * Find the first child of 'root_node' with a matching 'local_name', * non-recursive. * * @param env * @param root_node * @param local_name * @param search_str * @return the first matching child of 'root_node', or NULL if none found. */ axiom_node_t *rp_find_named_node_nr( const axutil_env_t * env, axiom_node_t *root_node, const axis2_char_t *local_name, const axis2_char_t *search_str) { axiom_node_t *found_node = NULL; axiom_children_iterator_t *chit = axiom_children_iterator_create (env, root_node); if (NULL != chit) { axiom_node_t *curr_node = NULL; while (axiom_children_iterator_has_next(chit, env)) { curr_node = axiom_children_iterator_next(chit, env); if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT) { axiom_element_t * el = (axiom_element_t *) axiom_node_get_data_element (curr_node, env); axis2_char_t *el_name = axiom_element_get_localname( el, env); if ( 0 == strncasecmp( local_name, el_name, strlen(local_name) ) ) { if ( search_str ) { axis2_char_t *txt = axiom_element_get_text (el, env, curr_node); if ( 0 == strncmp(search_str, txt, strlen(search_str))) { found_node = curr_node; break; } } else { found_node = curr_node; break; } } } // if } // while axiom_children_iterator_free (chit, env); } return found_node; }
AXIS2_EXTERN int AXIS2_CALL remote_registry_util_get_ratings_from_feed( const axutil_env_t *env, axis2_char_t *feed) { axiom_node_t *entry_node; axiom_children_iterator_t *entry_it = NULL; axiom_element_t *entry_ele = NULL; int rating = -1; entry_node = axiom_node_create_from_buffer(env, feed); if(!entry_node) { return -1; } entry_ele = axiom_node_get_data_element(entry_node, env); entry_it = axiom_element_get_children(entry_ele, env, entry_node); while(axiom_children_iterator_has_next(entry_it, env)) { axiom_node_t *child = NULL; axiom_element_t *child_ele = NULL; axis2_char_t *local_name = NULL; child = axiom_children_iterator_next(entry_it, env); if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT) { continue; } child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env); local_name = axiom_element_get_localname(child_ele, env); if(!axutil_strcmp(local_name, "AverageRating")) { axis2_char_t *rating_str = NULL; rating_str = axiom_element_get_text(child_ele, env, child); rating = atoi(rating_str); break; } } return rating; }
AXIS2_EXTERN int AXIS2_CALL saml_subject_query_build(saml_subject_query_t* subject_query, axiom_node_t *node, const axutil_env_t *env) { axiom_element_t *element = NULL; axiom_child_element_iterator_t *iterator = NULL; axiom_node_t *child_node = NULL; if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return AXIS2_FAILURE; } if ((element = axiom_node_get_data_element(node, env)) == NULL) { return AXIS2_FAILURE; } iterator = axiom_element_get_child_elements(element, env, node); if(iterator) { while(axiom_child_element_iterator_has_next(iterator, env)) { child_node = axiom_child_element_iterator_next(iterator, env); element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_SUBJECT))) { if(subject_query->subject) return saml_subject_build(subject_query->subject, child_node, env); else return AXIS2_FAILURE; /*subject query saml subject does not exist*/ } } return AXIS2_SUCCESS; } else return AXIS2_FAILURE; }
axis2_char_t * get_policy_ref( axiom_node_t * node, const axutil_env_t * env) { axiom_element_t *policy_element = NULL; axiom_children_iterator_t *children_iter = NULL; axiom_node_t *child_node = NULL; axutil_qname_t *qname = NULL; axis2_char_t *value = NULL; axis2_char_t *val = NULL; axiom_attribute_t *attr = NULL; policy_element = (axiom_element_t *) axiom_node_get_data_element(node, env); children_iter = axiom_element_get_children(policy_element, env, node); while (axiom_children_iterator_has_next(children_iter, env)) { child_node = axiom_children_iterator_next(children_iter, env); if (axiom_node_get_node_type(child_node, env) == AXIOM_ELEMENT) { policy_element = (axiom_element_t *) axiom_node_get_data_element(child_node, env); if (axutil_strcmp (axiom_element_get_localname(policy_element, env), "PolicyReference") == 0) { qname = axutil_qname_create(env, "URI", NULL, NULL); attr = axiom_element_get_attribute(policy_element, env, qname); if (attr) { value = axiom_attribute_get_value(attr, env); val = axutil_string_substring_starting_at(value, 1); return val; } } } } return NULL; }
/** Excecute 'func' on all immediate children of 'root_node' with 'local_name'. * @param env * @param root_node * @param local_name * @param func * Takes 3 args: const axutil_env_t * env, axiom_node_t *node, void *arg3 * node is the ptr to the node matching 'local_name', arg3 is func_arg. * The function should return zero if successful, non-zero otherwise. * @param func_arg passed as the third arg to the function. * @return the number of times func returned 0. */ int sp_func_at_nodes( const axutil_env_t *env, axiom_node_t *root_node, const axis2_char_t *local_name, int (* func)(const axutil_env_t * env, axiom_node_t *node, void *arg3), void *func_arg ) { int num_executed = 0; axiom_children_iterator_t *chit = axiom_children_iterator_create (env, root_node); if (NULL != chit) { axiom_node_t *curr_node = NULL; while (axiom_children_iterator_has_next(chit, env)) { curr_node = axiom_children_iterator_next(chit, env); if (axiom_node_get_node_type(curr_node, env) == AXIOM_ELEMENT) { axiom_element_t * el = (axiom_element_t *) axiom_node_get_data_element (curr_node, env); axis2_char_t *el_name = axiom_element_get_localname( el, env); if ( 0 == strncasecmp(local_name, el_name, strlen(local_name))) { if (0 == func(env, curr_node, func_arg)) num_executed++; } } // if } // while axiom_children_iterator_free (chit, env); } return num_executed; }
AXIS2_EXTERN int AXIS2_CALL saml_attr_query_build(saml_attr_query_t* attribute_query, axiom_node_t *node, const axutil_env_t *env) { axutil_hash_t *attr_hash = NULL; axiom_element_t *element = NULL; axutil_hash_index_t *hi = NULL; axiom_child_element_iterator_t *iterator = NULL; axiom_node_t *child_node; saml_attr_desig_t *attr_desig = NULL; if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return AXIS2_FAILURE; } if ((element = axiom_node_get_data_element(node, env)) == NULL) { return AXIS2_FAILURE; } /* initialize the attributes */ attr_hash = axiom_element_get_all_attributes(element, env); /*One resource attribute relate to the attibute query*/ for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) { void *v = NULL; axutil_hash_this(hi, NULL, NULL, &v); if (v) { axis2_char_t *attr_val = NULL; axiom_attribute_t *attr = (axiom_attribute_t*)v; attr_val = axiom_attribute_get_value(attr, env); if(!axutil_strcmp(axiom_attribute_get_localname(attr, env),SAML_RESOURCE)) { attribute_query->resource = attr_val; break; } } } iterator = axiom_element_get_child_elements(element, env, node); if(iterator) { while(axiom_child_element_iterator_has_next(iterator, env)) { child_node = axiom_child_element_iterator_next(iterator, env); element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_SUBJECT))) { if(attribute_query->subject) saml_subject_build(attribute_query->subject, child_node, env); } else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_ATTRIBUTE_DESIGNATOR))) { /*attr_desig = saml_attr_desig_create(env); */ attr_desig = (saml_attr_desig_t*)AXIS2_MALLOC(env->allocator, sizeof(saml_attr_desig_t)); if( AXIS2_SUCCESS == saml_attr_desig_build(attr_desig, child_node, env)) { axutil_array_list_add(attribute_query->attr_desigs,env, attr_desig); } } } return AXIS2_SUCCESS; } else return AXIS2_FAILURE; }
axis2_status_t AXIS2_CALL adb_SnakeException_deserialize( adb_SnakeException_t* _SnakeException, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _SnakeException, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for SnakeException : " "NULL elemenet can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); /* * building message element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "message", NULL, NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("message", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { status = adb_SnakeException_set_message(_SnakeException, env, text_value); } else { /* * axis2_qname_t *qname = NULL; * axiom_attribute_t *the_attri = NULL; * * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi"); * the_attri = axiom_element_get_attribute(current_element, env, qname); */ /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */ axiom_attribute_t *the_attri = NULL; axis2_char_t *attrib_text = NULL; axutil_hash_t *attribute_hash = NULL; attribute_hash = axiom_element_get_all_attributes(current_element, env); attrib_text = NULL; if(attribute_hash) { axutil_hash_index_t *hi; void *val; const void *key; for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance")) { the_attri = (axiom_attribute_t*)val; break; } } } if(the_attri) { attrib_text = axiom_attribute_get_value(the_attri, env); } else { /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */ attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil"); } if(attrib_text && 0 == axutil_strcmp(attrib_text, "1")) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element message"); status = AXIS2_FAILURE; } else { /* after all, we found this is a empty string */ status = adb_SnakeException_set_message(_SnakeException, env, ""); } } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for message "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
axis2_status_t axis2_addr_in_extract_addr_params( const axutil_env_t * env, axiom_soap_header_t * soap_header, axis2_msg_info_headers_t ** msg_info_headers_p, axutil_array_list_t * addr_headers, const axis2_char_t * addr_ns_str, axis2_msg_ctx_t * msg_ctx) { axutil_hash_t *header_block_ht = NULL; axutil_hash_index_t *hash_index = NULL; axis2_msg_info_headers_t *msg_info_headers = *(msg_info_headers_p); axis2_status_t status = AXIS2_SUCCESS; axis2_bool_t to_found = AXIS2_FALSE; axis2_bool_t reply_to_found = AXIS2_FALSE; axis2_bool_t fault_to_found = AXIS2_FALSE; axis2_bool_t action_found = AXIS2_FALSE; axis2_bool_t msg_id_found = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, soap_header, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, msg_info_headers_p, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, addr_headers, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, addr_ns_str, AXIS2_FAILURE); if (!msg_info_headers) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No messgae info header. Creating new"); msg_info_headers = axis2_msg_info_headers_create(env, NULL, NULL); if (!msg_info_headers) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MSG_INFO_HEADERS, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No message information headers available"); return AXIS2_FAILURE; } } header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); if (!header_block_ht) { return AXIS2_FAILURE; } /* Iterate thru header blocks */ for (hash_index = axutil_hash_first(header_block_ht, env); hash_index; hash_index = axutil_hash_next(env, hash_index)) { void *hb = NULL; axiom_soap_header_block_t *header_block = NULL; axiom_node_t *header_block_node = NULL; axiom_element_t *header_block_ele = NULL; axis2_char_t *ele_localname = NULL; axis2_endpoint_ref_t *epr = NULL; axis2_char_t *role = NULL; axutil_hash_this(hash_index, NULL, NULL, &hb); header_block = (axiom_soap_header_block_t *) hb; header_block_node = axiom_soap_header_block_get_base_node(header_block, env); header_block_ele = (axiom_element_t *) axiom_node_get_data_element(header_block_node, env); ele_localname = axiom_element_get_localname(header_block_ele, env); role = axiom_soap_header_block_get_role(header_block, env); if (role && !axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NONE)) { /* Role is none, no need of processing */ continue; } if (!axutil_strcmp(ele_localname, AXIS2_WSA_TO)) { /* Here the addressing epr overidde what ever already there in the message context */ epr = axis2_endpoint_ref_create(env, axiom_element_get_text (header_block_ele, env, header_block_node)); if (AXIS2_TRUE == to_found) { /* Duplicate To */ axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_TO, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; continue; } axis2_msg_info_headers_set_to(msg_info_headers, env, epr); axis2_addr_in_extract_to_epr_ref_params(env, epr, soap_header, addr_ns_str); axiom_soap_header_block_set_processed(header_block, env); to_found = AXIS2_TRUE; } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FROM)) { epr = axis2_msg_info_headers_get_from(msg_info_headers, env); if (!epr) { /* The address is not known now. Pass the empty string and fill this once the element under this is processed. */ epr = axis2_endpoint_ref_create(env, ""); axis2_msg_info_headers_set_from(msg_info_headers, env, epr); } axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); axiom_soap_header_block_set_processed(header_block, env); } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_REPLY_TO)) { epr = axis2_msg_info_headers_get_reply_to(msg_info_headers, env); if (reply_to_found == AXIS2_TRUE) { /* Duplicate Reply To */ axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_REPLY_TO, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; continue; } if (!epr) { epr = axis2_endpoint_ref_create(env, ""); axis2_msg_info_headers_set_reply_to(msg_info_headers, env, epr); } axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); axiom_soap_header_block_set_processed(header_block, env); reply_to_found = AXIS2_TRUE; } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_FAULT_TO)) { epr = axis2_msg_info_headers_get_fault_to(msg_info_headers, env); if (fault_to_found == AXIS2_TRUE) { /* Duplicate Fault To */ axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_FAULT_TO, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; axis2_msg_info_headers_set_fault_to(msg_info_headers, env, NULL); continue; } if (!epr) { epr = axis2_endpoint_ref_create(env, ""); axis2_msg_info_headers_set_fault_to(msg_info_headers, env, epr); } axis2_addr_in_extract_epr_information(env, header_block, epr, addr_ns_str); axiom_soap_header_block_set_processed(header_block, env); fault_to_found = AXIS2_TRUE; } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_MESSAGE_ID)) { axis2_char_t *text = NULL; if (msg_id_found == AXIS2_TRUE) { /* Duplicate Message ID */ axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_MESSAGE_ID, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; continue; } text = axiom_element_get_text(header_block_ele, env, header_block_node); axis2_msg_info_headers_set_in_message_id(msg_info_headers, env, text); axiom_soap_header_block_set_processed(header_block, env); msg_id_found = AXIS2_TRUE; } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_ACTION)) { axis2_char_t *text = NULL; if (action_found == AXIS2_TRUE) { /* Duplicate Action */ axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; continue; } text = axiom_element_get_text(header_block_ele, env, header_block_node); axis2_msg_info_headers_set_action(msg_info_headers, env, text); axiom_soap_header_block_set_processed(header_block, env); action_found = AXIS2_TRUE; } else if (!axutil_strcmp(ele_localname, AXIS2_WSA_RELATES_TO)) { axis2_char_t *address = NULL; axutil_qname_t *rqn = NULL; axiom_attribute_t *relationship_type = NULL; const axis2_char_t *relationship_type_default_value = NULL; const axis2_char_t *relationship_type_value = NULL; axis2_relates_to_t *relates_to = NULL; if (!axutil_strcmp(AXIS2_WSA_NAMESPACE_SUBMISSION, addr_ns_str)) { relationship_type_default_value = AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION; } else { relationship_type_default_value = AXIS2_WSA_ANONYMOUS_URL_SUBMISSION; } rqn = axutil_qname_create(env, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE, NULL, NULL); relationship_type = axiom_element_get_attribute(header_block_ele, env, rqn); if (!relationship_type) { relationship_type_value = AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE_SUBMISSION; } else { relationship_type_value = axiom_attribute_get_value(relationship_type, env); } address = axiom_element_get_text(header_block_ele, env, header_block_node); relates_to = axis2_relates_to_create(env, address, relationship_type_value); axis2_msg_info_headers_set_relates_to(msg_info_headers, env, relates_to); axiom_soap_header_block_set_processed(header_block, env); axutil_qname_free(rqn, env); } } /* If an action is not found, it's a false*/ if (action_found == AXIS2_FALSE) { axis2_addr_in_create_fault_envelope(env, AXIS2_WSA_PREFIX_ACTION, addr_ns_str, msg_ctx); status = AXIS2_FAILURE; } return status; }
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 axis2_status_t AXIS2_CALL axiom_soap11_builder_helper_handle_event( axiom_soap11_builder_helper_t * builder_helper, const axutil_env_t * env, axiom_node_t * om_element_node, int element_level) { axiom_element_t *om_ele = NULL; axis2_char_t *ele_localname = NULL; axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_body_t *soap_body = NULL; axiom_soap_fault_t *soap_fault = NULL; AXIS2_PARAM_CHECK(env->error, om_element_node, AXIS2_FAILURE); om_ele = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env); ele_localname = axiom_element_get_localname(om_ele, env); if(!ele_localname) { return AXIS2_FAILURE; } soap_envelope = axiom_soap_builder_get_soap_envelope(builder_helper->soap_builder, env); if(!soap_envelope) { return AXIS2_FAILURE; } soap_body = axiom_soap_envelope_get_body(soap_envelope, env); if(!soap_body) { return AXIS2_FAILURE; } soap_fault = axiom_soap_body_get_fault(soap_body, env); if(!soap_fault) { return AXIS2_FAILURE; } if(element_level == 4) { axiom_soap_fault_code_t *fault_code = NULL; axiom_soap_fault_value_t *fault_value = NULL; axiom_node_t *fault_value_node = NULL; axiom_element_t *fault_value_ele = NULL; if(axutil_strcmp(ele_localname, AXIOM_SOAP11_SOAP_FAULT_CODE_LOCAL_NAME) == 0) { axis2_status_t status = AXIS2_SUCCESS; if(builder_helper->fault_string_present) { axiom_soap_builder_set_bool_processing_mandatory_fault_elements( builder_helper->soap_builder, env, AXIS2_FALSE); } fault_code = axiom_soap_fault_code_create(env); if(!fault_code) { return AXIS2_FAILURE; } axiom_soap_fault_code_set_base_node(fault_code, env, om_element_node); axiom_soap_fault_set_code(soap_fault, env, fault_code); axiom_soap_fault_code_set_builder(fault_code, env, builder_helper->soap_builder); axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME); fault_value = axiom_soap_fault_value_create_with_code(env, fault_code); if(!fault_value) { return AXIS2_FAILURE; } fault_value_node = axiom_soap_fault_value_get_base_node(fault_value, env); if(!fault_value_node) { return AXIS2_FAILURE; } fault_value_ele = (axiom_element_t *)axiom_node_get_data_element(fault_value_node, env); axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_value_node); status = axiom_soap11_builder_helper_process_text(builder_helper, env); if(status == AXIS2_FAILURE) { return AXIS2_FAILURE; } axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node); axiom_node_set_complete(om_element_node, env, AXIS2_TRUE); axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level - 1)); builder_helper->fault_code_present = AXIS2_TRUE; } else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_STRING_LOCAL_NAME, ele_localname) == 0) { axiom_soap_fault_reason_t *fault_reason = NULL; axiom_soap_fault_text_t *fault_text = NULL; axiom_node_t *fault_text_node = NULL; int status = AXIS2_SUCCESS; if(builder_helper->fault_code_present) { axiom_soap_builder_set_bool_processing_mandatory_fault_elements( builder_helper->soap_builder, env, AXIS2_FALSE); } axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME); fault_reason = axiom_soap_fault_reason_create(env); if(!fault_reason) { return AXIS2_FAILURE; } axiom_soap_fault_reason_set_base_node(fault_reason, env, om_element_node); axiom_soap_fault_set_reason(soap_fault, env, fault_reason); fault_text = axiom_soap_fault_text_create_with_parent(env, fault_reason); if(!fault_text) { return AXIS2_FAILURE; } fault_text_node = axiom_soap_fault_text_get_base_node(fault_text, env); if(!fault_text_node) { return AXIS2_FAILURE; } axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, fault_text_node); status = axiom_soap11_builder_helper_process_text(builder_helper, env); if(status == AXIS2_FAILURE) { return AXIS2_FAILURE; } axiom_stax_builder_set_lastnode(builder_helper->om_builder, env, om_element_node); axiom_node_set_complete(om_element_node, env, AXIS2_TRUE); axiom_stax_builder_set_element_level(builder_helper->om_builder, env, (element_level - 1)); builder_helper->fault_string_present = AXIS2_TRUE; } else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_ACTOR_LOCAL_NAME, ele_localname) == 0) { axiom_soap_fault_role_t *fault_role = NULL; fault_role = axiom_soap_fault_role_create(env); if(!fault_role) { return AXIS2_FAILURE; } axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME); axiom_soap_fault_role_set_base_node(fault_role, env, om_element_node); axiom_soap_fault_set_role(soap_fault, env, fault_role); /* Role element may not have a namespace associated, hence commented, else it segfaults here - Samisa status = axiom_soap_builder_process_namespace_data( builder_helper->soap_builder, env, om_element_node, AXIS2_TRUE); if(status == AXIS2_FAILURE) return AXIS2_FAILURE; */ } else if(axutil_strcmp(AXIOM_SOAP11_SOAP_FAULT_DETAIL_LOCAL_NAME, ele_localname) == 0) { axiom_soap_fault_detail_t *fault_detail = NULL; fault_detail = axiom_soap_fault_detail_create(env); if(!fault_detail) { return AXIS2_FAILURE; } axiom_element_set_localname(om_ele, env, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME); axiom_soap_fault_detail_set_base_node(fault_detail, env, om_element_node); axiom_soap_fault_set_detail(soap_fault, env, fault_detail); } else { return AXIS2_SUCCESS; } } else if(element_level == 5) { axiom_node_t *parent_node = NULL; axiom_element_t *parent_element = NULL; axis2_char_t *parent_localname = NULL; parent_node = axiom_node_get_parent(om_element_node, env); if(!parent_node) { return AXIS2_FAILURE; } parent_element = (axiom_element_t *)axiom_node_get_data_element(om_element_node, env); parent_localname = axiom_element_get_localname(parent_element, env); if(!parent_localname) { return AXIS2_FAILURE; } if(axutil_strcmp(parent_localname, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME) == 0) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP11_FAULT_ACTOR_SHOULD_NOT_HAVE_CHILD_ELEMENTS, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "SOAP 1.1 Actor should not have child elements"); return AXIS2_FAILURE; } } return AXIS2_SUCCESS; }
int main( int argc, char **argv) { axutil_env_t *env = NULL; const axis2_char_t *address = NULL; axis2_endpoint_ref_t *endpoint_ref = NULL; axis2_options_t *options = NULL; const axis2_char_t *client_home = NULL; axis2_svc_client_t *svc_client = NULL; axiom_node_t *payload = NULL; axiom_node_t *ret_node = NULL; axiom_element_t *ret_ele = NULL; axis2_char_t *om_str = NULL; axis2_char_t *result = NULL; const axis2_char_t *echo_operation = NULL; const axis2_char_t *word_to_echo = NULL; const axis2_char_t *echo_type = NULL; axis2_char_t operation[32]; axis2_char_t echo_response_buff[32]; echo_operation = "String"; word_to_echo = "helloworld"; echo_type = "string"; if ((argc > 1) && (axutil_strcmp("-h", argv[1]) == 0)) { printf("\nUsage : %s [echo_operation] [echo_value] [XSD_type]\n", argv[0]); printf("use -h for help\n"); return 0; } if (argc > 1) echo_operation = argv[1]; if (argc > 2) word_to_echo = argv[2]; if (argc > 3) echo_type = argv[3]; /* address = "http://localhost:7070/cgi-bin/interopserver"; */ address = "http://easysoap.sourceforge.net/cgi-bin/interopserver"; sprintf(operation, "echo%s", echo_operation); printf("Using endpoint : %s\n", address); printf("Invoking %s with param %s\n", operation, word_to_echo); /* Set up the environment */ env = axutil_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE); /* Create EPR with given address */ endpoint_ref = axis2_endpoint_ref_create(env, address); options = axis2_options_create(env); axis2_options_set_to(options, env, endpoint_ref); /* this itest requried soap 1.1 message */ axis2_options_set_soap_version(options, env, AXIOM_SOAP11); client_home = AXIS2_GETENV("AXIS2C_HOME"); if (!client_home) client_home = "../../deploy"; /* Create service client */ svc_client = axis2_svc_client_create(env, client_home); if (!svc_client) { printf("Error creating service client\n"); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:" " %d :: %s", env->error->error_number, axutil_error_get_message(env->error)); } /* Set service client options */ axis2_svc_client_set_options(svc_client, env, options); payload = build_soap_body_content(env, echo_operation, echo_type, word_to_echo); /* Send request */ ret_node = axis2_svc_client_send_receive(svc_client, env, payload); if (ret_node) { om_str = AXIOM_NODE_TO_STRING(ret_node, env); if (om_str) printf("\nRecieving OM : %s\n", om_str); if (AXIOM_NODE_GET_NODE_TYPE(ret_node, env) == AXIOM_ELEMENT) { sprintf(echo_response_buff, "echo%sResponse", echo_operation); ret_ele = (axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env); if (axutil_strcmp (axiom_element_get_localname(ret_ele, env), echo_response_buff) != 0) { printf("%s != %s\n", axiom_element_get_localname(ret_ele, env), echo_response_buff); printf("\nFAIL\n\n"); return AXIS2_FAILURE; } ret_node = AXIOM_NODE_GET_FIRST_CHILD(ret_node, env); ret_ele = (axiom_element_t *) AXIOM_NODE_GET_DATA_ELEMENT(ret_node, env); result = axiom_element_get_text(ret_ele, env, ret_node); if (!strcmp(word_to_echo, result)) { printf("\nSUCCESS\n\n"); } else { printf("\nFAIL\n\n"); } } else { printf("\nFAIL\n\n"); return AXIS2_FAILURE; } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:" " %d :: %s", env->error->error_number, axutil_error_get_message(env->error)); printf("round1 stub invoke FAILED!\n"); return AXIS2_FAILURE; } return AXIS2_SUCCESS; }
/** * Builts EncryptedParts or SignedParts assertion * @param env Pointer to environment struct * @param node Assertion node * @param element Assertion element * @param is_signed boolean showing whether signing or encryption * @returns neethi assertion created. NULL if failure. */ AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL rp_signed_encrypted_parts_builder_build( const axutil_env_t *env, axiom_node_t *parts, axiom_element_t *parts_ele, axis2_bool_t is_signed) { rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL; axiom_children_iterator_t *children_iter = NULL; neethi_assertion_t *assertion = NULL; axis2_status_t status = AXIS2_SUCCESS; signed_encrypted_parts = rp_signed_encrypted_parts_create(env); if (!signed_encrypted_parts) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot create signed_encrypted_parts."); return NULL; } rp_signed_encrypted_parts_set_signedparts(signed_encrypted_parts, env, is_signed); children_iter = axiom_element_get_children(parts_ele, env, parts); if (children_iter) { while (axiom_children_iterator_has_next(children_iter, env)) { axiom_node_t *node = NULL; axiom_element_t *ele = NULL; axis2_char_t *local_name = NULL; node = axiom_children_iterator_next(children_iter, env); if (node) { if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { ele = (axiom_element_t *) axiom_node_get_data_element(node, env); if (ele) { local_name = axiom_element_get_localname(ele, env); if (local_name) { status = rp_signed_encrypted_parts_builder_set_properties (node, ele, local_name, signed_encrypted_parts, env); if (status != AXIS2_SUCCESS) { rp_signed_encrypted_parts_free (signed_encrypted_parts, env); signed_encrypted_parts = NULL; AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[neethi] Cannot create signed_encrypted_parts. " "Error in processing child element %s", local_name); return NULL; } } } } } } } assertion = neethi_assertion_create_with_args( env, (AXIS2_FREE_VOID_ARG)rp_signed_encrypted_parts_free, signed_encrypted_parts, ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS); return assertion; }
AXIS2_EXTERN int AXIS2_CALL saml_authentication_query_build(saml_authentication_query_t* authentication_query, axiom_node_t *node, const axutil_env_t *env) { axutil_hash_t *attr_hash = NULL; axiom_element_t *element = NULL; axutil_hash_index_t *hi = NULL; axiom_child_element_iterator_t *iterator = NULL; axiom_node_t *child_node; if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return AXIS2_FAILURE; } if ((element = axiom_node_get_data_element(node, env)) == NULL) { return AXIS2_FAILURE; } /* initialize the attributes */ attr_hash = axiom_element_get_all_attributes(element, env); if(attr_hash) { for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) { void *v = NULL; axutil_hash_this(hi, NULL, NULL, &v); if (v) { axis2_char_t *attr_val = NULL; axiom_attribute_t *attr = (axiom_attribute_t*)v; attr_val = axiom_attribute_get_value(attr, env); if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_AUTHENTICATION_METHOD)) { authentication_query->auth_method = attr_val; break; } } } } iterator = axiom_element_get_child_elements(element, env, node); if(iterator) { while(axiom_child_element_iterator_has_next(iterator, env)) { child_node = axiom_child_element_iterator_next(iterator, env); element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_SUBJECT))) { if(authentication_query->subject) return saml_subject_build(authentication_query->subject, child_node, env); else return AXIS2_FAILURE; } } return AXIS2_SUCCESS; } else return AXIS2_FAILURE; }
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; }
/** * 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; }
AXIS2_EXTERN axutil_array_list_t* AXIS2_CALL remote_registry_util_get_tags_from_feed( const axutil_env_t *env, axis2_char_t *feed) { axiom_node_t *entry_node = NULL; axiom_children_iterator_t *entry_it = NULL; axiom_element_t *entry_ele = NULL; axutil_array_list_t *tags = NULL; entry_node = axiom_node_create_from_buffer(env, feed); if(!entry_node) { return NULL; } entry_ele = axiom_node_get_data_element(entry_node, env); entry_it = axiom_element_get_children(entry_ele, env, entry_node); while(axiom_children_iterator_has_next(entry_it, env)) { axiom_node_t *child = NULL; axiom_element_t *child_ele = NULL; axis2_char_t *local_name = NULL; child = axiom_children_iterator_next(entry_it, env); if(axiom_node_get_node_type(child, env) != AXIOM_ELEMENT) { continue; } child_ele = (axiom_element_t *)axiom_node_get_data_element(child, env); local_name = axiom_element_get_localname(child_ele, env); if(!axutil_strcmp(local_name, "entry")) { axiom_children_iterator_t *entry_child_it = NULL; axis2_char_t *is_tagging = NULL; entry_child_it = axiom_element_get_children(entry_ele, env, entry_node); while(axiom_children_iterator_has_next(entry_child_it, env)) { axiom_element_t *entry_child_ele = NULL; axiom_node_t *entry_child = NULL; entry_child = axiom_children_iterator_next(entry_child_it, env); if(axiom_node_get_node_type(entry_child, env) != AXIOM_ELEMENT) { continue; } entry_child_ele = (axiom_element_t*)axiom_node_get_data_element(entry_child, env); local_name = axiom_element_get_localname(entry_child_ele, env); if(!axutil_strcmp(local_name, "taggings")) { is_tagging = axiom_element_get_text(entry_child_ele, env, entry_child); } } if(!axutil_strcmp("1", is_tagging)) { axiom_children_iterator_reset(entry_child_it, env); while(axiom_children_iterator_has_next(entry_child_it, env)) { axiom_element_t *entry_child_ele = NULL; axiom_node_t *entry_child = NULL; entry_child = axiom_children_iterator_next(entry_child_it, env); if(axiom_node_get_node_type(entry_child, env) != AXIOM_ELEMENT) { continue; } entry_child_ele = (axiom_element_t*)axiom_node_get_data_element(entry_child, env); local_name = axiom_element_get_localname(entry_child_ele, env); if(!axutil_strcmp(local_name, "title")) { axis2_char_t *tag_name = NULL; tag_name = axiom_element_get_text(entry_child_ele, env, entry_child); axutil_array_list_add(tags, env, tag_name); } } } } } return tags; }
AXIS2_EXTERN int AXIS2_CALL saml_autho_decision_query_build(saml_autho_decision_query_t* autho_decision_query, axiom_node_t *node, const axutil_env_t *env) { axutil_hash_t *attr_hash = NULL; axiom_element_t *element = NULL; axutil_hash_index_t *hi = NULL; axiom_child_element_iterator_t *iterator = NULL; axiom_node_t *child_node; saml_action_t *action; if (axiom_node_get_node_type(node, env) != AXIOM_ELEMENT) { return AXIS2_FAILURE; } if ((element = axiom_node_get_data_element(node, env)) == NULL) { return AXIS2_FAILURE; } /* initialize the attributes */ attr_hash = axiom_element_get_all_attributes(element, env); for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi)) { void *v = NULL; axutil_hash_this(hi, NULL, NULL, &v); if (v) { axis2_char_t *attr_val = NULL; axiom_attribute_t *attr = (axiom_attribute_t*)v; attr_val = axiom_attribute_get_value(attr, env); if(!axutil_strcmp(axiom_attribute_get_localname(attr, env), SAML_RESOURCE)) { if(autho_decision_query->resource) { autho_decision_query->resource = attr_val; break; } else return AXIS2_FAILURE; } } } iterator = axiom_element_get_child_elements(element, env, node); if(iterator) { while(axiom_child_element_iterator_has_next(iterator, env)) { child_node = axiom_child_element_iterator_next(iterator, env); element = (axiom_element_t *)axiom_node_get_data_element(child_node, env); if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_SUBJECT))) { if(autho_decision_query->subject) saml_subject_build(autho_decision_query->subject, child_node, env); } else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_ACTION))) { if(autho_decision_query->saml_actions) { action = saml_action_create(env); saml_action_build(action, child_node, env); axutil_array_list_add(autho_decision_query->saml_actions, env, action); } } else if(element != NULL && !(axutil_strcmp(axiom_element_get_localname(element, env), SAML_EVIDENCE))) { if(autho_decision_query->evidence) saml_evidence_build(autho_decision_query->evidence, child_node, env); } } return AXIS2_SUCCESS; } else return AXIS2_FAILURE; }
axis2_status_t AXIS2_CALL adb_createReservationResponse_deserialize( adb_createReservationResponse_t* _createReservationResponse, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; void *element = NULL; axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _createReservationResponse, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for createReservationResponse : " "NULL elemenet can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); /* * building ReservationStatus element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "ReservationStatus", NULL, NULL); if (adb_ReservationStatus_is_particle() || (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("ReservationStatus", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("ReservationStatus", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } element = (void*)adb_ReservationStatus_create(env); status = adb_ReservationStatus_deserialize((adb_ReservationStatus_t*)element, env, ¤t_node, &is_early_node_valid, AXIS2_FALSE); if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element ReservationStatus"); } else { status = adb_createReservationResponse_set_ReservationStatus(_createReservationResponse, env, (adb_ReservationStatus_t*)element); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for ReservationStatus "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
axis2_status_t AXIS2_CALL adb_CanonicalizationMethodType_deserialize_obj( adb_CanonicalizationMethodType_t* _CanonicalizationMethodType, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; axiom_attribute_t *parent_attri = NULL; axiom_element_t *parent_element = NULL; axis2_char_t *attrib_text = NULL; axutil_hash_t *attribute_hash = NULL; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; int i = 0; axutil_array_list_t *arr_list = NULL; int sequence_broken = 0; axiom_node_t *tmp_node = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _CanonicalizationMethodType, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for CanonicalizationMethodType : " "NULL element can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); parent_element = (axiom_element_t *)axiom_node_get_data_element(parent, env); attribute_hash = axiom_element_get_all_attributes(parent_element, env); /* * building extraElement array */ arr_list = axutil_array_list_create(env, 10); /* * building extraElement element */ /* 'any' arrays are not handling correctly when there are other elements mixed with the 'any' element. */ for (i = 0, sequence_broken = 0, current_node = first_node; !sequence_broken && current_node != NULL;) { if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node =axiom_node_get_next_sibling(current_node, env); is_early_node_valid = AXIS2_FALSE; continue; } if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("extraElement", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } text_value = NULL; /* just to avoid warning */ { axiom_node_t *current_property_node = current_node; current_node = axiom_node_get_next_sibling(current_node, env); axiom_node_detach(current_property_node, env); axutil_array_list_add_at(arr_list, env, i, (void*)current_property_node); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for extraElement "); if(element_qname) { axutil_qname_free(element_qname, env); } if(arr_list) { axutil_array_list_free(arr_list, env); } return AXIS2_FAILURE; } i ++; } if(0 == axutil_array_list_size(arr_list,env)) { axutil_array_list_free(arr_list, env); } else { status = adb_CanonicalizationMethodType_set_extraElement(_CanonicalizationMethodType, env, arr_list); } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } parent_attri = NULL; attrib_text = NULL; if(attribute_hash) { axutil_hash_index_t *hi; void *val; const void *key; for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, &val); if(!strcmp((axis2_char_t*)key, "Algorithm")) { parent_attri = (axiom_attribute_t*)val; AXIS2_FREE(env->allocator, hi); break; } } } if(parent_attri) { attrib_text = axiom_attribute_get_value(parent_attri, env); } else { /* this is hoping that attribute is stored in "Algorithm", this happnes when name is in default namespace */ attrib_text = axiom_element_get_attribute_value_by_name(parent_element, env, "Algorithm"); } if(attrib_text != NULL) { adb_CanonicalizationMethodType_set_Algorithm(_CanonicalizationMethodType, env, axutil_uri_parse_string(env, attrib_text)); } else if(!dont_care_minoccurs) { if(element_qname) { axutil_qname_free(element_qname, env); } /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "required attribute Algorithm missing"); return AXIS2_FAILURE; } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
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; }
int main( int argc, char **argv) { const axutil_env_t *env = NULL; const axis2_char_t *address = NULL; axis2_endpoint_ref_t *endpoint_ref = NULL; axis2_options_t *options = NULL; const axis2_char_t *client_home = NULL; axis2_svc_client_t *svc_client = NULL; axiom_node_t *payload = NULL; axiom_node_t *ret_node = NULL; const axis2_char_t *google_key = NULL; const axis2_char_t *word_to_spell = NULL; const axis2_char_t *operation = NULL; operation = "doSpellingSuggestion"; google_key = "00000000000000000000000000000000"; word_to_spell = "salvasion"; /* Set up the environment */ env = axutil_env_create_all("google_client.log", AXIS2_LOG_LEVEL_TRACE); /* Set end point reference of google service */ address = "http://api.google.com/search/beta2"; if ((argc > 1) && (axutil_strcmp("-h", argv[1]) == 0)) { printf("\nUsage : %s [google_key] [word_to_spell] \n", argv[0]); printf ("\tgoogle_key Your Google license key. Default value won't work. You must use your key here.\n"); printf ("\tword_to_spell Word to be spelled by Google service. Default is %s\n", word_to_spell); printf ("NOTE: command line arguments must appear in given order, with trailing ones being optional\n"); printf("\tUse -h for help\n"); return 0; } if (argc > 1) google_key = argv[1]; if (argc > 2) word_to_spell = argv[2]; if (argc > 3) address = argv[3]; printf("Using endpoint : %s\n", address); printf("\nInvoking operation %s with params %s and %s\n", operation, google_key, word_to_spell); /* Create EPR with given address */ endpoint_ref = axis2_endpoint_ref_create(env, address); /* Setup options */ options = axis2_options_create(env); axis2_options_set_to(options, env, endpoint_ref); axis2_options_set_soap_version(options, env, AXIOM_SOAP11); /* Set up deploy folder. */ client_home = AXIS2_GETENV("WSFC_HOME"); if (!client_home || !strcmp(client_home, "")) client_home = "../.."; /* Create service client */ svc_client = axis2_svc_client_create(env, client_home); if (!svc_client) { printf ("Error creating service client, Please check WSFC_HOME again\n"); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:" " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return -1; } /* Set service client options */ axis2_svc_client_set_options(svc_client, env, options); /* Build the SOAP request message payload using OM API. */ payload = build_soap_body_content(env, operation, google_key, word_to_spell); /* Send request */ ret_node = axis2_svc_client_send_receive(svc_client, env, payload); if (axis2_svc_client_get_last_response_has_fault(svc_client, env)) { axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_body_t *soap_body = NULL; axiom_soap_fault_t *soap_fault = NULL; axis2_char_t *fault_string = NULL; printf("\nResponse has a SOAP fault\n"); soap_envelope = axis2_svc_client_get_last_response_soap_envelope(svc_client, env); if (soap_envelope) { soap_body = axiom_soap_envelope_get_body(soap_envelope, env); } if (soap_body) { soap_fault = axiom_soap_body_get_fault(soap_body, env); } if (soap_fault) { fault_string = axiom_node_to_string(axiom_soap_fault_get_base_node (soap_fault, env), env); printf("\nReturned SOAP fault: %s\n", fault_string); AXIS2_FREE (env->allocator, fault_string); } if (svc_client) { axis2_svc_client_free(svc_client, env); svc_client = NULL; } if (env) { axutil_env_free((axutil_env_t *) env); env = NULL; } return -1; } if (ret_node) { if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT) { axis2_char_t *result = NULL; axiom_element_t *result_ele = NULL; axiom_node_t *ret_node1 = NULL; result_ele = (axiom_element_t *) axiom_node_get_data_element(ret_node, env); if (axutil_strcmp (axiom_element_get_localname(result_ele, env), "doSpellingSuggestionResponse") != 0) { print_invalid_om(env, ret_node); return AXIS2_FAILURE; } ret_node1 = axiom_node_get_first_element(ret_node, env); /*return */ if (!ret_node1) { print_invalid_om(env, ret_node); return AXIS2_FAILURE; } result_ele = (axiom_element_t *) axiom_node_get_data_element(ret_node1, env); result = axiom_element_get_text(result_ele, env, ret_node1); printf("\nResult = %s\n", result); } else { print_invalid_om(env, ret_node); return AXIS2_FAILURE; } } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:" " %d :: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); printf("Google client invoke FAILED!\n"); } if (svc_client) { axis2_svc_client_free(svc_client, env); svc_client = NULL; } if (env) { axutil_env_free((axutil_env_t *) env); env = NULL; } return 0; }
axis2_status_t AXIS2_CALL adb_getReservationStatusesResponse_deserialize( adb_getReservationStatusesResponse_t* _getReservationStatusesResponse, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; void *element = NULL; axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; int i = 0; axutil_array_list_t *arr_list = NULL; int sequence_broken = 0; axiom_node_t *tmp_node = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _getReservationStatusesResponse, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for getReservationStatusesResponse : " "NULL elemenet can not be passed to deserialize"); return AXIS2_FAILURE; } first_node = axiom_node_get_first_child(parent, env); /* * building reservationStatuses array */ arr_list = axutil_array_list_create(env, 10); /* * building reservationStatuses element */ element_qname = axutil_qname_create(env, "reservationStatuses", NULL, NULL); for (i = 0, sequence_broken = 0, current_node = first_node; !sequence_broken && current_node != NULL;) { if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node =axiom_node_get_next_sibling(current_node, env); is_early_node_valid = AXIS2_FALSE; continue; } current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); if (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("reservationStatuses", axiom_element_get_localname(current_element, env))) { is_early_node_valid = AXIS2_TRUE; element = (void*)adb_ReservationStatus_create(env); status = adb_ReservationStatus_deserialize((adb_ReservationStatus_t*)element, env, ¤t_node, &is_early_node_valid, AXIS2_FALSE); if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element reservationStatuses "); } else { axutil_array_list_add_at(arr_list, env, i, element); } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for reservationStatuses "); if(element_qname) { axutil_qname_free(element_qname, env); } if(arr_list) { axutil_array_list_free(arr_list, env); } return AXIS2_FAILURE; } i ++; current_node = axiom_node_get_next_sibling(current_node, env); } else { is_early_node_valid = AXIS2_FALSE; sequence_broken = 1; } } if (i < 0) { /* found element out of order */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "reservationStatuses (@minOccurs = '0') only have %d elements", i); if(element_qname) { axutil_qname_free(element_qname, env); } if(arr_list) { axutil_array_list_free(arr_list, env); } return AXIS2_FAILURE; } if(0 == axutil_array_list_size(arr_list,env)) { axutil_array_list_free(arr_list, env); } else { status = adb_getReservationStatusesResponse_set_reservationStatuses(_getReservationStatusesResponse, env, arr_list); } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
axis2_status_t AXIS2_CALL adb_subscriberRequest_deserialize_obj( adb_subscriberRequest_t* _subscriberRequest, const axutil_env_t *env, axiom_node_t **dp_parent, axis2_bool_t *dp_is_early_node_valid, axis2_bool_t dont_care_minoccurs) { axiom_node_t *parent = *dp_parent; axis2_status_t status = AXIS2_SUCCESS; const axis2_char_t* text_value = NULL; axutil_qname_t *qname = NULL; axutil_qname_t *element_qname = NULL; axiom_node_t *first_node = NULL; axis2_bool_t is_early_node_valid = AXIS2_TRUE; axiom_node_t *current_node = NULL; axiom_element_t *current_element = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, _subscriberRequest, AXIS2_FAILURE); while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT) { parent = axiom_node_get_next_sibling(parent, env); } if (NULL == parent) { /* This should be checked before everything */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for subscriberRequest : " "NULL element can not be passed to deserialize"); return AXIS2_FAILURE; } current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env); qname = axiom_element_get_qname(current_element, env, parent); if (axutil_qname_equals(qname, env, _subscriberRequest-> qname)) { first_node = axiom_node_get_first_child(parent, env); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in building adb object for subscriberRequest : " "Expected %s but returned %s", axutil_qname_to_string(_subscriberRequest-> qname, env), axutil_qname_to_string(qname, env)); return AXIS2_FAILURE; } /* * building number element */ current_node = first_node; is_early_node_valid = AXIS2_FALSE; while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT) { current_node = axiom_node_get_next_sibling(current_node, env); } if(current_node != NULL) { current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env); qname = axiom_element_get_qname(current_element, env, current_node); } element_qname = axutil_qname_create(env, "number", NULL, NULL); if ( (current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("number", axiom_element_get_localname(current_element, env))))) { if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname) || !axutil_strcmp("number", axiom_element_get_localname(current_element, env)))) { is_early_node_valid = AXIS2_TRUE; } text_value = axiom_element_get_text(current_element, env, current_node); if(text_value != NULL) { status = adb_subscriberRequest_set_number(_subscriberRequest, env, atoi(text_value)); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element number"); status = AXIS2_FAILURE; } if(AXIS2_FAILURE == status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for number "); if(element_qname) { axutil_qname_free(element_qname, env); } return AXIS2_FAILURE; } } else if(!dont_care_minoccurs) { if(element_qname) { axutil_qname_free(element_qname, env); } /* this is not a nillable element*/ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element number missing"); return AXIS2_FAILURE; } if(element_qname) { axutil_qname_free(element_qname, env); element_qname = NULL; } return status; }
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); } }