AXIS2_EXTERN void AXIS2_CALL axiom_namespace_free( axiom_namespace_t * om_namespace, const axutil_env_t * env) { AXIS2_ENV_CHECK_VOID(env); if(--om_namespace->ref > 0) { return; } if(om_namespace->prefix) { axutil_string_free(om_namespace->prefix, env); } if(om_namespace->uri) { axutil_string_free(om_namespace->uri, env); } if(om_namespace->key) { AXIS2_FREE(env->allocator, om_namespace->key); } AXIS2_FREE(env->allocator, om_namespace); }
AXIS2_EXTERN void AXIS2_CALL axiom_attribute_free( axiom_attribute_t * attribute, const axutil_env_t * env) { if(--attribute->ref > 0) { return; } AXIS2_ENV_CHECK(env, AXIS2_FAILURE); if(attribute->localname) { axutil_string_free(attribute->localname, env); } if(attribute->value) { axutil_string_free(attribute->value, env); } if(attribute->qname) { axutil_qname_free(attribute->qname, env); } AXIS2_FREE(env->allocator, attribute); return; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_namespace_set_uri_str( axiom_namespace_t * om_namespace, const axutil_env_t * env, axutil_string_t * uri) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); if(om_namespace->uri) { axutil_string_free(om_namespace->uri, env); om_namespace->uri = NULL; } om_namespace->uri = axutil_string_clone(uri, env); if(!(om_namespace->uri)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return AXIS2_FAILURE; } return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_attribute_set_localname( axiom_attribute_t * attribute, const axutil_env_t * env, const axis2_char_t * localname) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); if(attribute->localname) { axutil_string_free(attribute->localname, env); attribute->localname = NULL; } attribute->localname = axutil_string_create(env, localname); if(!(attribute->localname)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return AXIS2_FAILURE; } return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL axiom_text_free( axiom_text_t * om_text, const axutil_env_t * env) { AXIS2_ENV_CHECK_VOID(env); if(om_text->value) { axutil_string_free(om_text->value, env); } if(om_text->ns) { axiom_namespace_free(om_text->ns, env); } if(om_text->content_id) { AXIS2_FREE(env->allocator, om_text->content_id); } if(om_text->om_attribute) { axiom_attribute_free(om_text->om_attribute, env); } if(om_text->data_handler) { axiom_data_handler_free(om_text->data_handler, env); } AXIS2_FREE(env->allocator, om_text); return; }
AXIS2_EXTERN axis2_disp_t *AXIS2_CALL axis2_rest_disp_create( const axutil_env_t * env) { axis2_disp_t *disp = NULL; axis2_handler_t *handler = NULL; axutil_string_t *name = NULL; name = axutil_string_create_const(env, (axis2_char_t **)&AXIS2_REST_DISP_NAME); disp = axis2_disp_create(env, name); if(!disp) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } handler = axis2_disp_get_base(disp, env); if(!handler) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); return NULL; } axis2_handler_set_invoke(handler, env, axis2_rest_disp_invoke); axutil_string_free(name, env); return disp; }
sandesha2_msg_ctx_t *AXIS2_CALL sandesha2_msg_creator_create_terminate_seq_res_msg( const axutil_env_t *env, sandesha2_msg_ctx_t *ref_rm_msg, axis2_msg_ctx_t *out_msg, sandesha2_seq_property_mgr_t *seq_prop_mgr) { sandesha2_msg_ctx_t *res_rm_msg = NULL; sandesha2_terminate_seq_t *terminate_seq = NULL; axis2_char_t *seq_id = NULL; axis2_char_t *rm_ns_val = NULL; sandesha2_terminate_seq_res_t *terminate_seq_res = NULL; sandesha2_identifier_t *identifier = NULL; axiom_soap_envelope_t *soap_envelope = NULL; axis2_char_t *rm_version = NULL; axis2_char_t *temp_action = NULL; axutil_string_t *soap_action = NULL; res_rm_msg = sandesha2_msg_ctx_create(env, out_msg); terminate_seq = sandesha2_msg_ctx_get_terminate_seq(ref_rm_msg, env); seq_id = sandesha2_identifier_get_identifier( sandesha2_terminate_seq_get_identifier(terminate_seq, env), env); rm_ns_val = sandesha2_msg_ctx_get_rm_ns_val(ref_rm_msg, env); sandesha2_msg_ctx_set_rm_ns_val(res_rm_msg, env, rm_ns_val); terminate_seq_res = sandesha2_terminate_seq_res_create(env, rm_ns_val); identifier = sandesha2_identifier_create(env, rm_ns_val); sandesha2_identifier_set_identifier(identifier, env, seq_id); sandesha2_terminate_seq_res_set_identifier(terminate_seq_res, env, identifier); soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env, sandesha2_utils_get_soap_version(env, sandesha2_msg_ctx_get_soap_envelope(ref_rm_msg, env))); sandesha2_msg_ctx_set_soap_envelope(res_rm_msg, env, soap_envelope); sandesha2_msg_ctx_set_terminate_seq_res(res_rm_msg, env, terminate_seq_res); rm_version = sandesha2_utils_get_rm_version(env, sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env)); if(!rm_version) { rm_version = axutil_strdup(env, sandesha2_msg_ctx_get_rm_spec_ver(ref_rm_msg, env)); } temp_action = sandesha2_spec_specific_consts_get_teminate_seq_res_action(env, rm_version); axis2_msg_ctx_set_wsa_action(out_msg, env, temp_action); soap_action = axutil_string_create(env, temp_action); axis2_msg_ctx_set_soap_action(out_msg, env, soap_action); axutil_string_free(soap_action, env); sandesha2_msg_creator_init_creation(env, sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env), out_msg); sandesha2_msg_ctx_add_soap_envelope(ref_rm_msg, env); sandesha2_msg_creator_finalize_creation(env, sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env), out_msg); axis2_msg_ctx_set_server_side(sandesha2_msg_ctx_get_msg_ctx(ref_rm_msg, env), env, AXIS2_TRUE); return res_rm_msg; }
static axiom_node_t * axiom_stax_builder_create_om_text( axiom_stax_builder_t * om_builder, const axutil_env_t * env) { axis2_char_t *temp_value = NULL; axutil_string_t *temp_value_str = NULL; axiom_node_t *node = NULL; axiom_node_t *parent = om_builder->lastnode; if(!parent) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BUILDER_STATE_LAST_NODE_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text without a node"); return NULL; } temp_value = axiom_xml_reader_get_value(om_builder->parser, env); if(!temp_value) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_VALUE_NULL, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid OM Text value"); return NULL; } #ifdef AXIS2_LIBXML2_ENABLED temp_value_str = axutil_string_create(env, temp_value); axiom_xml_reader_xml_free(om_builder->parser, env, temp_value); #else temp_value_str = axutil_string_create_assume_ownership(env, &temp_value); #endif if(!temp_value_str) { /* axutil_string_create will have set an error number */ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create OM Text value"); return NULL; } if(axiom_node_is_complete(parent, env)) { parent = axiom_node_get_parent(om_builder->lastnode, env); } axiom_text_create_str(env, parent, temp_value_str, &node); axutil_string_free(temp_value_str, env); if(!node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create axiom_text"); return NULL; } axiom_node_set_builder(node, env, om_builder); axiom_node_set_complete(node, env, AXIS2_TRUE); om_builder->lastnode = node; return node; }
axis2_status_t axis2_addr_in_extract_svc_grp_ctx_id( const axutil_env_t * env, axiom_soap_header_t * soap_header, axis2_msg_ctx_t * msg_ctx) { axiom_node_t *node = NULL; axiom_element_t *element = NULL; node = axiom_soap_header_get_base_node(soap_header, env); if (node && axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { axutil_qname_t *qname = NULL; element = (axiom_element_t *) axiom_node_get_data_element(node, env); qname = axutil_qname_create(env, AXIS2_SVC_GRP_ID, AXIS2_NAMESPACE_URI, AXIS2_NAMESPACE_PREFIX); if (qname) { axiom_node_t *child_node = NULL; axiom_element_t *child_element = NULL; child_element = axiom_element_get_first_child_with_qname(element, env, qname, node, &child_node); if (child_element) { axis2_conf_ctx_t *conf_ctx = NULL; axis2_char_t *grp_id = axiom_element_get_text(child_element, env, child_node); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if (conf_ctx && grp_id) { axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env, grp_id); axis2_svc_grp_ctx_t *svc_ctx_grp_ctx = axis2_conf_ctx_get_svc_grp_ctx(conf_ctx, env, grp_id); if (!svc_ctx_grp_ctx) { return AXIS2_FAILURE; } axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); axutil_string_free(svc_grp_ctx_id_str, env); return AXIS2_SUCCESS; } } } axutil_qname_free(qname, env); } return AXIS2_FAILURE; }
AXIS2_EXTERN axiom_attribute_t *AXIS2_CALL axiom_attribute_create( const axutil_env_t * env, const axis2_char_t * localname, const axis2_char_t * value, axiom_namespace_t * ns) { axiom_attribute_t *attribute = NULL; AXIS2_ENV_CHECK(env, NULL); /* localname is mandatory */ AXIS2_PARAM_CHECK(env->error, localname, NULL); attribute = (axiom_attribute_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_attribute_t)); if(!attribute) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } /** initialize fields */ attribute->localname = NULL; attribute->value = NULL; attribute->ns = NULL; attribute->qname = NULL; attribute->localname = axutil_string_create(env, localname); if(!(attribute->localname)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_FREE(env->allocator, attribute); return NULL; } if(value) { attribute->value = axutil_string_create(env, value); if(!(attribute->value)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); axutil_string_free(attribute->localname, env); AXIS2_FREE(env->allocator, attribute); return NULL; } } attribute->ns = ns; attribute->ref = 0; return attribute; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_set_value_str( struct axiom_text * om_text, const axutil_env_t * env, axutil_string_t * value) { if(om_text->value) { axutil_string_free(om_text->value, env); om_text->value = NULL; } if(value) { om_text->value = axutil_string_clone(value, env); } return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_options_set_soap_action( axis2_options_t * options, const axutil_env_t * env, axutil_string_t * soap_action) { if(options->soap_action) { axutil_string_free(options->soap_action, env); options->soap_action = NULL; } if(soap_action) { options->soap_action = axutil_string_clone(soap_action, env); } return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_attribute_set_localname_str( axiom_attribute_t * attribute, const axutil_env_t * env, axutil_string_t * localname) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, localname, AXIS2_FAILURE); if(attribute->localname) { axutil_string_free(attribute->localname, env); attribute->localname = NULL; } attribute->localname = axutil_string_clone(localname, env); return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL axis2_options_free( axis2_options_t * options, const axutil_env_t * env) { if (options->properties) { axutil_hash_index_t *hi = NULL; void *val = NULL; const void *key = NULL; for (hi = axutil_hash_first(options->properties, env); hi; hi = axutil_hash_next(env, hi)) { axutil_property_t *property = NULL; axutil_hash_this(hi, &key, NULL, &val); property = (axutil_property_t *) val; if (property) { axutil_property_free(property, env); } } axutil_hash_free(options->properties, env); } if (options->soap_version_uri) { AXIS2_FREE(env->allocator, options->soap_version_uri); } if (options->msg_info_headers) { axis2_msg_info_headers_free(options->msg_info_headers, env); } if (options->soap_action) { axutil_string_free(options->soap_action, env); } AXIS2_FREE(env->allocator, options); }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_handler_desc_set_name( axis2_handler_desc_t * handler_desc, const axutil_env_t * env, axutil_string_t * name) { if(handler_desc->name) { axutil_string_free(handler_desc->name, env); handler_desc->name = NULL; } if(name) { handler_desc->name = axutil_string_clone(name, env); } return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_set_value( axiom_text_t * om_text, const axutil_env_t * env, const axis2_char_t * value) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE); if(om_text->value) { axutil_string_free(om_text->value, env); om_text->value = NULL; } om_text->value = axutil_string_create(env, value); if(!om_text->value) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return AXIS2_FAILURE; } return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_attribute_set_value_str( axiom_attribute_t * attribute, const axutil_env_t * env, axutil_string_t * value) { AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); if(attribute->value) { axutil_string_free(attribute->value, env); attribute->value = NULL; } attribute->value = axutil_string_clone(value, env); if(!(attribute->value)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return AXIS2_FAILURE; } return AXIS2_SUCCESS; }
AXIS2_EXTERN void AXIS2_CALL axis2_handler_desc_free( axis2_handler_desc_t * handler_desc, const axutil_env_t * env) { if(!handler_desc) { return; } if(handler_desc->param_container) { axutil_param_container_free(handler_desc->param_container, env); } if(handler_desc->name) { axutil_string_free(handler_desc->name, env); } if(handler_desc->rules) { axis2_phase_rule_free(handler_desc->rules, env); } if(handler_desc->handler) { axis2_handler_free(handler_desc->handler, env); } if(handler_desc->class_name) { AXIS2_FREE(env->allocator, handler_desc->class_name); } AXIS2_FREE(env->allocator, handler_desc); }
/** * Adds an ack message to the given application message. * * @param app_msg * @param sequence_id */ axis2_status_t AXIS2_CALL sandesha2_msg_creator_add_ack_msg( const axutil_env_t *env, sandesha2_msg_ctx_t *target_rm_msg_ctx, axis2_char_t *seq_id, sandesha2_seq_property_mgr_t *seq_prop_mgr) { axiom_soap_envelope_t *envelope = NULL; axiom_soap_header_t *soap_header = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_char_t *rm_version = NULL; axis2_char_t *rm_ns_value = NULL; axis2_char_t *msg_no_list = NULL; axis2_char_t *ack_req_action = NULL; axis2_char_t *temp_action = NULL; axutil_string_t *ack_req_soap_action = NULL; axis2_char_t *str_value = NULL; axis2_char_t *uuid = NULL; sandesha2_identifier_t *id = NULL; sandesha2_seq_ack_t *seq_ack = NULL; sandesha2_seq_property_bean_t *seq_bean = NULL; sandesha2_seq_property_bean_t *seq_closed_bean = NULL; axis2_msg_ctx_t *msg_ctx = NULL; axutil_array_list_t *ack_range_list = NULL; int i = 0, size = 0; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_msg_creator_add_ack_msg"); envelope = sandesha2_msg_ctx_get_soap_envelope(target_rm_msg_ctx, env); if(!envelope) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_SOAP_ENVELOPE_IN_MSG_CTX, AXIS2_FAILURE); return AXIS2_FAILURE; } msg_ctx = sandesha2_msg_ctx_get_msg_ctx(target_rm_msg_ctx, env); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); rm_version = sandesha2_utils_get_rm_version(env, msg_ctx); if(!rm_version) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_RM_VERSION_OF_GIVEN_MSG, AXIS2_FAILURE); return AXIS2_FAILURE; } rm_ns_value = sandesha2_spec_specific_consts_get_rm_ns_val(env, rm_version); seq_ack = sandesha2_seq_ack_create(env, rm_ns_value); id = sandesha2_identifier_create(env, rm_ns_value); sandesha2_identifier_set_identifier(id, env, seq_id); sandesha2_seq_ack_set_identifier(seq_ack, env, id); seq_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, seq_id, SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES); if(seq_bean) { msg_no_list = (axis2_char_t *) sandesha2_seq_property_bean_get_value(seq_bean, env); } ack_range_list = sandesha2_utils_get_ack_range_list(env, msg_no_list, rm_ns_value); if(seq_bean) { sandesha2_seq_property_bean_free(seq_bean, env); } if(ack_range_list) { size = axutil_array_list_size(ack_range_list, env); } for(i = 0; i < size; i++) { sandesha2_ack_range_t *ack_range = NULL; ack_range = axutil_array_list_get(ack_range_list, env, i); sandesha2_seq_ack_add_ack_range(seq_ack, env, ack_range); } if(ack_range_list) { axutil_array_list_free(ack_range_list, env); } seq_closed_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, seq_id, SANDESHA2_SEQ_PROP_SEQ_CLOSED); if(seq_closed_bean) { str_value = sandesha2_seq_property_bean_get_value(seq_closed_bean, env); } if(seq_closed_bean && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, str_value)) { axis2_bool_t is_allowed = AXIS2_FALSE; /* sequence is closed. so add the 'Final' part. */ is_allowed = sandesha2_spec_specific_consts_is_ack_final_allowed(env, rm_version); if(is_allowed) { sandesha2_ack_final_t *ack_final = NULL; ack_final = sandesha2_ack_final_create(env,rm_ns_value); sandesha2_seq_ack_set_ack_final(seq_ack, env, ack_final); } } if(seq_closed_bean) { sandesha2_seq_property_bean_free(seq_closed_bean, env); } sandesha2_msg_ctx_set_seq_ack(target_rm_msg_ctx, env, seq_ack); soap_header = axiom_soap_envelope_get_header(envelope, env); sandesha2_seq_ack_to_om_node(seq_ack, env, soap_header); ack_req_action = sandesha2_msg_ctx_get_wsa_action(target_rm_msg_ctx, env); if((!ack_req_action) || (!axutil_strcmp(ack_req_action, ""))) { ack_req_action = sandesha2_spec_specific_consts_get_seq_ack_action(env, rm_version); sandesha2_msg_ctx_set_wsa_action(target_rm_msg_ctx, env, ack_req_action); } temp_action = sandesha2_spec_specific_consts_get_seq_ack_soap_action(env, rm_version); ack_req_soap_action = axutil_string_create(env, temp_action); if(ack_req_soap_action) { sandesha2_msg_ctx_set_soap_action(target_rm_msg_ctx, env, ack_req_soap_action); axutil_string_free(ack_req_soap_action, env); } uuid = axutil_uuid_gen(env); sandesha2_msg_ctx_set_msg_id(target_rm_msg_ctx, env, uuid); if(uuid) { AXIS2_FREE(env->allocator, uuid); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_msg_creator_add_ack_msg"); return AXIS2_SUCCESS; }
static axis2_status_t axiom_stax_builder_process_namespaces( axiom_stax_builder_t * om_builder, const axutil_env_t * env, axiom_node_t * node, int is_soap_element) { axis2_status_t status = AXIS2_SUCCESS; int namespace_count = 0; axiom_namespace_t *om_ns = NULL; axiom_element_t *om_ele = NULL; /* temp values */ axis2_char_t *tmp_prefix = NULL; axis2_char_t *tmp_ns_prefix = NULL; axis2_char_t *tmp_ns_uri = NULL; axutil_string_t *tmp_ns_prefix_str = NULL; axutil_string_t *tmp_ns_uri_str = NULL; int i = 0; om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env); namespace_count = axiom_xml_reader_get_namespace_count(om_builder->parser, env); for(i = 1; i <= namespace_count; ++i) { tmp_ns_prefix = axiom_xml_reader_get_namespace_prefix_by_number(om_builder->parser, env, i); tmp_ns_uri = axiom_xml_reader_get_namespace_uri_by_number(om_builder->parser, env, i); #ifdef AXIS2_LIBXML2_ENABLED tmp_ns_prefix_str = axutil_string_create(env, tmp_ns_prefix); tmp_ns_uri_str = axutil_string_create(env, tmp_ns_uri); #else tmp_ns_prefix_str = axutil_string_create_assume_ownership(env, &tmp_ns_prefix); tmp_ns_uri_str = axutil_string_create_assume_ownership(env, &tmp_ns_uri); #endif if(!tmp_ns_prefix || axutil_strcmp(tmp_ns_prefix, "xmlns") == 0) { /* default namespace case. !temp_ns_prefix is for guththila */ if(tmp_ns_prefix_str) { axutil_string_free(tmp_ns_prefix_str, env); } tmp_ns_prefix_str = axutil_string_create(env, ""); om_ns = axiom_namespace_create_str(env, tmp_ns_uri_str, tmp_ns_prefix_str); if(!om_ns) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create namespace"); return AXIS2_FAILURE; } status = axiom_element_declare_namespace(om_ele, env, node, om_ns); if(!status) { axiom_namespace_free(om_ns, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error when declaring namespace"); return AXIS2_FAILURE; } } else { axis2_char_t *prefix = NULL; om_ns = axiom_namespace_create_str(env, tmp_ns_uri_str, tmp_ns_prefix_str); if(!om_ns) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create namespace"); return AXIS2_FAILURE; } status = axiom_element_declare_namespace(om_ele, env, node, om_ns); prefix = axiom_namespace_get_prefix(om_ns, env); axutil_hash_set(om_builder->declared_namespaces, prefix, AXIS2_HASH_KEY_STRING, om_ns); } axutil_string_free(tmp_ns_uri_str, env); axutil_string_free(tmp_ns_prefix_str, env); #ifdef AXIS2_LIBXML2_ENABLED axiom_xml_reader_xml_free(om_builder->parser, env, tmp_ns_uri); axiom_xml_reader_xml_free(om_builder->parser, env, tmp_ns_prefix); #endif } /* set own namespace */ tmp_prefix = axiom_xml_reader_get_prefix(om_builder->parser, env); if(tmp_prefix) { om_ns = axutil_hash_get(om_builder->declared_namespaces, tmp_prefix, AXIS2_HASH_KEY_STRING); if(om_ns) { axiom_element_set_namespace(om_ele, env, om_ns, node); } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_DOCUMENT_STATE_UNDEFINED_NAMESPACE, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error when setting namespace"); return AXIS2_FAILURE; } axiom_xml_reader_xml_free(om_builder->parser, env, tmp_prefix); } return status; }
static axis2_status_t AXIS2_CALL axis2_addr_disp_invoke( axis2_handler_t * handler, const axutil_env_t * env, struct axis2_msg_ctx *msg_ctx) { axis2_relates_to_t *relates_to = NULL; relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env); /** first check if we can dispatch using the relates_to */ if(relates_to) { const axis2_char_t *relates_to_value = NULL; relates_to_value = axis2_relates_to_get_value(relates_to, env); if(relates_to_value && axutil_strcmp(relates_to_value, "") != 0) { axis2_conf_ctx_t *conf_ctx = NULL; conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(conf_ctx) { axis2_op_ctx_t *op_ctx = NULL; const axis2_char_t *msg_id = axis2_msg_ctx_get_msg_id(msg_ctx, env); op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, msg_id); if(op_ctx) { axis2_op_t *op = NULL; op = axis2_op_ctx_get_op(op_ctx, env); if(op) { axis2_svc_ctx_t *svc_ctx = NULL; axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx); axis2_msg_ctx_set_op(msg_ctx, env, op); axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx); svc_ctx = axis2_op_ctx_get_parent(op_ctx, env); if(svc_ctx) { axis2_svc_t *svc = NULL; axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); svc = axis2_svc_ctx_get_svc(svc_ctx, env); if(svc) { axis2_msg_ctx_set_svc(msg_ctx, env, svc); } svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env); if(svc_grp_ctx) { axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env, axis2_svc_grp_ctx_get_id(svc_grp_ctx, env)); axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); axutil_string_free(svc_grp_ctx_id_str, env); } return AXIS2_SUCCESS; } } } } } } axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_addr_disp_find_svc); axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_addr_disp_find_op); return axis2_disp_find_svc_and_op(handler, env, msg_ctx); }
AXIS2_EXTERN axis2_svc_grp_ctx_t *AXIS2_CALL axis2_conf_ctx_fill_ctxs( axis2_conf_ctx_t * conf_ctx, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axis2_char_t *svc_grp_ctx_id = NULL; axis2_svc_grp_ctx_t *svc_grp_ctx = NULL; axis2_svc_ctx_t *svc_ctx = NULL; axis2_svc_t *svc = NULL; axis2_svc_grp_t *svc_grp = NULL; const axutil_qname_t *qname = NULL; axis2_char_t *svc_id = NULL; axis2_op_ctx_t *op_ctx = NULL; AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(!svc) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_NOT_YET_FOUND, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service not yet found in message context. Cannot proceed"); return NULL; } qname = axis2_svc_get_qname(svc, env); if(!qname) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); return NULL; } svc_id = axutil_qname_get_localpart(qname, env); if(!svc_id) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service found in message context has no name."); return NULL; } svc_grp = axis2_svc_get_parent(svc, env); if(svc_grp) { svc_grp_ctx_id = (axis2_char_t *)axis2_svc_grp_get_name(svc_grp, env); } if(!svc_grp_ctx_id) { svc_grp_ctx_id = (axis2_char_t *)axutil_string_get_buffer(axis2_msg_ctx_get_svc_grp_ctx_id( msg_ctx, env), env); } /* By this time service group context id must have a value, either from transport or from * addressing */ if(svc_grp_ctx_id) { svc_grp_ctx = (axis2_svc_grp_ctx_t *)axutil_hash_get(conf_ctx->svc_grp_ctx_map, svc_grp_ctx_id, AXIS2_HASH_KEY_STRING); if(svc_grp_ctx) { svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); if(!svc_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service group context has no servie context set for service %s", svc_id); return NULL; } } } if(!svc_grp_ctx_id) { svc_grp_ctx_id = axutil_uuid_gen(env); if(svc_grp_ctx_id) { axutil_string_t *svc_grp_ctx_id_str = axutil_string_create_assume_ownership(env, &svc_grp_ctx_id); axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str); axutil_string_free(svc_grp_ctx_id_str, env); } } if(!svc_grp_ctx) { axis2_svc_grp_t *svc_group; svc_group = axis2_svc_get_parent(svc, env); svc_grp_ctx = axis2_svc_grp_get_svc_grp_ctx(svc_group, env, conf_ctx); svc_ctx = axis2_svc_grp_ctx_get_svc_ctx(svc_grp_ctx, env, svc_id); if(!svc_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC_GRP, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service group context has no servie context set for service %s", svc_id); return NULL; } axis2_svc_grp_ctx_set_id(svc_grp_ctx, env, svc_grp_ctx_id); axis2_conf_ctx_register_svc_grp_ctx(conf_ctx, env, svc_grp_ctx_id, svc_grp_ctx); } /* When you come here operation context MUST have already been assigned to the message context */ op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); if(!op_ctx) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_MSG_CTX, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation context not set for message context"); return NULL; } axis2_op_ctx_set_parent(op_ctx, env, svc_ctx); axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx); axis2_msg_ctx_set_svc_grp_ctx(msg_ctx, env, svc_grp_ctx); return svc_grp_ctx; }
axis2_status_t AXIS2_CALL sandesha2_out_handler_invoke( struct axis2_handler *handler, const axutil_env_t *env, struct axis2_msg_ctx *msg_ctx) { axutil_property_t *temp_prop = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axis2_char_t *str_done = NULL; axis2_char_t *dummy_msg_str = NULL; axis2_bool_t dummy_msg = AXIS2_FALSE; axis2_svc_t *svc = NULL; axutil_qname_t *module_qname = NULL; sandesha2_msg_ctx_t *rm_msg_ctx = NULL; sandesha2_msg_processor_t *msg_processor = NULL; int msg_type = -1; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_out_handler_invoke"); temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_SEQ_PROP_MAKE_CONNECTION_OUT_PATH); if (temp_prop) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] In make connection out path. So return here."); return AXIS2_SUCCESS; temp_prop = NULL; } if(sandesha2_util_is_rstr_msg(env, msg_ctx)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] A RSTR message. Sandesha don't process."); return AXIS2_SUCCESS; } conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(!conf_ctx) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Configuration Context is NULL"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } svc = axis2_msg_ctx_get_svc(msg_ctx, env); if(!svc) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Axis2 Service is NULL"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SVC_NULL, AXIS2_FAILURE); return AXIS2_FAILURE; } module_qname = axutil_qname_create(env, SANDESHA2_MODULE, NULL, NULL); if(!axis2_svc_is_module_engaged(svc, env, module_qname)) { if(module_qname) { axutil_qname_free(module_qname, env); } AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]RM is not engaged. So return here"); return AXIS2_SUCCESS; } if(module_qname) { axutil_qname_free(module_qname, env); } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE); if(temp_prop) { str_done = (axis2_char_t *) axutil_property_get_value(temp_prop, env); } if(str_done && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, str_done)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2]Application Processing Done. So return here."); return AXIS2_SUCCESS; } temp_prop = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, temp_prop); conf = axis2_conf_ctx_get_conf(conf_ctx, env); if(!sandesha2_permanent_storage_mgr_create_db(env, conf_ctx)) { return AXIS2_FAILURE; } /* Getting rm message */ rm_msg_ctx = sandesha2_msg_init_init_msg(env, msg_ctx); temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_DUMMY_MESSAGE); if(NULL != temp_prop) { dummy_msg_str = (axis2_char_t *) axutil_property_get_value(temp_prop, env); } if(dummy_msg_str && 0 == axutil_strcmp(AXIS2_VALUE_TRUE, dummy_msg_str)) { dummy_msg = AXIS2_TRUE; } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_SVC_CLIENT_CLOSED); if(temp_prop) { axis2_char_t *spec_version = NULL; axis2_endpoint_ref_t *reply_to = axis2_msg_ctx_get_reply_to(msg_ctx, env); if(reply_to) { axis2_char_t *address = axis2_endpoint_ref_get_address(reply_to, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to_address:%s", address); } spec_version = sandesha2_utils_get_rm_version(env, msg_ctx); if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, spec_version)) { axis2_char_t *action = NULL; axutil_string_t *str_action = NULL; action = sandesha2_spec_specific_consts_get_terminate_seq_action(env, spec_version); str_action = axutil_string_create(env, action); axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action); axutil_string_free(str_action, env); /*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/ msg_type = sandesha2_msg_ctx_set_msg_type(rm_msg_ctx, env, SANDESHA2_MSG_TYPE_CLOSE_SEQ); } else if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_0, spec_version)) { axutil_property_t *property = NULL; axutil_string_t *str_action = NULL; /*axis2_msg_info_headers_set_action(axis2_msg_ctx_get_msg_info_headers(msg_ctx, env), * env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); */ str_action = axutil_string_create(env, SANDESHA2_SPEC_2005_02_SOAP_ACTION_LAST_MESSAGE); axis2_msg_ctx_set_soap_action(msg_ctx, env, str_action); axutil_string_free(str_action, env); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, "Sandesha2LastMessage", property); /*axis2_msg_ctx_set_reply_to(msg_ctx, env, NULL);*/ } } msg_type = sandesha2_msg_ctx_get_msg_type(rm_msg_ctx, env); if(msg_type == SANDESHA2_MSG_TYPE_UNKNOWN) { axis2_msg_ctx_t *req_msg_ctx = NULL; axis2_op_ctx_t *op_ctx = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); req_msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); if(req_msg_ctx) /* For the server side */ { sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL; sandesha2_seq_t *seq_part = NULL; req_rm_msg_ctx = sandesha2_msg_init_init_msg(env, req_msg_ctx); seq_part = sandesha2_msg_ctx_get_sequence(req_rm_msg_ctx, env); if(seq_part) { msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env); /* rm intended msg */ } if(req_rm_msg_ctx) sandesha2_msg_ctx_free(req_rm_msg_ctx, env); } else if(!axis2_msg_ctx_get_server_side(msg_ctx, env)) { msg_processor = (sandesha2_msg_processor_t *) sandesha2_app_msg_processor_create(env); } } else { msg_processor = sandesha2_msg_processor_create_msg_processor(env, rm_msg_ctx); } if(msg_processor) { sandesha2_msg_processor_process_out_msg(msg_processor, env, rm_msg_ctx); sandesha2_msg_processor_free(msg_processor, env); } if(AXIS2_SUCCESS != AXIS2_ERROR_GET_STATUS_CODE(env->error)) { /* Message should not be sent in an exception situation */ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Pausing message context"); axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE); if(rm_msg_ctx) { sandesha2_msg_ctx_free(rm_msg_ctx, env); } AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Error in processing the message"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_PROCESS_MSG, AXIS2_FAILURE); return AXIS2_FAILURE; } temp_prop = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE); if(temp_prop) { axutil_property_set_value(temp_prop, env, AXIS2_VALUE_FALSE); } if(rm_msg_ctx) { sandesha2_msg_ctx_free(rm_msg_ctx, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_out_handler_invoke"); return AXIS2_SUCCESS; }
/** * Create a new create_seq_msg * @param env * @param application_rm_msg * @param internal_seq_id * @param acks_to * @param seq_prop_mgr * @return sandesha2_msg_ctx_t */ sandesha2_msg_ctx_t *AXIS2_CALL sandesha2_msg_creator_create_create_seq_msg( const axutil_env_t *env, sandesha2_msg_ctx_t *application_rm_msg, axis2_char_t *internal_seq_id, axis2_char_t *acks_to, sandesha2_seq_property_mgr_t *seq_prop_mgr) { axis2_msg_ctx_t *application_msg_ctx = NULL; axis2_msg_ctx_t *create_seq_msg_ctx = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_op_t *app_msg_op_desc = NULL; axis2_op_ctx_t *op_ctx = NULL; axis2_char_t *create_seq_msg_id = NULL; axis2_char_t *rm_version = NULL; axis2_char_t *rm_ns_value = NULL; axis2_char_t *addressing_ns_value = NULL; axis2_char_t *anonymous_uri = NULL; axis2_char_t *temp_value = NULL; axis2_char_t *temp_action = NULL; axutil_string_t *temp_soap_action = NULL; axis2_endpoint_ref_t *to_epr = NULL; axis2_endpoint_ref_t *temp_to = NULL; axis2_endpoint_ref_t *acks_to_epr = NULL; axis2_endpoint_ref_t *temp_reply_to = NULL; sandesha2_create_seq_t *create_seq_part = NULL; sandesha2_seq_property_bean_t *reply_to_bean = NULL; sandesha2_seq_property_bean_t *to_bean = NULL; sandesha2_msg_ctx_t *create_seq_rm_msg = NULL; sandesha2_address_t *temp_address = NULL; sandesha2_acks_to_t *temp_acks_to = NULL; axutil_property_t *property = NULL; const axis2_char_t *reply_to_address = NULL; application_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(application_rm_msg, env); if(!application_msg_ctx) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_APPLICATION_MSG_NULL, AXIS2_FAILURE); return NULL; } conf_ctx = axis2_msg_ctx_get_conf_ctx(application_msg_ctx, env); if(!conf_ctx) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE); return NULL; } /* Creating by copying common contents. */ create_seq_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, application_rm_msg); sandesha2_msg_creator_init_creation(env, application_msg_ctx, create_seq_msg_ctx); create_seq_msg_id = axutil_uuid_gen(env); axis2_msg_ctx_set_message_id(create_seq_msg_ctx, env, create_seq_msg_id); AXIS2_FREE(env->allocator, create_seq_msg_id); app_msg_op_desc = axis2_msg_ctx_get_op(application_msg_ctx, env); property = axis2_msg_ctx_get_property(application_msg_ctx, env, AXIS2_TARGET_EPR); if(property) { temp_to = axutil_property_get_value(property, env); to_epr = axis2_endpoint_ref_create(env, axis2_endpoint_ref_get_address(temp_to, env)); } if (!to_epr) { temp_to = sandesha2_msg_ctx_get_to(application_rm_msg, env); if (temp_to) { to_epr = axis2_endpoint_ref_create(env, axis2_endpoint_ref_get_address(temp_to, env)); } } if (to_epr) { axis2_msg_ctx_set_to(create_seq_msg_ctx, env, to_epr); to_epr = NULL; } temp_reply_to = sandesha2_msg_ctx_get_reply_to(application_rm_msg, env); if(temp_reply_to) { axis2_endpoint_ref_t *reply_to_epr = NULL; reply_to_address = axis2_endpoint_ref_get_address(temp_reply_to, env); reply_to_epr = axis2_endpoint_ref_create(env, reply_to_address); if(reply_to_epr) { axis2_msg_ctx_set_reply_to(create_seq_msg_ctx, env, reply_to_epr); } } create_seq_rm_msg = sandesha2_msg_ctx_create(env, create_seq_msg_ctx); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "create_seq_internal_seq_id:%s", internal_seq_id); rm_version = sandesha2_utils_get_rm_version(env, application_msg_ctx); if(!rm_version) { AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_RM_VERSION_OF_GIVEN_MSG, AXIS2_FAILURE); return NULL; } rm_ns_value = sandesha2_spec_specific_consts_get_rm_ns_val(env, rm_version); addressing_ns_value = sandesha2_utils_get_seq_property(env, internal_seq_id, SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, seq_prop_mgr); create_seq_part = sandesha2_create_seq_create(env, addressing_ns_value, rm_ns_value); if(!create_seq_part) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] creating create sequence message failed"); return NULL; } /* Adding sequence offer if present */ op_ctx = axis2_msg_ctx_get_op_ctx(application_msg_ctx, env); if(op_ctx) { axis2_op_t *operation = NULL; int mep = -1; axis2_char_t *offered_seq_id = NULL; /*axutil_property_t *property = NULL; axis2_ctx_t *ctx = NULL; ctx = axis2_msg_ctx_get_base(application_msg_ctx, env); property = axis2_ctx_get_property(ctx, env, SANDESHA2_CLIENT_OFFERED_SEQ_ID); if(property) { offered_seq_id = axutil_property_get_value(property, env); }*/ operation = axis2_op_ctx_get_op(op_ctx, env); mep = axis2_op_get_axis_specific_mep_const(operation, env); if(mep == AXIS2_MEP_CONSTANT_OUT_IN) { offered_seq_id = axutil_uuid_gen(env); } /*if(offered_seq_id && 0 != axutil_strcmp("", offered_seq_id))*/ if(offered_seq_id) { sandesha2_seq_offer_t *offer_part = NULL; sandesha2_identifier_t *identifier = NULL; sandesha2_endpoint_t *endpoint = NULL; offer_part = sandesha2_seq_offer_create(env, rm_ns_value, addressing_ns_value); identifier = sandesha2_identifier_create(env, rm_ns_value); sandesha2_identifier_set_identifier(identifier, env, offered_seq_id); sandesha2_seq_offer_set_identifier(offer_part, env, identifier); if(!axutil_strcmp(SANDESHA2_SPEC_VERSION_1_1, rm_version)) { axis2_endpoint_ref_t *reply_to_epr = NULL; sandesha2_address_t *address = NULL; reply_to_epr = axis2_endpoint_ref_create(env, reply_to_address); address = sandesha2_address_create(env, addressing_ns_value, reply_to_epr); endpoint = sandesha2_endpoint_create(env, address, rm_ns_value, addressing_ns_value); sandesha2_seq_offer_set_endpoint(offer_part, env, endpoint); } sandesha2_create_seq_set_seq_offer(create_seq_part, env, offer_part); } } reply_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR); to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_seq_id, SANDESHA2_SEQ_PROP_TO_EPR); if (to_bean) { temp_value = sandesha2_seq_property_bean_get_value(to_bean, env); if (temp_value) { to_epr = axis2_endpoint_ref_create(env, temp_value); } sandesha2_seq_property_bean_free(to_bean, env); } anonymous_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addressing_ns_value); if(reply_to_bean) { axis2_endpoint_ref_t *reply_to_epr = NULL; temp_value = sandesha2_seq_property_bean_get_value(reply_to_bean, env); if(temp_value) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "dam_reply_to:%s", temp_value); reply_to_epr = axis2_endpoint_ref_create(env, temp_value); acks_to = axutil_strdup(env, temp_value); } if(reply_to_epr) { sandesha2_msg_ctx_set_reply_to(create_seq_rm_msg, env, reply_to_epr); } sandesha2_seq_property_bean_free(reply_to_bean, env); } if(!acks_to || !axutil_strcmp("", acks_to)) { acks_to = axutil_strdup(env, anonymous_uri); } acks_to_epr = axis2_endpoint_ref_create(env, acks_to); temp_to = sandesha2_msg_ctx_get_to(create_seq_rm_msg, env); if(!temp_to && to_epr) { sandesha2_msg_ctx_set_to(create_seq_rm_msg, env, to_epr); } else { axis2_endpoint_ref_free(to_epr, env); } temp_address = sandesha2_address_create(env, addressing_ns_value, acks_to_epr); temp_acks_to = sandesha2_acks_to_create(env, temp_address, rm_ns_value, addressing_ns_value); if(addressing_ns_value) { AXIS2_FREE(env->allocator, addressing_ns_value); } sandesha2_create_seq_set_acks_to(create_seq_part, env, temp_acks_to); sandesha2_msg_ctx_set_create_seq(create_seq_rm_msg, env, create_seq_part); sandesha2_msg_ctx_add_soap_envelope(create_seq_rm_msg, env); temp_action = sandesha2_spec_specific_consts_get_create_seq_action(env, rm_version); sandesha2_msg_ctx_set_wsa_action(create_seq_rm_msg, env, temp_action); temp_soap_action = axutil_string_create(env, temp_action); if(temp_soap_action) { sandesha2_msg_ctx_set_soap_action(create_seq_rm_msg, env, temp_soap_action); axutil_string_free(temp_soap_action, env); } /*sandesha2_msg_creator_finalize_creation(env, application_msg_ctx, create_seq_msg_ctx);*/ return create_seq_rm_msg; }
adb_getResponse_t* AXIS2_CALL axis2_stub_op_IIp2Location_get( axis2_stub_t *stub, const axutil_env_t *env, adb_get_t* _get) { axis2_svc_client_t *svc_client = NULL; axis2_options_t *options = NULL; axiom_node_t *ret_node = NULL; const axis2_char_t *soap_action = NULL; axutil_qname_t *op_qname = NULL; axiom_node_t *payload = NULL; axis2_bool_t is_soap_act_set = AXIS2_TRUE; axutil_string_t *soap_act = NULL; adb_getResponse_t* ret_val; payload = adb_get_serialize(_get, env, NULL, NULL, AXIS2_TRUE, NULL, NULL); svc_client = axis2_stub_get_svc_client(stub, env ); options = axis2_stub_get_options( stub, env); if (NULL == options) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "options is null in stub"); return (adb_getResponse_t*)NULL; } soap_act = axis2_options_get_soap_action( options, env ); if (NULL == soap_act) { is_soap_act_set = AXIS2_FALSE; soap_action = "urn:get"; soap_act = axutil_string_create(env, "urn:get"); axis2_options_set_soap_action(options, env, soap_act); } axis2_options_set_soap_version(options, env, AXIOM_SOAP12); ret_node = axis2_svc_client_send_receive_with_op_qname( svc_client, env, op_qname, payload); if (!is_soap_act_set) { axis2_options_set_soap_action(options, env, NULL); axis2_options_set_action( options, env, NULL); } if(soap_act) { axutil_string_free(soap_act, env); } if ( NULL == ret_node ) { return (adb_getResponse_t*)NULL; } ret_val = adb_getResponse_create(env); if(adb_getResponse_deserialize(ret_val, env, &ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE) { if(ret_val != NULL) { adb_getResponse_free(ret_val, env); } AXIS2_LOG_ERROR( env->log, AXIS2_LOG_SI, "NULL returnted from the adb_getResponse_deserialize: " "This should be due to an invalid XML"); return (adb_getResponse_t*)NULL; } return ret_val; }
static axis2_status_t axiom_stax_builder_process_attributes( axiom_stax_builder_t * om_builder, const axutil_env_t * env, axiom_node_t * element_node) { int i = 0; int attribute_count; axiom_element_t *om_ele = NULL; om_ele = (axiom_element_t *)axiom_node_get_data_element(element_node, env); attribute_count = axiom_xml_reader_get_attribute_count(om_builder->parser, env); for(i = 1; i <= attribute_count; ++i) { axiom_namespace_t *ns = NULL; axis2_char_t *uri = NULL; axis2_char_t *prefix = NULL; axis2_char_t *attr_name = NULL; axis2_char_t *attr_value = NULL; uri = axiom_xml_reader_get_attribute_namespace_by_number(om_builder-> parser, env, i); prefix = axiom_xml_reader_get_attribute_prefix_by_number(om_builder->parser, env, i); if(uri && (axutil_strcmp(uri, "") != 0)) { ns = axiom_element_find_namespace(om_ele, env, element_node, uri, prefix); if(!ns) { /* if namespace is not defined yet, create it */ ns = axiom_namespace_create(env, uri, prefix); } } if(uri) { axiom_xml_reader_xml_free(om_builder->parser, env, uri); } if(prefix) { axiom_xml_reader_xml_free(om_builder->parser, env, prefix); } attr_name = axiom_xml_reader_get_attribute_name_by_number(om_builder->parser, env, i); attr_value = axiom_xml_reader_get_attribute_value_by_number(om_builder->parser, env, i); if(attr_name) { axutil_string_t *attr_name_str = NULL; axutil_string_t *attr_value_str = NULL; axiom_attribute_t *attribute = NULL; #ifdef AXIS2_LIBXML2_ENABLED attr_name_str = axutil_string_create(env, attr_name); attr_value_str = axutil_string_create(env, attr_value); axiom_xml_reader_xml_free(om_builder->parser, env, attr_name); axiom_xml_reader_xml_free(om_builder->parser, env, attr_value); #else attr_name_str = axutil_string_create_assume_ownership(env, &attr_name); attr_value_str = axutil_string_create_assume_ownership(env, &attr_value); #endif attribute = axiom_attribute_create_str(env, attr_name_str, attr_value_str, ns); axutil_string_free(attr_name_str, env); axutil_string_free(attr_value_str, env); if(!attribute) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot create attribute"); return AXIS2_FAILURE; } if(axiom_element_add_attribute(om_ele, env, attribute, element_node) != AXIS2_SUCCESS) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Cannot add attribute to element"); return AXIS2_FAILURE; } } } return AXIS2_SUCCESS; }