/*Public functions*/ AXIS2_EXTERN axis2_status_t AXIS2_CALL rampart_shb_ensure_sec_header_order(const axutil_env_t *env, axis2_msg_ctx_t *msg_ctx, rampart_context_t *rampart_context, axiom_node_t* sec_node) { axis2_bool_t signature_protection = AXIS2_FALSE; axis2_bool_t is_encrypt_before_sign = AXIS2_FALSE; axiom_node_t *sig_node = NULL; axiom_node_t *enc_key_node = NULL; axiom_node_t *ref_list_node = NULL; axiom_node_t *h_node = NULL; axutil_array_list_t *dk_list = NULL; axutil_array_list_t *enc_key_list = NULL; axiom_node_t* first_protection_item = NULL; int i = 0; signature_protection = rampart_context_is_encrypt_signature(rampart_context, env); is_encrypt_before_sign = rampart_context_is_encrypt_before_sign(rampart_context, env); dk_list = axutil_array_list_create(env, 5); enc_key_list = axutil_array_list_create(env, 2); h_node = axiom_node_get_first_child(sec_node, env); while(h_node) { if(0 == axutil_strcmp(OXS_NODE_DERIVED_KEY_TOKEN, axiom_util_get_localname(h_node, env)) || (0 == axutil_strcmp(OXS_NODE_BINARY_SECURITY_TOKEN, axiom_util_get_localname(h_node, env)))) { axutil_array_list_add(dk_list, env, h_node); } else if((0 == axutil_strcmp(OXS_NODE_ENCRYPTED_KEY, axiom_util_get_localname(h_node, env))) || (0 == axutil_strcmp(OXS_NODE_SECURITY_CONTEXT_TOKEN, axiom_util_get_localname(h_node, env)))) { axutil_array_list_add(enc_key_list, env, h_node); } h_node = axiom_node_get_next_sibling(h_node, env); } ref_list_node = oxs_axiom_get_first_child_node_by_name(env, sec_node, OXS_NODE_REFERENCE_LIST, OXS_ENC_NS, NULL); sig_node = oxs_axiom_get_first_child_node_by_name(env, sec_node, OXS_NODE_SIGNATURE, OXS_DSIG_NS, NULL); /*Ensure the protection order in the header*/ if(sig_node && ref_list_node) { if(is_encrypt_before_sign) { int no_of_sig_node = 0; /*Encrypt->Sig <Sig><RefList>*/ oxs_axiom_interchange_nodes(env, sig_node, ref_list_node ); first_protection_item = sig_node; no_of_sig_node = oxs_axiom_get_number_of_children_with_qname(env, sec_node, OXS_NODE_SIGNATURE, OXS_DSIG_NS, NULL); if(no_of_sig_node > 1) { axiom_node_t* cur_node = NULL; cur_node = axiom_node_get_first_child(sec_node, env); while(cur_node) { axis2_char_t *cur_local_name = NULL; cur_local_name = axiom_util_get_localname(cur_node, env); if(0 == axutil_strcmp(cur_local_name, OXS_NODE_SIGNATURE)) { oxs_axiom_interchange_nodes(env, cur_node, ref_list_node); } cur_node = axiom_node_get_next_sibling(cur_node, env); } } } else { /*Sig->Encrypt <RefList> <Sig>*/ oxs_axiom_interchange_nodes(env, ref_list_node, sig_node ); first_protection_item = ref_list_node; } } else if(sig_node) { first_protection_item = sig_node; } else { first_protection_item = ref_list_node; } /*makesure enc_key_node is appearing before first protection item*/ if(first_protection_item) { for(i = 0; i < axutil_array_list_size(enc_key_list, env); i++) { axiom_node_t *tmp_node = NULL; tmp_node = (axiom_node_t*)axutil_array_list_get(enc_key_list, env, i); enc_key_node = axiom_node_detach_without_namespaces(tmp_node, env); axiom_node_insert_sibling_before(first_protection_item, env, enc_key_node); } } /* * If there are derived keys, make sure they come after the EncryptedKey/security context token 1. First we get all the derived keys 2. Then we attach after the EncryptedKey(hidden sessionkey)/security context token 3. If key is not available, then attach derived keys before sig_node and ref_list_node (whichever is first) */ if(enc_key_node) { for(i = 0; i < axutil_array_list_size(dk_list, env); i++) { axiom_node_t *dk_node = NULL; axiom_node_t *tmp_node = NULL; dk_node = (axiom_node_t*)axutil_array_list_get(dk_list, env, i); tmp_node = axiom_node_detach(dk_node, env); axiom_node_insert_sibling_after(enc_key_node, env, tmp_node); } } else { if(first_protection_item) { for(i = 0; i < axutil_array_list_size(dk_list, env); i++) { axiom_node_t *dk_node = NULL; axiom_node_t *tmp_node = NULL; dk_node = (axiom_node_t*)axutil_array_list_get(dk_list, env, i); tmp_node = axiom_node_detach(dk_node, env); axiom_node_insert_sibling_before(first_protection_item, env, tmp_node); } } } axutil_array_list_free(dk_list, env); axutil_array_list_free(enc_key_list, env); return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_msg_ctx_t * AXIS2_CALL axis2_engine_create_fault_msg_ctx( axis2_engine_t * engine, const axutil_env_t * env, axis2_msg_ctx_t * processing_context, const axis2_char_t * code_value, const axis2_char_t * reason_text) { axis2_msg_ctx_t *fault_ctx = NULL; axis2_endpoint_ref_t *fault_to = NULL; axis2_endpoint_ref_t *reply_to = NULL; axutil_stream_t *stream = NULL; axiom_soap_envelope_t *envelope = NULL; const axis2_char_t *wsa_action = NULL; const axis2_char_t *msg_id = NULL; axis2_relates_to_t *relates_to = NULL; axis2_char_t *msg_uuid = NULL; axis2_msg_info_headers_t *msg_info_headers = NULL; axis2_bool_t doing_rest = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, processing_context, NULL); if(axis2_msg_ctx_get_process_fault(processing_context, env)) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PROCESSING_FAULT_ALREADY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating fault message contex failed"); return NULL; } fault_ctx = axis2_msg_ctx_create(env, engine->conf_ctx, axis2_msg_ctx_get_transport_in_desc( processing_context, env), axis2_msg_ctx_get_transport_out_desc(processing_context, env)); axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); fault_to = axis2_msg_ctx_get_fault_to(processing_context, env); if(fault_to) { const axis2_char_t *address = axis2_endpoint_ref_get_address(fault_to, env); if(!address) { fault_to = NULL; } else if(axutil_strcmp(AXIS2_WSA_NONE_URL, address) == 0 || axutil_strcmp( AXIS2_WSA_NONE_URL_SUBMISSION, address) == 0) { reply_to = axis2_msg_ctx_get_reply_to(processing_context, env); if(reply_to) { axis2_msg_ctx_set_fault_to(fault_ctx, env, reply_to); } else { axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); } } else { axis2_msg_ctx_set_fault_to(fault_ctx, env, fault_to); } } stream = axis2_msg_ctx_get_transport_out_stream(processing_context, env); if(stream) { axis2_msg_ctx_set_transport_out_stream(fault_ctx, env, stream); axis2_msg_ctx_reset_transport_out_stream(processing_context, env); } if(!fault_to && !stream) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NOWHERE_TO_SEND_FAULT, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap fault target destination not found"); return NULL; } /* Set WSA action */ msg_info_headers = axis2_msg_ctx_get_msg_info_headers(processing_context, env); if(msg_info_headers) { wsa_action = axis2_msg_info_headers_get_action(msg_info_headers, env); if(wsa_action) { /* We have to use the action set by user, cannot use the default always. wsa_action = "http://www.w3.org/2005/08/addressing/fault"; */ axis2_msg_ctx_set_wsa_action(fault_ctx, env, wsa_action); } } /* Set relates to */ msg_id = axis2_msg_ctx_get_msg_id(processing_context, env); /* we can create with default Relates to namespace. Actual namespace based on addressing version will be created in addressing out handler */ relates_to = axis2_relates_to_create(env, msg_id, AXIS2_WSA_RELATES_TO_RELATIONSHIP_TYPE_DEFAULT_VALUE); axis2_msg_ctx_set_relates_to(fault_ctx, env, relates_to); /* Set msg id */ msg_uuid = axutil_uuid_gen(env); axis2_msg_ctx_set_message_id(fault_ctx, env, msg_uuid); if(msg_uuid) { AXIS2_FREE(env->allocator, msg_uuid); msg_uuid = NULL; } /** Copy the property map from the current message context to the newly created fault message context. */ { axis2_ctx_t *ctx = axis2_msg_ctx_get_base(processing_context, env); axis2_ctx_t *fault_base_ctx = axis2_msg_ctx_get_base(fault_ctx, env); if(ctx && fault_ctx) { axis2_ctx_set_property_map(fault_base_ctx, env, axis2_ctx_get_property_map(ctx, env)); } } axis2_msg_ctx_set_op_ctx(fault_ctx, env, axis2_msg_ctx_get_op_ctx(processing_context, env)); axis2_msg_ctx_set_process_fault(fault_ctx, env, AXIS2_TRUE); axis2_msg_ctx_set_server_side(fault_ctx, env, AXIS2_TRUE); envelope = axis2_msg_ctx_get_fault_soap_envelope(processing_context, env); if(!envelope) { if(axis2_msg_ctx_get_is_soap_11(processing_context, env)) { envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, reason_text, AXIOM_SOAP11, NULL, NULL); } else { envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, code_value, reason_text, AXIOM_SOAP12, NULL, NULL); } if(!envelope) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Creating default soap envelope failed"); return NULL; } } else { axis2_msg_ctx_set_fault_soap_envelope(processing_context, env, NULL); } doing_rest = axis2_msg_ctx_get_doing_rest(processing_context, env); axis2_msg_ctx_set_doing_rest(fault_ctx, env, doing_rest); axis2_msg_ctx_set_soap_envelope(fault_ctx, env, envelope); axis2_msg_ctx_set_out_transport_info(fault_ctx, env, axis2_msg_ctx_get_out_transport_info( processing_context, env)); axis2_msg_ctx_reset_out_transport_info(processing_context, env); return fault_ctx; }
axiom_node_t* AXIS2_CALL adb_SecurityConfigExceptionE0_serialize_obj( adb_SecurityConfigExceptionE0_t* _SecurityConfigExceptionE0, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _SecurityConfigExceptionE0, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://service.config.security.carbon.wso2.org", "n"); axutil_hash_set(namespaces, "http://service.config.security.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "SecurityConfigException", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.config.security.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://service.config.security.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://service.config.security.carbon.wso2.org", p_prefix)); } if (!_SecurityConfigExceptionE0->is_valid_SecurityConfigException) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("SecurityConfigException"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("SecurityConfigException"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing SecurityConfigException element */ sprintf(start_input_str, "<%s%sSecurityConfigException", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sSecurityConfigException>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); if(!adb_SecurityConfigException_is_particle()) { axutil_stream_write(stream, env, start_input_str, start_input_str_len); } adb_SecurityConfigException_serialize(_SecurityConfigExceptionE0->property_SecurityConfigException, env, current_node, parent_element, adb_SecurityConfigException_is_particle() || AXIS2_FALSE, namespaces, next_ns_index); if(!adb_SecurityConfigException_is_particle()) { axutil_stream_write(stream, env, end_input_str, end_input_str_len); } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
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; /* Set up the environment */ env = axutil_env_create_all("echo_blocking_addr_amqp.log", AXIS2_LOG_LEVEL_TRACE); /* Set end point reference of echo service */ address = "amqp://localhost:5672/axis2/services/echo"; if (argc > 1) address = argv[1]; if (axutil_strcmp(address, "-h") == 0) { printf("Usage : %s [endpoint_url]\n", argv[0]); printf("use -h for help\n"); return 0; } printf("Using endpoint : %s\n", address); /* 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_action(options, env, "http://ws.apache.org/axis2/c/samples/echoString"); /* Set up deploy folder. It is from the deploy folder, the configuration is picked up * using the axis2.xml file. * In this sample client_home points to the Axis2/C default deploy folder. The client_home can * be different from this folder on your system. For example, you may have a different folder * (say, my_client_folder) with its own axis2.xml file. my_client_folder/modules will have the * modules that the client uses */ 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); /* Engage addressing module */ axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING); /* Build the SOAP request message payload using OM API. */ payload = build_om_payload_for_echo_svc(env); /* Send request */ ret_node = axis2_svc_client_send_receive(svc_client, env, payload); if (ret_node) { axis2_char_t *om_str = NULL; om_str = axiom_node_to_string(ret_node, env); if (om_str) { printf("\nReceived OM : %s\n", om_str); AXIS2_FREE(env->allocator, om_str); } printf("\necho client invoke SUCCESSFUL!\n"); } 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("echo 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; }
axiom_node_t* AXIS2_CALL adb_engageModuleForService_serialize_obj( adb_engageModuleForService_t* _engageModuleForService, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *text_value_2; axis2_char_t *text_value_2_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _engageModuleForService, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://service.mgt.module.carbon.wso2.org", "n"); axutil_hash_set(namespaces, "http://service.mgt.module.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "engageModuleForService", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.module.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://service.mgt.module.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://service.mgt.module.carbon.wso2.org", p_prefix)); } if (!_engageModuleForService->is_valid_moduleId) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("moduleId"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("moduleId"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing moduleId element */ sprintf(start_input_str, "<%s%smoduleId>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%smoduleId>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_1 = _engageModuleForService->property_moduleId; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.module.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://service.mgt.module.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://service.mgt.module.carbon.wso2.org", p_prefix)); } if (!_engageModuleForService->is_valid_serviceName) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("serviceName"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("serviceName"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing serviceName element */ sprintf(start_input_str, "<%s%sserviceName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sserviceName>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_2 = _engageModuleForService->property_serviceName; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE); if (text_value_2_temp) { axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp)); AXIS2_FREE(env->allocator, text_value_2_temp); } else { axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
axis2_status_t AXIS2_CALL adb_IncorrectStatusTypeException_deserialize( adb_IncorrectStatusTypeException_t* _IncorrectStatusTypeException, 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, _IncorrectStatusTypeException, 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 IncorrectStatusTypeException : " "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_IncorrectStatusTypeException_set_message(_IncorrectStatusTypeException, 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_IncorrectStatusTypeException_set_message(_IncorrectStatusTypeException, 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 __euca_authenticate(const axutil_env_t *env,axis2_msg_ctx_t *out_msg_ctx, axis2_op_ctx_t *op_ctx) { //***** First get the message context before doing anything dumb w/ a NULL pointer *****/ axis2_msg_ctx_t *msg_ctx = NULL; //<--- incoming msg context, it is NULL, see? msg_ctx = axis2_op_ctx_get_msg_ctx(op_ctx, env, AXIS2_WSDL_MESSAGE_LABEL_IN); //***** Print everything from the security results, just for testing now *****// rampart_context_t *rampart_context = NULL; axutil_property_t *property = NULL; property = axis2_msg_ctx_get_property(msg_ctx, env, RAMPART_CONTEXT); if(property) { rampart_context = (rampart_context_t *)axutil_property_get_value(property, env); // AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," ======== PRINTING PROCESSED WSSEC TOKENS ======== "); rampart_print_security_processed_results_set(env,msg_ctx); } //***** Extract Security Node from header from enveloper from msg_ctx *****// axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_header_t *soap_header = NULL; axiom_node_t *sec_node = NULL; soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_envelope) NO_U_FAIL("SOAP envelope cannot be found."); soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if (!soap_header) NO_U_FAIL("SOAP header cannot be found."); sec_node = rampart_get_security_header(env, msg_ctx, soap_header); // <---- here it is! if(!sec_node)NO_U_FAIL("No node wsse:Security -- required: ws-security"); //***** Find the wsse:Reference to the BinarySecurityToken *****// //** Path is: Security/ //** *sec_node must be non-NULL, kkthx **// axiom_node_t *sig_node = NULL; axiom_node_t *key_info_node = NULL; axiom_node_t *sec_token_ref_node = NULL; /** the ds:Signature node **/ sig_node = oxs_axiom_get_first_child_node_by_name(env,sec_node, OXS_NODE_SIGNATURE, OXS_DSIG_NS, OXS_DS ); if(!sig_node)NO_U_FAIL("No node ds:Signature -- required: signature"); /** the ds:KeyInfo **/ key_info_node = oxs_axiom_get_first_child_node_by_name(env, sig_node, OXS_NODE_KEY_INFO, OXS_DSIG_NS, NULL ); if(!key_info_node)NO_U_FAIL("No node ds:KeyInfo -- required: signature key"); /** the wsse:SecurityTokenReference **/ sec_token_ref_node = oxs_axiom_get_first_child_node_by_name(env, key_info_node,OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, NULL); if(!sec_token_ref_node)NO_U_FAIL("No node wsse:SecurityTokenReference -- required: signing token"); //** in theory this is the branching point for supporting all kinds of tokens -- we only do BST Direct Reference **/ //***** Find the wsse:Reference to the BinarySecurityToken *****// //** *sec_token_ref_node must be non-NULL **/ axis2_char_t *ref = NULL; axis2_char_t *ref_id = NULL; axiom_node_t *token_ref_node = NULL; axiom_node_t *bst_node = NULL; /** the wsse:Reference node **/ token_ref_node = oxs_axiom_get_first_child_node_by_name(env, sec_token_ref_node,OXS_NODE_REFERENCE, OXS_WSSE_XMLNS, NULL); /** pull out the name of the BST node **/ ref = oxs_token_get_reference(env, token_ref_node); ref_id = axutil_string_substring_starting_at(axutil_strdup(env, ref), 1); /** get the wsse:BinarySecurityToken used to sign the message **/ bst_node = oxs_axiom_get_node_by_id(env, sec_node, "Id", ref_id, OXS_WSU_XMLNS); if(!bst_node){oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Error retrieving elementwith ID=%s", ref_id);NO_U_FAIL("Cant find the required node");} //***** Find the wsse:Reference to the BinarySecurityToken *****// //** *bst_node must be non-NULL **/ axis2_char_t *data = NULL; oxs_x509_cert_t *_cert = NULL; oxs_x509_cert_t *recv_cert = NULL; axis2_char_t *file_name = NULL; axis2_char_t *recv_x509_buf = NULL; axis2_char_t *msg_x509_buf = NULL; /** pull out the data from the BST **/ data = oxs_axiom_get_node_content(env, bst_node); /** create an oxs_X509_cert **/ _cert = oxs_key_mgr_load_x509_cert_from_string(env, data); if(_cert) { //***** FINALLY -- we have the certificate used to sign the message. authenticate it HERE *****// msg_x509_buf = oxs_x509_cert_get_data(_cert,env); if(!msg_x509_buf)NO_U_FAIL("OMG WHAT NOW?!"); /* recv_x509_buf = (axis2_char_t *)rampart_context_get_receiver_certificate(rampart_context, env); if(recv_x509_buf) recv_cert = oxs_key_mgr_load_x509_cert_from_string(env, recv_x509_buf); else { file_name = rampart_context_get_receiver_certificate_file(rampart_context, env); if(!file_name) NO_U_FAIL("Policy for the service is incorrect -- ReceiverCertificate is not set!!"); if (check_file(file_name)) NO_U_FAIL("No cert file ($EUCALYPTUS/var/lib/eucalyptus/keys/cloud-cert.pem) found, failing"); recv_cert = oxs_key_mgr_load_x509_cert_from_pem_file(env, file_name); } */ file_name = rampart_context_get_receiver_certificate_file(rampart_context, env); if(!file_name) NO_U_FAIL("Policy for the service is incorrect -- ReceiverCertificate is not set!!"); if (check_file(file_name)) NO_U_FAIL("No cert file ($EUCALYPTUS/var/lib/eucalyptus/keys/cloud-cert.pem) found, failing"); recv_cert = oxs_key_mgr_load_x509_cert_from_pem_file(env, file_name); if (recv_cert) { recv_x509_buf = oxs_x509_cert_get_data(recv_cert,env); } else { NO_U_FAIL("could not populate receiver cert"); } if( axutil_strcmp(recv_x509_buf,msg_x509_buf)!=0){ AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," --------- Received x509 certificate value ---------" ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI, msg_x509_buf ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," --------- Local x509 certificate value! ---------" ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI, recv_x509_buf ); AXIS2_LOG_CRITICAL(env->log,AXIS2_LOG_SI," ---------------------------------------------------" ); NO_U_FAIL("The certificate specified is invalid!"); } if(verify_references(sig_node, env, out_msg_ctx, soap_envelope, rampart_context) == AXIS2_FAILURE) { return AXIS2_FAILURE; } } else { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_DEFAULT, "Cannot load certificate from string =%s", data); NO_U_FAIL("Failed to build certificate from BinarySecurityToken"); } oxs_x509_cert_free(_cert, env); oxs_x509_cert_free(recv_cert, env); return AXIS2_SUCCESS; }
/* * Since we have received the terminate sequence message we determine the last in message which * arrived prior to this terminate message. Then we mark it as the last message. We also determine if * an out message is already sent related to that highest in comming message. If so then we determine * whether we have received ack messages for them. If so send the terminate sequence message. */ static axis2_status_t AXIS2_CALL sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums( const axutil_env_t *env, axis2_conf_ctx_t *conf_ctx, sandesha2_storage_mgr_t *storage_mgr, axis2_char_t *seq_id, sandesha2_msg_ctx_t *rm_msg_ctx, sandesha2_seq_property_mgr_t *seq_prop_mgr, sandesha2_create_seq_mgr_t *create_seq_mgr, sandesha2_sender_mgr_t *sender_mgr) { axis2_char_t *highest_in_msg_num_str = NULL; axis2_char_t *highest_in_msg_id = NULL; long highest_in_msg_num = 0; long highest_out_msg_num = 0; axis2_char_t *rec_side_int_seq_id = NULL; axis2_bool_t add_rec_side_term = AXIS2_FALSE; axis2_char_t *out_seq_id = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Entry:sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums"); AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, storage_mgr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, seq_prop_mgr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, create_seq_mgr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, sender_mgr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); /* Message number of the highest in comming message so far */ highest_in_msg_num_str = sandesha2_utils_get_seq_property(env, seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER, seq_prop_mgr); /* Message id of the highest in comming message so far */ highest_in_msg_id = sandesha2_utils_get_seq_property(env, seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_ID, seq_prop_mgr); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Highest_in_msg_num_str:%s", highest_in_msg_num_str); if(highest_in_msg_num_str) { if(!highest_in_msg_id) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] highest in msg id has not been stored"); if(highest_in_msg_num_str) { AXIS2_FREE(env->allocator, highest_in_msg_num_str); } return AXIS2_FAILURE; } highest_in_msg_num = atol(highest_in_msg_num_str); if(highest_in_msg_num_str) { AXIS2_FREE(env->allocator, highest_in_msg_num_str); } } rec_side_int_seq_id = sandesha2_utils_get_internal_sequence_id(env, seq_id); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] rec_side_int_seq_id:%s", rec_side_int_seq_id); if(0 == highest_in_msg_num) { add_rec_side_term = AXIS2_FALSE; } else { /* Mark up the highest inbound message as if it had the last message * flag on it. We can do this because we have received the terminate sequence message. So * we can treat the highest in-comming message as the last message. */ sandesha2_seq_property_bean_t *last_in_msg_bean = NULL; axis2_char_t *highest_out_relates_to = NULL; last_in_msg_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id, SANDESHA2_SEQ_PROP_LAST_IN_MESSAGE_ID, highest_in_msg_id); if(last_in_msg_bean) { sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, last_in_msg_bean); sandesha2_seq_property_bean_free(last_in_msg_bean, env); } /* If an outbound message has already gone out which relates to the highest in message id, * then we can terminate right away. */ highest_out_relates_to = sandesha2_utils_get_seq_property(env, rec_side_int_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_OUT_RELATES_TO, seq_prop_mgr); if(highest_out_relates_to && 0 == axutil_strcmp(highest_out_relates_to, highest_in_msg_id)) { axis2_char_t *highest_out_msg_num_str = NULL; highest_out_msg_num_str = sandesha2_utils_get_seq_property(env, rec_side_int_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_OUT_MSG_NUMBER, seq_prop_mgr); highest_out_msg_num = atol(highest_out_msg_num_str); add_rec_side_term = AXIS2_TRUE; if(highest_out_msg_num_str) { AXIS2_FREE(env->allocator, highest_out_msg_num_str); } } if(highest_out_relates_to) { AXIS2_FREE(env->allocator, highest_out_relates_to); } } if(highest_in_msg_id) { AXIS2_FREE(env->allocator, highest_in_msg_id); } AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] add_rec_side_term:%d", add_rec_side_term); out_seq_id = sandesha2_utils_get_seq_property(env, rec_side_int_seq_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_SEQUENCE_ID, seq_prop_mgr); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] out_seq_id:%s", out_seq_id); if(rec_side_int_seq_id) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] rec_side_int_seq_id:%s", rec_side_int_seq_id); } AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] highest_out_msg_num:%d", highest_out_msg_num); /*if(add_rec_side_term && highest_out_msg_num > 0 && rec_side_int_seq_id && out_seq_id)*/ if(/*highest_out_msg_num > 0 &&*/ rec_side_int_seq_id && out_seq_id) { axis2_bool_t all_acked = AXIS2_FALSE; all_acked = sandesha2_utils_is_all_msgs_acked_upto(env, highest_out_msg_num, rec_side_int_seq_id, seq_prop_mgr); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] all_acked:%d", all_acked); if(!all_acked) { all_acked = sandesha2_utils_is_all_msgs_acked_upto(env, highest_out_msg_num, out_seq_id, seq_prop_mgr); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] all_acked:%d", all_acked); } if(all_acked) { sandesha2_terminate_mgr_send_terminate_seq_msg(env, rm_msg_ctx, out_seq_id, rec_side_int_seq_id, storage_mgr, seq_prop_mgr, create_seq_mgr, sender_mgr); } } if(rec_side_int_seq_id) { AXIS2_FREE(env->allocator, rec_side_int_seq_id); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums"); return AXIS2_SUCCESS; }
/** * This function is invoked in RM 1.1 where client explicitly send the * terminate sequence message */ static axis2_status_t AXIS2_CALL sandesha2_terminate_seq_msg_processor_process_out_msg( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { axis2_msg_ctx_t *msg_ctx = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_storage_mgr_t *storage_mgr = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_create_seq_mgr_t *create_seq_mgr = NULL; sandesha2_sender_mgr_t *sender_mgr = NULL; axis2_char_t *to_address = NULL; axis2_char_t *seq_key = NULL; axis2_char_t *int_seq_id = NULL; axis2_char_t *out_seq_id = NULL; axutil_property_t *property = NULL; axis2_char_t *terminated = NULL; axis2_op_t *old_op = NULL; axis2_op_t *out_in_op = NULL; axutil_qname_t *qname = NULL; sandesha2_terminate_seq_t *term_seq_part = NULL; axis2_char_t *rm_version = NULL; axis2_char_t *transport_to = NULL; sandesha2_seq_property_bean_t *term_added = NULL; axis2_char_t *temp_action = NULL; axutil_string_t *soap_action = NULL; axis2_char_t *dbname = NULL; AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_terminate_seq_msg_processor_process_out_msg."); msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname); if(!storage_mgr) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager."); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER, AXIS2_FAILURE); return AXIS2_FAILURE; } seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); create_seq_mgr = sandesha2_permanent_create_seq_mgr_create(env, dbname); sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname); to_address = (axis2_char_t*)axis2_endpoint_ref_get_address(axis2_msg_ctx_get_to(msg_ctx, env), env); property = axis2_msg_ctx_get_property(msg_ctx, env, SANDESHA2_CLIENT_SEQ_KEY); if(property) { seq_key = axutil_property_get_value(property, env); } int_seq_id = sandesha2_utils_get_client_internal_sequence_id(env, to_address, seq_key); out_seq_id = sandesha2_utils_get_seq_property(env, int_seq_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_SEQUENCE_ID, seq_prop_mgr); if(!out_seq_id) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]seq_id was not found. Cannot send the terminate message"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_SEQ_ID, AXIS2_FAILURE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } terminated = sandesha2_utils_get_seq_property(env, int_seq_id, SANDESHA2_SEQ_PROP_TERMINATE_ADDED, seq_prop_mgr); old_op = axis2_msg_ctx_get_op(msg_ctx, env); qname = axutil_qname_create(env, "temp", NULL, NULL); out_in_op = axis2_op_create_with_qname(env, qname); if(qname) { axutil_qname_free(qname, env); } axis2_op_set_msg_exchange_pattern(out_in_op, env, AXIS2_MEP_URI_OUT_IN); axis2_op_set_in_flow(out_in_op, env, axis2_op_get_in_flow(old_op, env)); if(terminated && !axutil_strcmp(terminated, AXIS2_VALUE_TRUE)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate was added previously"); if(terminated) { AXIS2_FREE(env->allocator, terminated); } if(out_seq_id) { AXIS2_FREE(env->allocator, out_seq_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_SUCCESS; } if(terminated) { AXIS2_FREE(env->allocator, terminated); } term_seq_part = sandesha2_msg_ctx_get_terminate_seq(rm_msg_ctx, env); sandesha2_identifier_set_identifier(sandesha2_terminate_seq_get_identifier(term_seq_part, env), env, out_seq_id); sandesha2_msg_ctx_set_flow(rm_msg_ctx, env, AXIS2_OUT_FLOW); property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE); axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_APPLICATION_PROCESSING_DONE, property); axis2_msg_ctx_set_to(msg_ctx, env, axis2_endpoint_ref_create(env, to_address)); rm_version = sandesha2_utils_get_rm_version(env, msg_ctx); if(!rm_version) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cant find the rm_version of the given message"); if(out_seq_id) { AXIS2_FREE(env->allocator, out_seq_id); } if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_FAILURE; } axis2_msg_ctx_set_wsa_action(msg_ctx, env, sandesha2_spec_specific_consts_get_terminate_seq_action(env, rm_version)); temp_action = sandesha2_spec_specific_consts_get_terminate_seq_soap_action(env, rm_version); soap_action = axutil_string_create(env, temp_action); axis2_msg_ctx_set_soap_action(msg_ctx, env, soap_action); transport_to = sandesha2_utils_get_seq_property(env, int_seq_id, SANDESHA2_SEQ_PROP_TRANSPORT_TO, seq_prop_mgr); if(transport_to) { axis2_msg_ctx_set_transport_url(msg_ctx, env, transport_to); AXIS2_FREE(env->allocator, transport_to); } if(!sandesha2_util_is_ack_already_piggybacked(env, rm_msg_ctx)) { sandesha2_ack_mgr_piggyback_acks_if_present(env, out_seq_id, rm_msg_ctx, storage_mgr, seq_prop_mgr, sender_mgr); } term_added = sandesha2_seq_property_bean_create(env); sandesha2_seq_property_bean_set_name(term_added, env, SANDESHA2_SEQ_PROP_TERMINATE_ADDED); sandesha2_seq_property_bean_set_seq_id(term_added, env, int_seq_id); if(out_seq_id) { AXIS2_FREE(env->allocator, out_seq_id); } sandesha2_seq_property_bean_set_value(term_added, env, AXIS2_VALUE_TRUE); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, term_added); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2] Exit:sandesha2_terminate_seq_msg_processor_process_out_msg"); 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; axis2_callback_t *callback = NULL; int count = 0; /* Set up the environment */ env = axutil_env_create_all("echo_non_blocking.log", AXIS2_LOG_LEVEL_TRACE); /* Set end point reference of echo service */ address = "http://localhost:9090/axis2/services/echo"; if (argc > 1) address = argv[1]; if (axutil_strcmp(address, "-h") == 0) { printf("Usage : %s [endpoint_url]\n", argv[0]); printf("use -h for help\n"); return 0; } printf("Using endpoint : %s\n", address); /* 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); /* Set up deploy folder. It is from the deploy folder, the configuration is picked up * using the axis2.xml file. * In this sample client_home points to the Axis2/C default deploy folder. The client_home can * be different from this folder on your system. For example, you may have a different folder * (say, my_client_folder) with its own axis2.xml file. my_client_folder/modules will have the * modules that the client uses */ client_home = AXIS2_GETENV("AXIS2C_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 AXIS2C_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_om_payload_for_echo_svc(env); /* Create the callback object with default on_complete and on_error callback functions */ callback = axis2_callback_create(env); /* Set our on_complete fucntion pointer to the callback object */ /*axis2_callback_set_on_complete(callback, echo_callback_on_complete);*/ /* Set our on_error function pointer to the callback object */ axis2_callback_set_on_error(callback, echo_callback_on_error); /* Send request */ axis2_svc_client_send_receive_non_blocking(svc_client, env, payload, callback); /** Wait till callback is complete. Simply keep the parent thread running until our on_complete or on_error is invoked */ while(!axis2_callback_get_complete(callback, env)) { AXIS2_SLEEP(1); if(count < 30) { count++; } else { printf("\necho client invoke FAILED. Counter timed out.\n"); } } echo_process_response_envelope(callback, env); if(svc_client) axis2_svc_client_free(svc_client, env); if (env) { axutil_env_free((axutil_env_t *) env); env = NULL; } return 0; }
static axis2_status_t AXIS2_CALL sandesha2_terminate_seq_msg_processor_process_in_msg ( sandesha2_msg_processor_t *msg_processor, const axutil_env_t *env, sandesha2_msg_ctx_t *rm_msg_ctx) { axis2_msg_ctx_t *terminate_msg_ctx = NULL; sandesha2_terminate_seq_t *term_seq = NULL; axis2_char_t *rmd_sequence_id = NULL; axis2_conf_ctx_t *conf_ctx = NULL; sandesha2_storage_mgr_t *storage_mgr = NULL; sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL; sandesha2_create_seq_mgr_t *create_seq_mgr = NULL; sandesha2_sender_mgr_t *sender_mgr = NULL; sandesha2_next_msg_mgr_t *next_msg_mgr = NULL; sandesha2_msg_ctx_t *fault_ctx = NULL; axis2_char_t *spec_version = NULL; axis2_char_t *dbname = NULL; sandesha2_seq_ack_t *seq_ack = NULL; axis2_op_ctx_t *op_ctx = NULL; /*sandesha2_seq_property_bean_t *term_rcvd_bean = NULL;*/ AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Entry:sandesha2_terminate_seq_msg_processor_process_in_msg"); AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE); terminate_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env); if(axis2_msg_ctx_get_server_side(terminate_msg_ctx, env)) { axis2_msg_ctx_t **msg_ctx_map = NULL; op_ctx = axis2_msg_ctx_get_op_ctx(terminate_msg_ctx, env); msg_ctx_map = axis2_op_ctx_get_msg_ctx_map(op_ctx, env); msg_ctx_map[AXIS2_WSDL_MESSAGE_LABEL_IN] = terminate_msg_ctx; } term_seq = sandesha2_msg_ctx_get_terminate_seq(rm_msg_ctx, env); if(!term_seq) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate Sequence part is not available"); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING, AXIS2_FAILURE); return AXIS2_FAILURE; } rmd_sequence_id = sandesha2_identifier_get_identifier(sandesha2_terminate_seq_get_identifier( term_seq, env), env); if(!rmd_sequence_id || 0 == axutil_strlen(rmd_sequence_id)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Invalid sequence id"); return AXIS2_FAILURE; } conf_ctx = axis2_msg_ctx_get_conf_ctx(terminate_msg_ctx, env); dbname = sandesha2_util_get_dbname(env, conf_ctx); storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname); if(!storage_mgr) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager."); AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER, AXIS2_FAILURE); return AXIS2_FAILURE; } seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname); create_seq_mgr = sandesha2_permanent_create_seq_mgr_create(env, dbname); sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname); next_msg_mgr = sandesha2_permanent_next_msg_mgr_create(env, dbname); fault_ctx = sandesha2_fault_mgr_check_for_unknown_seq(env, rm_msg_ctx, rmd_sequence_id, seq_prop_mgr, create_seq_mgr, next_msg_mgr); if(fault_ctx) { axis2_engine_t *engine = NULL; engine = axis2_engine_create(env, conf_ctx); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Send fault occurred"); axis2_engine_send_fault(engine, env, sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)); sandesha2_msg_ctx_free(fault_ctx, env); if(engine) { axis2_engine_free(engine, env); } axis2_msg_ctx_set_paused(terminate_msg_ctx, env, AXIS2_TRUE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } return AXIS2_SUCCESS; } /*term_rcvd_bean = sandesha2_seq_property_bean_create(env); sandesha2_seq_property_bean_set_seq_id(term_rcvd_bean, env, rmd_sequence_id); sandesha2_seq_property_bean_set_name(term_rcvd_bean, env, SANDESHA2_SEQ_PROP_TERMINATE_RECEIVED); sandesha2_seq_property_bean_set_value(term_rcvd_bean, env, AXIS2_VALUE_TRUE); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, term_rcvd_bean);*/ spec_version = sandesha2_msg_ctx_get_rm_spec_ver(rm_msg_ctx, env); if(sandesha2_spec_specific_consts_is_term_seq_res_reqd(env, spec_version)) { sandesha2_terminate_seq_msg_processor_add_terminate_seq_res(env, rm_msg_ctx, rmd_sequence_id, seq_prop_mgr); } seq_ack = sandesha2_msg_ctx_get_seq_ack(rm_msg_ctx, env); /* If we have received a sequence acknowldegment with the incoming terminate message then we may * decide to send the terminate sequence message. */ if(seq_ack) { axis2_char_t *internal_sequence_id = NULL; axis2_char_t *rms_sequence_id = NULL; axis2_char_t *last_out_msg_no_str = NULL; long highest_out_msg_no = 0; sandesha2_seq_property_bean_t *terminated_bean = NULL; /* If there is a sequence acknowledgement element present in the sequence we will check * whether the sequence is completed. If so send a terminate sequence message. */ rms_sequence_id = sandesha2_identifier_get_identifier(sandesha2_seq_ack_get_identifier( seq_ack, env), env); internal_sequence_id = sandesha2_utils_get_seq_property(env, rms_sequence_id, SANDESHA2_SEQUENCE_PROPERTY_OUTGOING_INTERNAL_SEQUENCE_ID, seq_prop_mgr); terminated_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, internal_sequence_id, SANDESHA2_SEQ_PROP_TERMINATE_ADDED); if(terminated_bean) { axis2_char_t *value = sandesha2_seq_property_bean_get_value(terminated_bean, env); if(value && !axutil_strcmp(AXIS2_VALUE_TRUE, value)) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate sequence message was added previously"); } sandesha2_seq_property_bean_free(terminated_bean, env); } else { /* Retrieve the message number of the RM 1.0 last message */ last_out_msg_no_str = sandesha2_utils_get_seq_property(env, internal_sequence_id, SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO, seq_prop_mgr); if(last_out_msg_no_str) { highest_out_msg_no = atol(last_out_msg_no_str); if(last_out_msg_no_str) { AXIS2_FREE(env->allocator, last_out_msg_no_str); } } else { highest_out_msg_no = sandesha2_app_msg_processor_get_prev_msg_no(env, internal_sequence_id, seq_prop_mgr); } if(highest_out_msg_no > 0) { axis2_bool_t completed = AXIS2_FALSE; axutil_array_list_t *ack_range_list = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] highest_out_msg_no:%ld", highest_out_msg_no); ack_range_list = sandesha2_seq_ack_get_ack_range_list(seq_ack, env); completed = sandesha2_ack_mgr_verify_seq_completion(env, ack_range_list, highest_out_msg_no); if(completed) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Sequence %s is completed. So adding terminate msg", rms_sequence_id); sandesha2_terminate_mgr_send_terminate_seq_msg(env, rm_msg_ctx, rms_sequence_id, internal_sequence_id, storage_mgr, seq_prop_mgr, create_seq_mgr, sender_mgr); } } if(internal_sequence_id) { AXIS2_FREE(env->allocator, internal_sequence_id); } } } else { sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums(env, conf_ctx, storage_mgr, rmd_sequence_id, rm_msg_ctx, seq_prop_mgr, create_seq_mgr, sender_mgr); } /*sandesha2_terminate_mgr_clean_recv_side_after_terminate_msg(env, conf_ctx, rmd_sequence_id, storage_mgr, seq_prop_mgr, next_msg_mgr);*/ /*transmit_bean = sandesha2_seq_property_bean_create_with_data(env, rmd_sequence_id, SANDESHA2_SEQ_PROP_SEQ_TERMINATED, AXIS2_VALUE_TRUE); sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, transmit_bean); sandesha2_seq_mgr_update_last_activated_time(env, rmd_sequence_id, storage_mgr); */ /* We have no intention to pass this message beyond Sandesha2/C handler. So pause the message * context */ sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE); if(seq_prop_mgr) { sandesha2_seq_property_mgr_free(seq_prop_mgr, env); } if(create_seq_mgr) { sandesha2_create_seq_mgr_free(create_seq_mgr, env); } if(sender_mgr) { sandesha2_sender_mgr_free(sender_mgr, env); } if(next_msg_mgr) { sandesha2_next_msg_mgr_free(next_msg_mgr, env); } if(storage_mgr) { sandesha2_storage_mgr_free(storage_mgr, env); } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[sandesha2]Exit:sandesha2_terminate_seq_msg_processor_process_in_msg"); return AXIS2_SUCCESS; }
axiom_node_t* AXIS2_CALL adb_contentItem_type0_serialize_obj( adb_contentItem_type0_t* _contentItem_type0, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_attribute_t *text_attri = NULL; axis2_char_t *string_to_stream; axiom_node_t* current_node = NULL; int tag_closed = 0; axis2_char_t* xsi_prefix = NULL; axiom_namespace_t* xsi_ns = NULL; axiom_attribute_t* xsi_type_attri = NULL; axis2_char_t* type_attrib = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *text_value_2; axis2_char_t *text_value_2_temp; axis2_char_t *text_value_3; axis2_char_t *text_value_3_temp; axis2_char_t *text_value = NULL; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _contentItem_type0, NULL); current_node = parent; data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env); if (!data_source) return NULL; stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */ if (!stream) return NULL; if(!parent_tag_closed) { if(_contentItem_type0->is_valid_id) { p_prefix = NULL; text_value = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * (5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT + axutil_strlen(_contentItem_type0->property_id) + axutil_strlen("id"))); sprintf(text_value, " %s%s%s=\"%s\"", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":"", "id", _contentItem_type0->property_id); axutil_stream_write(stream, env, text_value, axutil_strlen(text_value)); AXIS2_FREE(env-> allocator, text_value); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute id"); return NULL; } if(_contentItem_type0->is_valid_lastModifiedDate) { p_prefix = NULL; text_value = axutil_date_time_serialize_date_time(_contentItem_type0->property_lastModifiedDate, env); string_to_stream = (axis2_char_t*) AXIS2_MALLOC (env-> allocator, sizeof (axis2_char_t) * (5 + ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT + axutil_strlen(text_value) + axutil_strlen("lastModifiedDate"))); sprintf(string_to_stream, " %s%s%s=\"%s\"", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":"", "lastModifiedDate", text_value); axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream)); AXIS2_FREE(env-> allocator, string_to_stream); } string_to_stream = ">"; axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream)); tag_closed = 1; } if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://www.daisy.org/ns/daisy-online/", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://www.daisy.org/ns/daisy-online/", p_prefix)); } if (!_contentItem_type0->is_valid_label) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property label"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("label"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("label"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing label element */ sprintf(start_input_str, "<%s%slabel", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%slabel>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); if(!adb_label_type0_is_particle()) { axutil_stream_write(stream, env, start_input_str, start_input_str_len); } adb_label_type0_serialize(_contentItem_type0->property_label, env, current_node, parent_element, adb_label_type0_is_particle() || AXIS2_FALSE, namespaces, next_ns_index); if(!adb_label_type0_is_particle()) { axutil_stream_write(stream, env, end_input_str, end_input_str_len); } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(parent_tag_closed) { if(_contentItem_type0->is_valid_id) { p_prefix = NULL; ns1 = NULL; text_value = _contentItem_type0->property_id; text_attri = axiom_attribute_create (env, "id", text_value, ns1); axiom_element_add_attribute (parent_element, env, text_attri, parent); } else { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-optional attribute id"); return NULL; } } if(parent_tag_closed) { if(_contentItem_type0->is_valid_lastModifiedDate) { p_prefix = NULL; ns1 = NULL; text_value = axutil_date_time_serialize_date_time(_contentItem_type0->property_lastModifiedDate, env); text_attri = axiom_attribute_create (env, "lastModifiedDate", text_value, ns1); axiom_element_add_attribute (parent_element, env, text_attri, parent); } } return parent; }
/* This is the function where threads start running */ void *AXIS2_THREAD_FUNC axis2_udp_receiver_thread_worker_func( axutil_thread_t * thd, void *data) { const axutil_env_t *env = NULL; axis2_status_t status = AXIS2_FAILURE; axis2_conf_t *conf = NULL; axis2_svc_t *svc = NULL; axis2_udp_recv_thd_args_t *args = NULL; axis2_udp_response_t response; axutil_hash_index_t *hi = NULL; axutil_hash_t *ori_all_svcs = NULL, *all_svcs = NULL; void *val = NULL; args = (axis2_udp_recv_thd_args_t *) data; env = (axutil_env_t *) args->env; conf = axis2_conf_ctx_get_conf(args->conf_ctx, env); /* Get all the service discriptions */ ori_all_svcs = axis2_conf_get_all_svcs(conf, env); if (!ori_all_svcs) { return NULL; } all_svcs = axutil_hash_copy(ori_all_svcs, env); if (args->is_multicast) { /* If multicast we go through every service and try to figure out weather they are accepting multicast messages. If a service accepts a multicast message we send the request to that service bypassing the normal dispatchers. Dispatchers cannot be used since no dispatching information is found in the multicast messages */ for (hi = axutil_hash_first(all_svcs, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); svc = (axis2_svc_t *) val; if (svc) { axutil_param_t *param = NULL; axis2_char_t *param_val = NULL; /* Get the Multicast accept parameter from the services.xml */ param = axis2_svc_get_param(svc, env, AXIS2_UDP_MULTICAST_ACCEPT); if (!param) { continue; } /* check weather this service accepts multicast requests */ param_val = axutil_param_get_value(param, env); if (!param_val || !axutil_strcmp(param_val, "false") || axutil_strcmp(param_val, "true")) { continue; } response.buf_size = 0; response.buff = NULL; /* set the service to the request. This will bypass the dispatches */ args->request.svc = svc; /* Process the request */ status = axis2_udp_receiver_process_request(args->env, args->conf_ctx, &args->request, &response); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error processing the request."); return NULL; } /* If we have a response send it */ if (response.buff) { status = axutil_network_handler_send_dgram(env, args->send_socket, response.buff, &response.buf_size, args->req_addr, args->req_port, NULL); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error sending the response."); return NULL; } } } } } else { axis2_ctx_t *ctx = NULL; axutil_property_t *prop = NULL; axis2_udp_backchannel_info_t *binfo = NULL; ctx = axis2_conf_ctx_get_base(args->conf_ctx, env); prop = axis2_ctx_get_property(ctx, env, AXIS2_UDP_BACKCHANNEL_INFO); if (prop) { binfo = axutil_property_get_value(prop, env); } /* Unicast case. In this case message contains dispatching information. * So we send the request in the normal way */ response.buf_size = 0; response.buff = NULL; if (binfo) { args->request.svc = binfo->svc; args->request.op = binfo->op; } /* Process the request */ status = axis2_udp_receiver_process_request(args->env, args->conf_ctx, &args->request, &response); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error processing the request."); return NULL; } /* If we have a response send it */ if (response.buff) { status = axutil_network_handler_send_dgram(env, args->send_socket, response.buff, &response.buf_size, args->req_addr, args->req_port, NULL); if (status == AXIS2_FAILURE) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error sending the response."); return NULL; } } } return NULL; }
axiom_node_t* AXIS2_CALL adb_Signature_serialize_obj( adb_Signature_t* _Signature, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axis2_char_t* xsi_prefix = NULL; axiom_namespace_t* xsi_ns = NULL; axiom_attribute_t* xsi_type_attri = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _Signature, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://www.w3.org/2000/09/xmldsig#", "n"); axutil_hash_set(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "Signature", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://www.w3.org/2000/09/xmldsig#", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://www.w3.org/2000/09/xmldsig#", p_prefix)); } if (!_Signature->is_valid_Signature) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property Signature"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("Signature"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("Signature"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing Signature element */ sprintf(start_input_str, "<%s%sSignature", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sSignature>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); adb_SignatureType_serialize(_Signature->property_Signature, env, current_node, parent_element, adb_SignatureType_is_particle() || AXIS2_TRUE, namespaces, next_ns_index); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_http_client_send( axis2_http_client_t * client, const axutil_env_t * env, axis2_http_simple_request_t * request, axis2_char_t * ssl_pp) { char *wire_format = NULL; axutil_array_list_t *headers = NULL; char *str_header = NULL; char *str_request_line = NULL; int written = 0; axis2_status_t status = AXIS2_FAILURE; axis2_bool_t chunking_enabled = AXIS2_FALSE; axis2_char_t *host = NULL; unsigned int port = 0; /* In the MTOM case request body is not set. Instead mime_parts array_list is there */ /*if(client->req_body) { AXIS2_FREE(env->allocator, client->req_body); client->req_body = NULL; }*/ if(!client->req_body && !(client->doing_mtom)) { client->req_body_size = axis2_http_simple_request_get_body_bytes(request, env, &client->req_body); } if(client->dump_input_msg == AXIS2_TRUE) { return AXIS2_SUCCESS; } if(!client->url) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_URL, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Request url not set"); return AXIS2_FAILURE; } host = axutil_url_get_host(client->url, env); port = axutil_url_get_port(client->url, env); if(client->proxy_enabled) { if(!client->proxy_host || client->proxy_port <= 0) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy port or Host not set"); return AXIS2_FAILURE; } if(client->sockfd < 0) { client->sockfd = (int)axutil_network_handler_open_socket(env, client->proxy_host, client->proxy_port); } } else { /*Proxy is not enabled*/ if(client->sockfd < 0) { client->sockfd = (int)axutil_network_handler_open_socket(env, host, port); } } if(client->sockfd < 0) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Socket Creation failed."); return AXIS2_FAILURE; } if(client->timeout > 0) { /*Set the receiving time out*/ axutil_network_handler_set_sock_option(env, client->sockfd, SO_RCVTIMEO, client->timeout); /*Set the sending time out*/ axutil_network_handler_set_sock_option(env, client->sockfd, SO_SNDTIMEO, client->timeout); } if(0 == axutil_strcasecmp(axutil_url_get_protocol(client->url, env), AXIS2_TRANSPORT_URL_HTTPS)) { #ifdef AXIS2_SSL_ENABLED if (client->proxy_enabled) { if (AXIS2_SUCCESS != axis2_http_client_connect_ssl_host(client, env, host, port)) { axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTPS connection creation failed"); return AXIS2_FAILURE; } } if(!client->data_stream) { client->data_stream = axutil_stream_create_ssl(env, client->sockfd, axis2_http_client_get_server_cert(client, env), axis2_http_client_get_key_file(client, env), ssl_pp); client->owns_stream = AXIS2_TRUE; } #else axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_TRANSPORT_PROTOCOL, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid Transport Protocol, HTTPS transport not enabled."); return AXIS2_FAILURE; #endif } else { if(!client->data_stream) { client->data_stream = axutil_stream_create_socket(env, client->sockfd); client->owns_stream = AXIS2_TRUE; } } if(!client->data_stream) { axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Data stream creation failed for Host %s and %d port", host, port); return AXIS2_FAILURE; } /*Accessing HTTP headers*/ headers = axis2_http_simple_request_get_headers(request, env); if(headers) { int header_count = axutil_array_list_size(headers, env); int i = 0; char *str_header2 = NULL; for(i = 0; i < header_count; i++) { axis2_char_t *header_ext_form = NULL; axis2_http_header_t *tmp_header = (axis2_http_header_t *)axutil_array_list_get(headers, env, i); if(!tmp_header) { /* This continue is added as a safey mechanism, * However I see a problem with this logic, AFAIC * see there can't be null headers in the headers * array list, because number of headers in "headers" * array list count with axutil_array_list_size, * therefore this check and continue might not have a * real effect.*/ continue; } /* check whether we have transfer encoding and then see whether the * value is "chunked" */ if(!axutil_strcmp(axis2_http_header_get_name(tmp_header, env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && !axutil_strcmp(axis2_http_header_get_value( tmp_header, env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) { chunking_enabled = AXIS2_TRUE; } header_ext_form = axis2_http_header_to_external_form(tmp_header, env); /* str_header2 is to hold intermediate value of str_header */ str_header2 = axutil_stracat(env, str_header, header_ext_form); if(str_header) { AXIS2_FREE(env->allocator, str_header); str_header = NULL; } if(header_ext_form) { AXIS2_FREE(env->allocator, header_ext_form); header_ext_form = NULL; } /* str_header has all HTTP headers to send. */ str_header = str_header2; } } if(AXIS2_FALSE == client->proxy_enabled) { str_request_line = axis2_http_request_line_to_string( axis2_http_simple_request_get_request_line(request, env), env); } else { /* proxy enabled case */ /* we need the request line in the format * POST http://host:port/path HTTP/1.x if we have enabled proxies */ axis2_char_t *host_port_str = NULL; axis2_char_t *host = axutil_url_get_host(client->url, env); axis2_http_request_line_t *request_line = axis2_http_simple_request_get_request_line( request, env); axis2_char_t *path = axis2_http_request_line_get_uri(request_line, env); host_port_str = AXIS2_MALLOC(env->allocator, axutil_strlen(host) + axutil_strlen(path) + 20 * sizeof(axis2_char_t)); if(!host_port_str) { axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Memory allocation failed for host %s and %s path", host, path); return AXIS2_FAILURE; } sprintf(host_port_str, "http://%s:%d%s", host, axutil_url_get_port(client->url, env), path); str_request_line = AXIS2_MALLOC(env->allocator, axutil_strlen(host_port_str) + 20 * sizeof(axis2_char_t)); if(!str_request_line) { axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_FREE(env->allocator, host_port_str); AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "memory allocation failed for host %s and %s path", host, path); return AXIS2_FAILURE; } sprintf(str_request_line, "%s %s %s\r\n", axis2_http_request_line_get_method(request_line, env), host_port_str, axis2_http_request_line_get_http_version(request_line, env)); AXIS2_FREE(env->allocator, host_port_str); host_port_str = NULL; } /* Here first we send the http header part */ wire_format = axutil_stracat(env, str_request_line, str_header); AXIS2_FREE(env->allocator, str_header); str_header = NULL; AXIS2_FREE(env->allocator, str_request_line); str_request_line = NULL; written = axutil_stream_write(client->data_stream, env, wire_format, axutil_strlen(wire_format)); AXIS2_FREE(env->allocator, wire_format); wire_format = NULL; /* Then we write the two new line charaters before the http body*/ written = axutil_stream_write(client->data_stream, env, AXIS2_HTTP_CRLF, 2); /* When sending MTOM it is bit different. We keep the attachment + other mime headers in an array_list and send them one by one */ if(client->doing_mtom) { /*axis2_status_t status = AXIS2_SUCCESS; */ axutil_http_chunked_stream_t *chunked_stream = NULL; /* If the callback name is not there, then we will check whether there * is any mime_parts which has type callback. If we found then no point * of continuing we should return a failure */ if(!(client->mtom_sending_callback_name)) { if(axis2_http_transport_utils_is_callback_required(env, client->mime_parts)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); return AXIS2_FAILURE; } } /* For MTOM we automatically enabled chunking */ chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); /* This method will write the Attachment + data to the wire */ status = axis2_http_transport_utils_send_mtom_message(chunked_stream, env, client->mime_parts, client->mtom_sending_callback_name); axutil_http_chunked_stream_free(chunked_stream, env); chunked_stream = NULL; } /* Non MTOM case */ else if(client->req_body_size > 0 && client->req_body) { int len = 0; written = 0; /* Keep on writing data in a loop until we finised with all the data in the buffer */ if(!chunking_enabled) { status = AXIS2_SUCCESS; while(written < client->req_body_size) { len = 0; len = axutil_stream_write(client->data_stream, env, client->req_body + written, client->req_body_size - written); if(-1 == len) { status = AXIS2_FAILURE; break; } else { written += len; } } } else { /* Not MTOM but chunking is enabled */ axutil_http_chunked_stream_t *chunked_stream = NULL; chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); status = AXIS2_SUCCESS; if(!chunked_stream) { axutil_network_handler_close_socket(env, client->sockfd); client->sockfd = -1; AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked stream failed"); return AXIS2_FAILURE; } while(written < client->req_body_size) { written = axutil_http_chunked_stream_write(chunked_stream, env, client->req_body, client->req_body_size); if(-1 == written) { status = AXIS2_FAILURE; break; } } if(AXIS2_SUCCESS == status) { /* Writing the trailing null charactor */ axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); } axutil_http_chunked_stream_free(chunked_stream, env); } } client->request_sent = AXIS2_TRUE; return status; }
axiom_node_t* AXIS2_CALL adb_getMaxOperationResponseTimeResponse_serialize( adb_getMaxOperationResponseTimeResponse_t* _getMaxOperationResponseTimeResponse, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t *current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT]; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _getMaxOperationResponseTimeResponse, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://org.apache.axis2/xsd", "n"); axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "getMaxOperationResponseTimeResponse", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://org.apache.axis2/xsd", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://org.apache.axis2/xsd", p_prefix)); } if (!_getMaxOperationResponseTimeResponse->is_valid_return) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing return element */ sprintf(start_input_str, "<%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); sprintf (text_value_1, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t) _getMaxOperationResponseTimeResponse->property_return); axutil_stream_write(stream, env, start_input_str, start_input_str_len); axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
axiom_node_t* AXIS2_CALL adb_IncorrectStatusTypeException_serialize( adb_IncorrectStatusTypeException_t* _IncorrectStatusTypeException, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axis2_char_t *string_to_stream; axiom_node_t *current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _IncorrectStatusTypeException, NULL); current_node = parent; data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env); if (!data_source) return NULL; stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */ if (!stream) return NULL; if(!parent_tag_closed) { string_to_stream = ">"; axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream)); tag_closed = 1; } p_prefix = NULL; if (!_IncorrectStatusTypeException->is_valid_message) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("message"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("message"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing message element */ sprintf(start_input_str, "<%s%smessage>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%smessage>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_1 = _IncorrectStatusTypeException->property_message; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } return parent; }
/*For SOAP this parent is the wsse:Security node*/ AXIS2_EXTERN axis2_status_t AXIS2_CALL oxs_xml_enc_encrypt_key( const axutil_env_t *env, oxs_asym_ctx_t * asym_ctx, axiom_node_t *parent, oxs_key_t *sym_key, axutil_array_list_t *id_list) { axis2_char_t *algorithm = NULL; axis2_char_t *encrypted_key_data = NULL; axis2_char_t *st_ref_pattern = NULL; oxs_buffer_t *input = NULL; oxs_buffer_t *result = NULL; axiom_node_t *encrypted_key_node = NULL; axiom_node_t *enc_mtd_node = NULL; axiom_node_t *key_info_node = NULL; axiom_node_t *stref_node = NULL; axiom_node_t *cd_node = NULL; axiom_node_t *cv_node = NULL; axis2_status_t status = AXIS2_FAILURE; axis2_char_t* encrypted_key_hash = NULL; int decoded_len = 0; axis2_char_t *decoded_enc_sec = NULL; /*Create input buffer*/ input = oxs_buffer_create(env); oxs_buffer_populate(input, env, oxs_key_get_data(sym_key, env), oxs_key_get_size(sym_key, env)); /*Create an empty buffer to collect results*/ result = oxs_buffer_create(env); /*Call encryption*/ status = oxs_encryption_asymmetric_crypt(env, asym_ctx, input, result); /*Free input*/ oxs_buffer_free(input, env); input = NULL; if(AXIS2_FAILURE == status) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Assymmetric key encryption failed"); return AXIS2_FAILURE; } /*Get the encrypted key*/ encrypted_key_data = (axis2_char_t *)oxs_buffer_get_data(result, env); /*Build nodes*/ encrypted_key_node = oxs_token_build_encrypted_key_element(env, parent); algorithm = oxs_asym_ctx_get_algorithm(asym_ctx, env); enc_mtd_node = oxs_token_build_encryption_method_element(env, encrypted_key_node, algorithm); key_info_node = oxs_token_build_key_info_element(env, encrypted_key_node); stref_node = oxs_token_build_security_token_reference_element(env, key_info_node); /*Get the ST REF pattern. If not set the default*/ st_ref_pattern = oxs_asym_ctx_get_st_ref_pattern(asym_ctx, env); if((!st_ref_pattern) || (0 == axutil_strcmp(st_ref_pattern, ""))) { st_ref_pattern = OXS_STR_DEFAULT; } if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_ISSUER_SERIAL)) { status = oxs_xml_enc_populate_stref_with_issuer_serial(env, asym_ctx, stref_node); } else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_EMBEDDED)) { status = oxs_xml_enc_populate_stref_with_embedded(env, asym_ctx, stref_node); } else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_DIRECT_REFERENCE)) { status = oxs_xml_enc_populate_stref_with_bst(env, asym_ctx, stref_node, parent); } else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_KEY_IDENTIFIER)) { status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_FALSE); } else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_THUMB_PRINT)) { /*TODO: Need to support Thumbprint Ref*/ status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_TRUE); } cd_node = oxs_token_build_cipher_data_element(env, encrypted_key_node); cv_node = oxs_token_build_cipher_value_element(env, cd_node, encrypted_key_data); /*If and only if the id_list the present, we create the reference list*/ if(id_list) { oxs_token_build_data_reference_list(env, encrypted_key_node, id_list); } /*calculate the EncryptedKeySHA1 and set as the key_sha*/ decoded_len = axutil_base64_decode_len(encrypted_key_data); decoded_enc_sec = AXIS2_MALLOC(env->allocator, decoded_len); axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, encrypted_key_data); encrypted_key_hash = openssl_sha1(env, decoded_enc_sec, decoded_len); oxs_key_set_key_sha(sym_key, env, encrypted_key_hash); AXIS2_FREE(env->allocator, decoded_enc_sec); /*Free*/ oxs_buffer_free(result, env); result = NULL; return AXIS2_SUCCESS; }
int main(int argc, char** argv) { const axutil_env_t *env = NULL; const axis2_char_t *address = NULL; axis2_char_t *file_name = NULL; axis2_endpoint_ref_t* endpoint_ref = NULL; axis2_options_t *options = NULL; axis2_svc_client_t* svc_client = NULL; axiom_node_t *payload = NULL; axiom_node_t *ret_node = NULL; axis2_status_t status = AXIS2_FAILURE; neethi_policy_t *policy = NULL; rampart_config_t* client_config = NULL; axutil_property_t *property = NULL; /* Set up the environment */ env = axutil_env_create_all("echo.log", AXIS2_LOG_LEVEL_TRACE); /* Set end-point-reference of echo service */ address = "http://localhost:9090/axis2/services/echo"; if (argc > 2) { address = argv[1]; client_home = argv[2]; printf("Using endpoint : %s\n", address); printf("Using client_home : %s\n", client_home); } if ((axutil_strcmp(argv[1], "-h") == 0) || (axutil_strcmp(argv[1], "--help") == 0)) { printf("Usage : %s [endpoint_url] [client_home]\n", argv[0]); printf("use -h for help\n"); return 0; } /* Create end-point-reference 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_action(options, env, "http://example.com/ws/2004/09/policy/Test/EchoRequest"); /*axis2_options_set_action(options, env, "urn:echo");*/ /*If the client home is not specified, use the AXIS2C_HOME*/ if (!client_home) { client_home = AXIS2_GETENV("AXIS2C_HOME"); printf("\nNo client_home specified. Using default %s", client_home); } /* Create service client */ printf("client_home= %s", client_home); svc_client = axis2_svc_client_create(env, client_home); if (!svc_client) { printf("Error creating service client\n"); return -1; } client_config = rampart_config_create(env); if(!client_config) { printf("Cannot create rampart config\n"); return 0; } rampart_config_set_issued_token_aquire_function(client_config, env, (rampart_issued_token_t*)get_issued_token); property = axutil_property_create_with_args(env, AXIS2_SCOPE_REQUEST , AXIS2_TRUE, (void *)rampart_config_free, client_config); axis2_options_set_property(options, env, RAMPART_CLIENT_CONFIGURATION, property); /* Set service client options */ axis2_svc_client_set_options(svc_client, env, options); /*We need to specify the client's policy file location*/ if(client_home) { file_name = axutil_stracat(env, client_home, AXIS2_PATH_SEP_STR); policy_file = axutil_stracat(env, file_name, "policy.xml"); sts_ploicy = axutil_stracat(env, file_name, "sts_policy.xml"); AXIS2_FREE(env->allocator, file_name); file_name = NULL; }else{ printf("Client Home not Specified\n"); printf("echo client invoke FAILED!\n"); return 0; } /*Create the policy, from file*/ policy = neethi_util_create_policy_from_file(env, policy_file); if(policy_file){ AXIS2_FREE(env->allocator, policy_file); policy_file = NULL; } if(!policy) { printf("\nPolicy creation failed from the file. %s\n", policy_file); } status = axis2_svc_client_set_policy(svc_client, env, policy); if(status == AXIS2_FAILURE) { printf("Policy setting failed\n"); } /* Build the SOAP request message payload using OM API.*/ payload = build_om_payload_for_echo_svc(env); /*If not engaged in the client's axis2.xml, uncomment this line*/ axis2_svc_client_engage_module(svc_client, env, "rampart"); /* 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; 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) { printf("\nReturned SOAP fault: %s\n", axiom_node_to_string(axiom_soap_fault_get_base_node(soap_fault,env), env)); } printf("echo client invoke FAILED!\n"); return -1; } if (ret_node) { axis2_char_t *om_str = NULL; om_str = axiom_node_to_string(ret_node, env); if (om_str) { printf("\nReceived OM : %s\n", om_str); } printf("\necho client invoke SUCCESSFUL!\n"); AXIS2_FREE(env->allocator, om_str); ret_node = NULL; } else { printf("echo client invoke FAILED!\n"); return -1; } 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_EXTERN axis2_char_t *AXIS2_CALL savan_client_renew( savan_client_t *client, const axutil_env_t *env, axis2_svc_client_t *svc_client, axutil_hash_t *options) { axis2_options_t *wsa_options = NULL; const axis2_char_t *old_action = NULL; axiom_namespace_t *ns = NULL; axiom_node_t *reply = NULL; axiom_node_t *renew_node = NULL; axiom_node_t *expires_node = NULL; axiom_element_t *renew_elem = NULL; axiom_element_t *expires_elem = NULL; axis2_char_t *expires = NULL; axis2_char_t *renew_elem_localname = NULL; axutil_qname_t *qname = NULL; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_renew"); /* Set wsa action as Renew. remember the old action */ wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env); old_action = axis2_options_get_action(wsa_options, env); axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_RENEW); /* Create the body of the Renew request */ ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX); renew_elem = axiom_element_create(env, NULL, ELEM_NAME_RENEW, ns, &renew_node); /* Extract the values from the options map */ expires = axutil_hash_get(options, SAVAN_OP_KEY_EXPIRES, AXIS2_HASH_KEY_STRING); if(expires) { /* Expires element */ expires_elem = axiom_element_create(env, renew_node, ELEM_NAME_EXPIRES, ns, &expires_node); axiom_element_set_text(expires_elem, env, expires, expires_node); } savan_client_add_sub_id_to_soap_header(client, env, svc_client); /* send the Renew request and wait for the response */ reply = axis2_svc_client_send_receive(svc_client, env, renew_node); /* reset the old action */ axis2_options_set_action(wsa_options, env, old_action); if (!reply) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send renew request. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } renew_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env); /* Check whether we have received a RenewResponse */ renew_elem_localname = axiom_element_get_localname(renew_elem, env); if (axutil_strcmp(ELEM_NAME_RENEW_RESPONSE, renew_elem_localname)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve RenewResponse"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } /* Get Expires element from RenewResponse element */ qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL); expires_elem = axiom_element_get_first_child_with_qname(renew_elem, env, qname, reply, &expires_node); axutil_qname_free(qname, env); if(!expires_node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } expires = axiom_element_get_text(expires_elem, env, expires_node); AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_renew"); return expires; }
/** * Verifies XPath location of signed elements. */ int verify_node(axiom_node_t *signed_node, const axutil_env_t *env, axis2_msg_ctx_t *msg_ctx, axis2_char_t *ref, short *signed_elems, rampart_context_t *rampart_context) { if(!axutil_strcmp(OXS_NODE_BODY, axiom_util_get_localname(signed_node, env))) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Body", ref); signed_elems[0] = 1; axiom_node_t *parent = axiom_node_get_parent(signed_node,env); if(axutil_strcmp(OXS_NODE_ENVELOPE, axiom_util_get_localname(parent, env))) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected parent element for Body with ID = %s", ref); return 1; } parent = axiom_node_get_parent(parent,env); if(parent) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] parent of Envelope = %s", axiom_node_to_string(parent, env)); oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Unexpected location of signed Body with ID = %s", ref); return 1; } } else if(!axutil_strcmp(RAMPART_SECURITY_TIMESTAMP, axiom_util_get_localname(signed_node, env))) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Timestamp", ref); signed_elems[1] = 1; /* Regardless of the location of the Timestamp, verify the one that is signed */ if(AXIS2_FAILURE == rampart_timestamp_token_validate(env, msg_ctx, signed_node, rampart_context_get_clock_skew_buffer(rampart_context, env))) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for Timestamp with ID = %s", ref); return 1; } } else if(!axutil_strcmp(AXIS2_WSA_ACTION, axiom_util_get_localname(signed_node, env))) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is Action", ref); signed_elems[2] = 1; if(verify_addr_hdr_elem_loc(signed_node, env, ref)) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for Action with ID = %s", ref); return 1; } } else if(!axutil_strcmp(AXIS2_WSA_TO, axiom_util_get_localname(signed_node, env))) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is To", ref); signed_elems[3] = 1; if(verify_addr_hdr_elem_loc(signed_node, env, ref)) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for To with ID = %s", ref); return 1; } } else if(!axutil_strcmp(AXIS2_WSA_MESSAGE_ID, axiom_util_get_localname(signed_node, env))) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is MessageId", ref); signed_elems[4] = 1; if(verify_addr_hdr_elem_loc(signed_node, env, ref)) { oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ELEMENT_FAILED, "Validation failed for MessageId with ID = %s", ref); return 1; } } else { AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "[euca-rampart] node %s is UNKNOWN", ref); } return 0; }
AXIS2_EXTERN axis2_char_t * AXIS2_CALL savan_client_get_status( savan_client_t *client, const axutil_env_t *env, axis2_svc_client_t *svc_client) { axis2_options_t *wsa_options = NULL; const axis2_char_t *old_action = NULL; axutil_qname_t *qname = NULL; axiom_namespace_t *ns = NULL; axiom_node_t *reply = NULL; axiom_node_t *status_node = NULL; axiom_node_t *expires_node = NULL; axiom_element_t *status_elem = NULL; axiom_element_t *expires_elem = NULL; axis2_char_t *expires = NULL; axis2_char_t *status_elem_localname = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_get_status"); /* Set wsa action as GetStatus. remember the old action */ wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env); old_action = axis2_options_get_action(wsa_options, env); axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_GET_STATUS); /* Create the body of the GetStatus request */ ns = axiom_namespace_create (env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX); status_elem = axiom_element_create(env, NULL, ELEM_NAME_GETSTATUS, ns, &status_node); savan_client_add_sub_id_to_soap_header(client, env, svc_client); /* Send the GetStatus request and wait for the response */ reply = axis2_svc_client_send_receive(svc_client, env, status_node); /* Reset the old action */ axis2_options_set_action(wsa_options, env, old_action); if (!reply) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send get status " "request. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } status_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env); /* Check whether we have received a GetStatusResponse */ status_elem_localname = axiom_element_get_localname(status_elem, env); if (axutil_strcmp(ELEM_NAME_GETSTATUS_RESPONSE, status_elem_localname)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve GetStatusResponse"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } /* Now read Expires sub element */ qname = axutil_qname_create(env, ELEM_NAME_EXPIRES, EVENTING_NAMESPACE, NULL); expires_elem = axiom_element_get_first_child_with_qname(status_elem, env, qname, reply, &expires_node); axutil_qname_free(qname, env); if(!expires_node) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to retrieve Expires"\ "element. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return NULL; } expires_elem = (axiom_element_t *) axiom_node_get_data_element(expires_node, env); expires = axiom_element_get_text(expires_elem, env, expires_node); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_get_status"); return expires; }
axis2_char_t* AXIS2_CALL get_sample_password(rampart_callback_t *rcb, const axutil_env_t *env, const axis2_char_t *username, void *param) { /*First set pf password are for sample usernames*/ axis2_char_t * pw = NULL; if (0 == axutil_strcmp(username, "Raigama")) { pw = "RaigamaPW" ; } else if (0 == axutil_strcmp(username, "Gampola")) { pw = "GampolaPW"; } else if (0 == axutil_strcmp(username, "alice")) { pw = "password"; } else if (0 == axutil_strcmp(username, "bob")) { pw = "bobPW"; } else if (0 == axutil_strcmp(username, "Bob")) { pw = "boB"; } else if (0 == axutil_strcmp(username, "Alice")) { pw = "abcd!1234"; /*pw = "ecilA";*/ } /*These are for sample keystores*/ else if (0 == axutil_strcmp(username, "a")) { pw = "a12345"; } else if (0 == axutil_strcmp(username, "b")) { pw = "b12345"; } else if (0 == axutil_strcmp(username, "x")) { pw = "x12345"; } else if (0 == axutil_strcmp(username, "abcd")) { pw = "dcba"; } else if (0 == axutil_strcmp(username, "y")) { pw = "y12345"; } else { /*Append 12345 for any name not specified above*/ /*sprintf(pw, "%s%s", username, "12345");*/ } return pw; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL savan_client_subscribe( savan_client_t *client, const axutil_env_t *env, axis2_svc_client_t *svc_client, axutil_hash_t *options) { axis2_options_t *wsa_options = NULL; const axis2_char_t *old_action = NULL; axiom_node_t *reply = NULL; axiom_node_t *sub_node = NULL; axiom_element_t *body_elem = NULL; axis2_char_t *sub_id = NULL; axis2_char_t *sub_url = NULL; axis2_char_t *sub_elem_local_name = NULL; savan_subscriber_t *subscriber = NULL; /*axis2_char_t *endto = NULL;*/ axis2_char_t *notify = NULL; axis2_char_t *filter = NULL; axis2_char_t *filter_dialect = NULL; axis2_char_t *expires = NULL; axis2_status_t status = AXIS2_SUCCESS; axis2_endpoint_ref_t *endpoint_ref = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Entry:savan_client_subscribe"); /* set wsa action as Subscribe. remember the old action */ wsa_options = (axis2_options_t*)axis2_svc_client_get_options(svc_client, env); old_action = axis2_options_get_action(wsa_options, env); axis2_options_set_action(wsa_options, env, SAVAN_ACTIONS_SUB); /* extract the values from the options map */ /* endto endpoint reference is used by the event source to send a subscription end message. Default is not * to send this message by the event source. How this should be provided by the client? */ /*endto = axutil_hash_get(options, SAVAN_OP_KEY_ENDTO_EPR, AXIS2_HASH_KEY_STRING);*/ notify = axutil_hash_get(options, SAVAN_OP_KEY_NOTIFY_EPR, AXIS2_HASH_KEY_STRING); filter = axutil_hash_get(options, SAVAN_OP_KEY_FILTER, AXIS2_HASH_KEY_STRING); filter_dialect = axutil_hash_get(options, SAVAN_OP_KEY_FILTER_DIALECT, AXIS2_HASH_KEY_STRING); expires = axutil_hash_get(options, SAVAN_OP_KEY_EXPIRES, AXIS2_HASH_KEY_STRING); subscriber = savan_subscriber_create(env); /*endpoint_ref = axis2_endpoint_ref_create(env, endto); savan_subscriber_set_end_to(subscriber, env, endpoint_ref);*/ endpoint_ref = axis2_endpoint_ref_create(env, notify); savan_subscriber_set_notify_to(subscriber, env, endpoint_ref); savan_subscriber_set_filter(subscriber, env, filter); savan_subscriber_set_filter_dialect(subscriber, env, filter_dialect); if(expires) { savan_subscriber_set_expires(subscriber, env, expires); } /* Create the Subscriber node */ sub_node = savan_util_create_subscriber_node(env, subscriber, NULL); if(!sub_node) { status = axutil_error_get_status_code(env->error); savan_subscriber_free(subscriber, env); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Could not create the subscriber node"); return status; } /* send the Subscription and wait for the response */ reply = axis2_svc_client_send_receive(svc_client, env, sub_node); /* reset the old action */ axis2_options_set_action(wsa_options, env, old_action); if (!reply) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Failed to send subscription request. Error: %d Reason: %s", env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error)); return AXIS2_FAILURE; } /* Extract the subscription id from the response and store for future * requests */ /* Get Body element from body node */ body_elem = (axiom_element_t*)axiom_node_get_data_element(reply, env); /* Check whether we have received a SubscribeResponse */ sub_elem_local_name = axiom_element_get_localname(body_elem, env); if (axutil_strcmp(ELEM_NAME_SUB_RESPONSE, sub_elem_local_name)) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] Subscription failed"); return AXIS2_FAILURE; } sub_id = savan_client_get_sub_id_from_response(body_elem, reply, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "sub_id3:%s", sub_id); client->sub_id = axutil_strdup(env, sub_id); sub_url = savan_client_get_sub_url_from_response(body_elem, reply, env); client->sub_url = axutil_strdup(env, sub_url); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[savan] Exit:savan_client_subscribe"); return AXIS2_SUCCESS; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_ws_info_list_check_for_undeploy( axis2_ws_info_list_t * ws_info_list, const axutil_env_t * env) { int list_size = 0; axutil_array_list_t *temp_list = NULL; int i = 0; /* Create temp list */ temp_list = axutil_array_list_create(env, 0); if(!temp_list) { return AXIS2_FAILURE; } list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); for(i = 0; i < list_size; i++) { /* For each ws_info item in the ws_info_list check whether it is also * in the current_info_list. If not mark it to be undeployed by adding * it to a temporarily list. Also add that item to the undeploy list of * deployment engine.*/ int current_lists_size = 0; axis2_ws_info_t *file_item = NULL; axis2_char_t *file_item_name = NULL; axis2_bool_t exist = AXIS2_FALSE; int j = 0; file_item = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); file_item_name = axis2_ws_info_get_file_name(file_item, env); current_lists_size = axutil_array_list_size(ws_info_list->current_info_list, env); for(j = 0; j < current_lists_size; j++) { axis2_char_t *file_name = NULL; file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list-> current_info_list, env, j); if(!axutil_strcmp(file_name, file_item_name)) { exist = AXIS2_TRUE; break; } } if(!exist) { axis2_ws_info_t *ws_info = NULL; long last_modified_date = 0; last_modified_date = axis2_ws_info_get_last_modified_date(file_item, env); axutil_array_list_add(temp_list, env, file_item); ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date(env, file_item_name, last_modified_date); /* This ws_info is to be undeployed */ axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env, ws_info); } } list_size = axutil_array_list_size(temp_list, env); for(i = 0; i < list_size; i++) { /* Get each ws_info item from the temp list created and remove that * item from the ws_info_list */ axis2_ws_info_t *file_item = NULL; int index = 0; file_item = (axis2_ws_info_t *)axutil_array_list_get(temp_list, env, i); index = axutil_array_list_index_of(ws_info_list->ws_info_list, env, file_item); axutil_array_list_remove(ws_info_list->ws_info_list, env, index); } axutil_array_list_free(temp_list, env); return AXIS2_SUCCESS; }
axiom_node_t* AXIS2_CALL prf_getAttributeResponseType_serialize_obj( prf_getAttributeResponseType_t* _getAttributeResponseType, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axis2_char_t *string_to_stream; axiom_node_t* current_node = NULL; int tag_closed = 0; axis2_char_t* xsi_prefix = NULL; axiom_namespace_t* xsi_ns = NULL; axiom_attribute_t* xsi_type_attri = NULL; axis2_char_t* type_attrib = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _getAttributeResponseType, NULL); current_node = parent; data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env); if (!data_source) return NULL; stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */ if (!stream) return NULL; if(!parent_tag_closed) { if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING))) { /* it is better to stick with the standard prefix */ xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi"); axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix); if(parent_element) { axiom_namespace_t *element_ns = NULL; element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance", xsi_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns); if(element_ns) { axiom_namespace_free(element_ns, env); } } } type_attrib = axutil_strcat(env, " ", xsi_prefix, ":type=\"getAttributeResponseType\"", NULL); axutil_stream_write(stream, env, type_attrib, axutil_strlen(type_attrib)); AXIS2_FREE(env->allocator, type_attrib); string_to_stream = ">"; axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream)); tag_closed = 1; } else { /* if the parent tag closed we would be able to declare the type directly on the parent element */ if(!(xsi_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING))) { /* it is better to stick with the standard prefix */ xsi_prefix = (axis2_char_t*)axutil_strdup(env, "xsi"); axutil_hash_set(namespaces, "http://www.w3.org/2001/XMLSchema-instance", AXIS2_HASH_KEY_STRING, xsi_prefix); if(parent_element) { axiom_namespace_t *element_ns = NULL; element_ns = axiom_namespace_create(env, "http://www.w3.org/2001/XMLSchema-instance", xsi_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, element_ns); if(element_ns) { axiom_namespace_free(element_ns, env); } } } } xsi_ns = axiom_namespace_create (env, "http://www.pratsam.org/ns/profile/", xsi_prefix); xsi_type_attri = axiom_attribute_create (env, "type", "getAttributeResponseType", xsi_ns); axiom_element_add_attribute (parent_element, env, xsi_type_attri, parent); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * PRF_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://www.pratsam.org/ns/profile/", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://www.pratsam.org/ns/profile/", p_prefix)); } if (!_getAttributeResponseType->is_valid_getAttributeResult) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property getAttributeResult"); return NULL; } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("getAttributeResult"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("getAttributeResult"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * parsing getAttributeResult element */ sprintf(start_input_str, "<%s%sgetAttributeResult>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sgetAttributeResult>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); text_value_1 = _getAttributeResponseType->property_getAttributeResult; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } return parent; }
axis2_status_t axis2_engine_check_must_understand_headers( const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { axiom_soap_envelope_t *soap_envelope = NULL; axiom_soap_header_t *soap_header = NULL; axutil_hash_t *header_block_ht = NULL; axutil_hash_index_t *hash_index = NULL; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_envelope) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Soap envelope not found in message context"); return AXIS2_FAILURE; } soap_header = axiom_soap_envelope_get_header(soap_envelope, env); if(!soap_header) return AXIS2_SUCCESS; header_block_ht = axiom_soap_header_get_all_header_blocks(soap_header, env); if(!header_block_ht) return AXIS2_SUCCESS; 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; axis2_char_t *role = NULL; axutil_hash_this(hash_index, NULL, NULL, &hb); header_block = (axiom_soap_header_block_t *)hb; if(header_block) { if(axiom_soap_header_block_is_processed(header_block, env) || !axiom_soap_header_block_get_must_understand(header_block, env)) { continue; } /* If this header block is not targeted to me then its not my problem. Currently this code only supports the "next" role; we need to fix this to allow the engine/service to be in one or more additional roles and then to check that any headers targeted for that role too have been dealt with. */ role = axiom_soap_header_block_get_role(header_block, env); if(axis2_msg_ctx_get_is_soap_11(msg_ctx, env) != AXIS2_TRUE) { /* SOAP 1.2 */ if(!role || axutil_strcmp(role, AXIOM_SOAP12_SOAP_ROLE_NEXT) != 0) { axiom_soap_envelope_t *temp_env = axiom_soap_envelope_create_default_soap_fault_envelope(env, "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP12, NULL, NULL); axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env); axis2_msg_ctx_set_wsa_action(msg_ctx, env, "http://www.w3.org/2005/08/addressing/fault"); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured"); return AXIS2_FAILURE; } } else { /* SOAP 1.1 */ if(!role || axutil_strcmp(role, AXIOM_SOAP11_SOAP_ACTOR_NEXT) != 0) { axiom_soap_envelope_t *temp_env = axiom_soap_envelope_create_default_soap_fault_envelope(env, "soapenv:MustUnderstand", "Header not understood", AXIOM_SOAP11, NULL, NULL); axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, temp_env); axis2_msg_ctx_set_wsa_action(msg_ctx, env, "http://www.w3.org/2005/08/addressing/fault"); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Must understand soap fault occured"); return AXIS2_FAILURE; } } } } return AXIS2_SUCCESS; }
AXIS2_EXTERN remote_registry_comment_t* AXIS2_CALL remote_registry_comment_create_from_entry_node( const axutil_env_t *env, axiom_node_t *entry_node) { remote_registry_comment_t *comment = NULL; axiom_children_iterator_t *entry_it = NULL; axiom_element_t *entry_ele = NULL; comment = remote_registry_comment_create(env); if(comment == NULL) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); 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); /* retriving the attribute one by one */ if(!axutil_strcmp(local_name, "updated")) { axis2_char_t *updated_text = NULL; axutil_date_time_t *updated_datetime = NULL; updated_text = axiom_element_get_text(child_ele, env, child); updated_datetime = axutil_date_time_create(env); axutil_date_time_deserialize_time(updated_datetime, env, updated_text); remote_registry_comment_set_date_time(comment, env, updated_datetime); } else if(!axutil_strcmp(local_name, "content")) { axis2_char_t *content = NULL; content = axiom_element_get_text(child_ele, env, child); remote_registry_comment_set_text(comment, env, content); } else if(!axutil_strcmp(local_name, "author")) { axiom_node_t *name_node = NULL; axiom_element_t *name_element = NULL; name_node = axiom_node_get_first_child(child, env); /* get the first child (with type AXIOM_ELEMENT) where we can find the name */ if(name_node && axiom_node_get_node_type(name_node, env) != AXIOM_ELEMENT) { name_node = axiom_node_get_next_sibling(name_node, env); } if(name_node) { axis2_char_t *name = NULL; name_element = axiom_node_get_data_element(name_node, env); name = axiom_element_get_text(name_element, env, name_node); remote_registry_comment_set_user(comment, env, name); } } } return comment; }
axiom_node_t* AXIS2_CALL adb_getInternalUsersResponse_serialize_obj( adb_getInternalUsersResponse_t* _getInternalUsersResponse, const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index) { axiom_node_t* current_node = NULL; int tag_closed = 0; axiom_namespace_t *ns1 = NULL; axis2_char_t *qname_uri = NULL; axis2_char_t *qname_prefix = NULL; axis2_char_t *p_prefix = NULL; axis2_bool_t ns_already_defined; int i = 0; int count = 0; void *element = NULL; axis2_char_t *text_value_1; axis2_char_t *text_value_1_temp; axis2_char_t *start_input_str = NULL; axis2_char_t *end_input_str = NULL; unsigned int start_input_str_len = 0; unsigned int end_input_str_len = 0; axiom_data_source_t *data_source = NULL; axutil_stream_t *stream = NULL; int next_ns_index_value = 0; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, _getInternalUsersResponse, NULL); namespaces = axutil_hash_make(env); next_ns_index = &next_ns_index_value; ns1 = axiom_namespace_create (env, "http://service.mgt.user.carbon.wso2.org", "n"); axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n")); parent_element = axiom_element_create (env, NULL, "getInternalUsersResponse", ns1 , &parent); axiom_element_set_namespace(parent_element, env, ns1, parent); data_source = axiom_data_source_create(env, parent, ¤t_node); stream = axiom_data_source_get_stream(data_source, env); if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING))) { p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT); sprintf(p_prefix, "n%d", (*next_ns_index)++); axutil_hash_set(namespaces, "http://service.mgt.user.carbon.wso2.org", AXIS2_HASH_KEY_STRING, p_prefix); axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env, "http://service.mgt.user.carbon.wso2.org", p_prefix)); } if (!_getInternalUsersResponse->is_valid_return) { /* no need to complain for minoccurs=0 element */ } else { start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (4 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("<:>") + 1 = 4 */ end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (5 + axutil_strlen(p_prefix) + axutil_strlen("return"))); /* axutil_strlen("</:>") + 1 = 5 */ /* * Parsing return array */ if (_getInternalUsersResponse->property_return != NULL) { sprintf(start_input_str, "<%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); start_input_str_len = axutil_strlen(start_input_str); sprintf(end_input_str, "</%s%sreturn>", p_prefix?p_prefix:"", (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); end_input_str_len = axutil_strlen(end_input_str); count = axutil_array_list_size(_getInternalUsersResponse->property_return, env); for(i = 0; i < count; i ++) { element = axutil_array_list_get(_getInternalUsersResponse->property_return, env, i); if(NULL == element) { continue; } /* * parsing return element */ text_value_1 = (axis2_char_t*)element; axutil_stream_write(stream, env, start_input_str, start_input_str_len); text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE); if (text_value_1_temp) { axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp)); AXIS2_FREE(env->allocator, text_value_1_temp); } else { axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1)); } axutil_stream_write(stream, env, end_input_str, end_input_str_len); } } AXIS2_FREE(env->allocator,start_input_str); AXIS2_FREE(env->allocator,end_input_str); } if(namespaces) { axutil_hash_index_t *hi; void *val; for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, NULL, NULL, &val); AXIS2_FREE(env->allocator, val); } axutil_hash_free(namespaces, env); } return parent; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap12_builder_helper_handle_event( axiom_soap12_builder_helper_t * builder_helper, const axutil_env_t * env, axiom_node_t * om_ele_node, int element_level) { axis2_char_t *ele_localname = NULL; axiom_element_t *om_ele = NULL; axiom_soap_body_t *soap_body = NULL; axiom_soap_fault_t *soap_fault = NULL; axiom_soap_envelope_t *soap_envelope = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, om_ele_node, AXIS2_FAILURE); om_ele = (axiom_element_t *) axiom_node_get_data_element(om_ele_node, env); if (!om_ele) { return AXIS2_FAILURE; } 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) { if (axutil_strcmp (AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME, ele_localname) == 0) { if (builder_helper->code_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_CODE_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Multiple fault code elements encountered in SOAP fault"); return AXIS2_FAILURE; } else { axiom_soap_fault_code_t *soap_fault_code = NULL; soap_fault_code = axiom_soap_fault_code_create(env); if (!soap_fault_code) { return AXIS2_FAILURE; } axiom_soap_fault_code_set_base_node(soap_fault_code, env, om_ele_node); axiom_soap_fault_code_set_builder(soap_fault_code, env, builder_helper->soap_builder); axiom_soap_fault_set_code(soap_fault, env, soap_fault_code); builder_helper->code_present = AXIS2_TRUE; builder_helper->code_processing = AXIS2_TRUE; } } else if (axutil_strcmp (AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME, ele_localname) == 0) { if (!(builder_helper->code_processing) && !(builder_helper->sub_code_processing)) { if (builder_helper->code_present) { if (builder_helper->reason_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_REASON_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Multiple fault reason elements encountered in SOAP fault"); return AXIS2_FAILURE; } else { axiom_soap_fault_reason_t *fault_reason = NULL; 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_ele_node); axiom_soap_fault_set_reason(soap_fault, env, fault_reason); axiom_soap_fault_reason_set_builder(fault_reason, env, builder_helper-> soap_builder); builder_helper->reason_present = AXIS2_TRUE; builder_helper->reason_processing = AXIS2_TRUE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { if (builder_helper->code_processing) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_CODE_DOES_NOT_HAVE_A_VALUE, AXIS2_FAILURE); return AXIS2_FAILURE; } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_CODE_DOES_NOT_HAVE_A_VALUE, AXIS2_FAILURE); return AXIS2_FAILURE; } } } else if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_NODE_LOCAL_NAME) == 0) { if (!(builder_helper->reason_processing)) { if (builder_helper->reason_present && !(builder_helper->role_present) && !(builder_helper->detail_present)) { if (builder_helper->node_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_NODE_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } else { axiom_soap_fault_node_t *soap_fault_node = NULL; soap_fault_node = axiom_soap_fault_node_create(env); if (!soap_fault_node) { return AXIS2_FAILURE; } axiom_soap_fault_node_set_base_node(soap_fault_node, env, om_ele_node); axiom_soap_fault_set_node(soap_fault, env, soap_fault_node); builder_helper->node_present = AXIS2_TRUE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED, AXIS2_FALSE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_REASON_ELEMENT_SHOULD_HAVE_A_TEXT, AXIS2_FALSE); return AXIS2_FAILURE; } } else if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_ROLE_LOCAL_NAME) == 0) { if (!(builder_helper->reason_processing)) { if (builder_helper->reason_present && !(builder_helper->detail_present)) { if (builder_helper->role_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_ROLE_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } else { axiom_soap_fault_role_t *soap_fault_role = NULL; soap_fault_role = axiom_soap_fault_role_create(env); if (!soap_fault_role) return AXIS2_FAILURE; axiom_soap_fault_role_set_base_node(soap_fault_role, env, om_ele_node); axiom_soap_fault_set_role(soap_fault, env, soap_fault_role); builder_helper->role_present = AXIS2_TRUE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_ROLE_ELEMENT_SHOULD_HAVE_A_TEXT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME) == 0) { if (!(builder_helper->reason_processing)) { if (builder_helper->reason_present) { if (builder_helper->detail_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_DETAIL_ELEMENTS_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } else { axiom_soap_fault_detail_t *soap_fault_detail = NULL; soap_fault_detail = axiom_soap_fault_detail_create(env); if (!soap_fault_detail) return AXIS2_FAILURE; axiom_soap_fault_detail_set_base_node(soap_fault_detail, env, om_ele_node); axiom_soap_fault_set_detail(soap_fault, env, soap_fault_detail); builder_helper->detail_present = AXIS2_TRUE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_WRONG_ELEMENT_ORDER_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_REASON_ELEMENT_SHOULD_HAVE_A_TEXT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNSUPPORTED_ELEMENT_IN_SOAP_FAULT_ELEMENT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (element_level == 5) { axiom_node_t *parent_node = NULL; axiom_element_t *parent_ele = NULL; axis2_char_t *parent_localname = NULL; parent_node = axiom_node_get_parent(om_ele_node, env); if (!parent_node) { return AXIS2_FAILURE; } parent_ele = (axiom_element_t *) axiom_node_get_data_element(parent_node, env); if (!parent_ele) { return AXIS2_FAILURE; } parent_localname = axiom_element_get_localname(parent_ele, env); if (!parent_localname) { return AXIS2_FAILURE; } if (axutil_strcmp(parent_localname, AXIOM_SOAP12_SOAP_FAULT_CODE_LOCAL_NAME) == 0) { if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME) == 0) { if (!(builder_helper->value_present)) { axiom_soap_fault_value_t *soap_fault_value = NULL; axiom_soap_fault_code_t *parent_fcode = NULL; soap_fault_value = axiom_soap_fault_value_create(env); if (!soap_fault_value) { return AXIS2_FAILURE; } axiom_soap_fault_value_set_base_node(soap_fault_value, env, om_ele_node); parent_fcode = axiom_soap_fault_get_code(soap_fault, env); if (!parent_fcode) { return AXIS2_FAILURE; } axiom_soap_fault_code_set_value(parent_fcode, env, soap_fault_value); builder_helper->value_present = AXIS2_TRUE; builder_helper->code_processing = AXIS2_FALSE; } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_VALUE_ENCOUNTERED_IN_CODE_ELEMENT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (axutil_strcmp(ele_localname, AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME) == 0) { if (!(builder_helper->sub_code_present)) { if (builder_helper->value_present) { axiom_soap_fault_sub_code_t *fault_subcode = NULL; axiom_soap_fault_code_t *fault_code = NULL; fault_subcode = axiom_soap_fault_sub_code_create(env); if (!fault_subcode) { return AXIS2_FAILURE; } axiom_soap_fault_sub_code_set_base_node(fault_subcode, env, om_ele_node); fault_code = axiom_soap_fault_get_code(soap_fault, env); if (!fault_code) { return AXIS2_FAILURE; } axiom_soap_fault_code_set_sub_code(fault_code, env, fault_subcode); axiom_soap_fault_sub_code_set_builder(fault_subcode, env, builder_helper-> soap_builder); builder_helper->sub_code_present = AXIS2_TRUE; builder_helper->sub_code_processing = AXIS2_TRUE; } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_VALUE_SHOULD_BE_PRESENT_BEFORE_SUB_CODE, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_THIS_LOCALNAME_NOT_SUPPORTED_INSIDE_THE_CODE_ELEMENT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (axutil_strcmp (parent_localname, AXIOM_SOAP12_SOAP_FAULT_REASON_LOCAL_NAME) == 0) { if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_TEXT_LOCAL_NAME) == 0) { axiom_soap_fault_text_t *soap_fault_text = NULL; axiom_soap_fault_reason_t *fault_reason = NULL; soap_fault_text = axiom_soap_fault_text_create(env); if (!soap_fault_text) { return AXIS2_FAILURE; } axiom_soap_fault_text_set_base_node(soap_fault_text, env, om_ele_node); fault_reason = axiom_soap_fault_get_reason(soap_fault, env); if (!fault_reason) { return AXIS2_FAILURE; } axiom_soap_fault_reason_add_soap_fault_text(fault_reason, env, soap_fault_text); builder_helper->reason_processing = AXIS2_FALSE; axiom_soap_builder_set_bool_processing_mandatory_fault_elements (builder_helper->soap_builder, env, AXIS2_FALSE); } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_THIS_LOCALNAME_IS_NOT_SUPPORTED_INSIDE_THE_REASON_ELEMENT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (axutil_strcmp (parent_localname, AXIOM_SOAP12_SOAP_FAULT_DETAIL_LOCAL_NAME) == 0) { axiom_soap_builder_set_processing_detail_elements(builder_helper-> soap_builder, env, AXIS2_TRUE); if (!(builder_helper->detail_element_names)) { builder_helper->detail_element_names = axutil_array_list_create(env, 20); } axutil_array_list_add(builder_helper->detail_element_names, env, ele_localname); } else { return AXIS2_FAILURE; } } else if (element_level > 5) { axiom_node_t *parent_node = NULL; axiom_element_t *parent_ele = NULL; axis2_char_t *parent_localname = NULL; parent_node = axiom_node_get_parent(om_ele_node, env); if (!parent_node) { return AXIS2_FAILURE; } parent_ele = (axiom_element_t *) axiom_node_get_data_element(parent_node, env); if (!parent_ele) { return AXIS2_FAILURE; } parent_localname = axiom_element_get_localname(parent_ele, env); if (!parent_localname) { return AXIS2_FAILURE; } if (axutil_strcmp (parent_localname, AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME) == 0) { if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_VALUE_LOCAL_NAME) == 0) { if (builder_helper->subcode_value_present) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } else { axiom_soap_fault_sub_code_t *sub_code = NULL; axiom_soap_fault_code_t *code = NULL; axiom_soap_fault_value_t *value = NULL; code = axiom_soap_fault_get_code(soap_fault, env); if (!code) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault code null when it should not be null"); return AXIS2_FAILURE; } sub_code = axiom_soap_fault_code_get_sub_code(code, env); if (!sub_code) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault subcode null when it should not be null"); return AXIS2_FAILURE; } value = axiom_soap_fault_value_create(env); if (!value) { return AXIS2_FAILURE; } axiom_soap_fault_value_set_base_node(value, env, om_ele_node); axiom_soap_fault_sub_code_set_value(sub_code, env, value); builder_helper->subcode_value_present = AXIS2_TRUE; builder_helper->sub_sub_code_present = AXIS2_FALSE; builder_helper->sub_code_processing = AXIS2_FALSE; } } else if (axutil_strcmp (ele_localname, AXIOM_SOAP12_SOAP_FAULT_SUB_CODE_LOCAL_NAME) == 0) { if (builder_helper->subcode_value_present) { if (!(builder_helper->sub_sub_code_present)) { axiom_soap_fault_code_t *fault_code = NULL; axiom_soap_fault_sub_code_t *parent_subcode = NULL; axiom_soap_fault_sub_code_t *subcode = NULL; subcode = axiom_soap_fault_sub_code_create(env); if (!subcode) { return AXIS2_FAILURE; } axiom_soap_fault_sub_code_set_base_node(subcode, env, om_ele_node); fault_code = axiom_soap_fault_get_code(soap_fault, env); if (!fault_code) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault code null when it should not be null"); return AXIS2_FAILURE; } parent_subcode = axiom_soap_fault_code_get_sub_code(fault_code, env); if (!parent_subcode) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "fault subcode null when it should not be null"); return AXIS2_FAILURE; } axiom_soap_fault_sub_code_set_sub_code(parent_subcode, env, subcode); builder_helper->subcode_value_present = AXIS2_FALSE; builder_helper->sub_sub_code_present = AXIS2_TRUE; builder_helper->sub_code_processing = AXIS2_TRUE; } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MULTIPLE_SUB_CODE_VALUES_ENCOUNTERED, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_FAULT_VALUE_SHOULD_BE_PRESENT_BEFORE_SUB_CODE, AXIS2_FAILURE); return AXIS2_FAILURE; } } else { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_THIS_LOCALNAME_IS_NOT_SUPPORTED_INSIDE_THE_SUB_CODE_ELEMENT, AXIS2_FAILURE); return AXIS2_FAILURE; } } else if (axiom_soap_builder_is_processing_detail_elements (builder_helper->soap_builder, env)) { int detail_element_level = 0; axis2_bool_t local_name_exists = AXIS2_FALSE; int i = 0; if (!(builder_helper->detail_element_names)) { return AXIS2_FAILURE; } for (i = 0; i < axutil_array_list_size(builder_helper->detail_element_names, env); i++) { if (axutil_strcmp (parent_localname, axutil_array_list_get(builder_helper->detail_element_names, env, i)) == 0) { local_name_exists = AXIS2_TRUE; detail_element_level = i + 1; } } if (local_name_exists) { axutil_array_list_add(builder_helper->detail_element_names, env, ele_localname); } else { return AXIS2_FAILURE; } } } return AXIS2_SUCCESS; }