axiom_node_t * generate_request_xml( const axutil_env_t * env) { axiom_node_t *op_node = NULL; axiom_element_t *op_ele = NULL; axiom_node_t *value_node = NULL; axiom_element_t *value_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *om_str = NULL; int value1 = 13; int value2 = 7; char value_str[64]; ns1 = axiom_namespace_create(env, "http://localhost/axis/Calculator", "ns1"); op_ele = axiom_element_create(env, NULL, "add", ns1, &op_node); value_ele = axiom_element_create(env, op_node, "in1", NULL, &value_node); sprintf(value_str, "%d", value1); axiom_element_set_text(value_ele, env, value_str, value_node); value_ele = axiom_element_create(env, op_node, "in2", NULL, &value_node); sprintf(value_str, "%d", value1); axiom_element_set_text(value_ele, env, value_str, value_node); printf("requesting %d + %d \n", value1, value2); om_str = axiom_node_to_string(op_node, env); if (om_str) printf("\nSending OM : %s\n", om_str); return op_node; }
static axiom_node_t * AXIS2_CALL Axis2Service_on_fault( axis2_svc_skeleton_t*, const axutil_env_t* pEnv, axiom_node_t* /*pNode*/) { staff::ScopedLock tLock(m_tFaultDetailsMutex); std::map<unsigned long, std::string>::iterator itFault = m_mFaultDetails.find(staff::Thread::GetCurrentId()); axiom_node_t* pErrorNode = NULL; axiom_element_t* pErrorElement = axiom_element_create(pEnv, NULL, "Exception", NULL, &pErrorNode); if (itFault != m_mFaultDetails.end()) { axiom_element_set_text(pErrorElement, pEnv, itFault->second.c_str(), pErrorNode); m_mFaultDetails.erase(itFault); } else { axiom_element_set_text(pErrorElement, pEnv, "No fault details", pErrorNode); } return pErrorNode; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_programatically( const axutil_env_t *env, axis2_char_t *text, axis2_char_t *seq) { axiom_node_t *ping_om_node = NULL; axiom_element_t* ping_om_ele = NULL; axiom_node_t *text_om_node = NULL; axiom_element_t* text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *buffer = NULL; axiom_node_t* seq_om_node = NULL; axiom_element_t * seq_om_ele = NULL; ns1 = axiom_namespace_create (env, "http://tempuri.org/", "ns1"); ping_om_ele = axiom_element_create(env, NULL, "ping", ns1, &ping_om_node); text_om_ele = axiom_element_create(env, ping_om_node, "Text", ns1, &text_om_node); seq_om_ele = axiom_element_create(env, ping_om_node, "Sequence", ns1, &seq_om_node); axiom_element_set_text(text_om_ele, env, text, text_om_node); axiom_element_set_text(text_om_ele, env, seq, seq_om_node); buffer = axiom_node_to_string(ping_om_node, env); if(buffer) { printf("\nSending OM node in XML : %s \n", buffer); AXIS2_FREE(env->allocator, buffer); } return ping_om_node; }
axiom_node_t * build_soap_body_content( const axutil_env_t * env, const axis2_char_t * operation, const axis2_char_t * google_key, const axis2_char_t * word_to_spell) { axiom_node_t *google_om_node = NULL; axiom_element_t *google_om_ele = NULL; axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_namespace_t *ns0 = NULL, *ns1 = NULL, *ns2 = NULL, *ns3 = NULL; axiom_attribute_t *attri1 = NULL; axis2_char_t *buffer = NULL; ns0 = axiom_namespace_create(env, AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI, "soapenv"); ns1 = axiom_namespace_create(env, "urn:GoogleSearch", "ns1"); ns2 = axiom_namespace_create(env, "http://www.w3.org/1999/XMLSchema-instance", "xsi"); ns3 = axiom_namespace_create(env, "http://www.w3.org/1999/XMLSchema", "xsd"); attri1 = axiom_attribute_create(env, "encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/", ns0); google_om_ele = axiom_element_create(env, NULL, operation, ns1, &google_om_node); axiom_element_add_attribute(google_om_ele, env, attri1, google_om_node); axiom_element_declare_namespace(google_om_ele, env, google_om_node, ns2); axiom_element_declare_namespace(google_om_ele, env, google_om_node, ns3); text_om_ele = axiom_element_create(env, google_om_node, "key", NULL, &text_om_node); attri1 = axiom_attribute_create(env, "type", "xsd:string", ns2); axiom_element_add_attribute(text_om_ele, env, attri1, text_om_node); axiom_element_set_text(text_om_ele, env, google_key, text_om_node); text_om_ele = axiom_element_create(env, google_om_node, "phrase", NULL, &text_om_node); axiom_element_add_attribute(text_om_ele, env, attri1, text_om_node); axiom_element_set_text(text_om_ele, env, word_to_spell, text_om_node); buffer = axiom_node_to_string(google_om_node, env); printf("%s\n", buffer); AXIS2_FREE (env->allocator, buffer); return google_om_node; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_payload_for_echo_svc( const axutil_env_t *env) { axiom_node_t *echo_om_node = NULL; axiom_element_t* echo_om_ele = NULL; axiom_node_t* text_om_node = NULL; axiom_element_t * text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *om_str = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/rampart/c/samples", "ns1"); /*ns1 = axiom_namespace_create(env, "http://echo.services.wsas.wso2.org", "ns1");*/ echo_om_ele = axiom_element_create(env, NULL, "echoIn", ns1, &echo_om_node); text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node); axiom_element_set_text(text_om_ele, env, "Hello", text_om_node); om_str = axiom_node_to_string(echo_om_node, env); if(om_str) { printf("\nSending OM : %s\n", om_str); AXIS2_FREE(env->allocator, om_str); om_str = NULL; } return echo_om_node; }
axiom_node_t* AXIS2_CALL axis2_svc_skel_IIp2Location_on_fault(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *node) { axiom_node_t *error_node = NULL; axiom_element_t *error_ele = NULL; axutil_error_codes_t error_code; axis2_svc_skel_IIp2Location_t *svc_skeleton_wrapper = NULL; svc_skeleton_wrapper = (axis2_svc_skel_IIp2Location_t*)svc_skeleton; error_code = env->error->error_number; if(error_code <= AXIS2_SKEL_IIP2LOCATION_ERROR_NONE || error_code >= AXIS2_SKEL_IIP2LOCATION_ERROR_LAST ) { error_ele = axiom_element_create(env, node, "fault", NULL, &error_node); axiom_element_set_text(error_ele, env, "IIp2Location|http://ws.apache.org/axis2 failed", error_node); } return error_node; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_fault_text_set_text( axiom_soap_fault_text_t * fault_text, const axutil_env_t * env, axis2_char_t * value, axis2_char_t * lang) { AXIS2_PARAM_CHECK(env->error, value, AXIS2_FAILURE); if(fault_text->om_ele_node) { axiom_element_t *text_ele = NULL; text_ele = (axiom_element_t *)axiom_node_get_data_element(fault_text->om_ele_node, env); if(text_ele) { axiom_element_set_text(text_ele, env, value, fault_text->om_ele_node); if(lang) { axiom_soap_fault_text_set_lang(fault_text, env, lang); } return AXIS2_SUCCESS; } } return AXIS2_FAILURE; }
AXIS2_EXTERN axiom_node_t* AXIS2_CALL service_admin_util_serialize_param(axutil_env_t *env, axutil_param_t *param) { axis2_char_t *name = NULL; axis2_char_t *value = NULL; void *param_value = NULL; axiom_node_t *param_node = NULL; axiom_element_t *param_ele = NULL; axiom_attribute_t *attri = NULL; name = axutil_param_get_name(param, env); param_value = axutil_param_get_value(param, env); if(name && axutil_strcmp(name, "ServiceClass") ==0) { return NULL; }else { value = (axis2_char_t*)param_value; } param_ele = axiom_element_create(env, NULL, "parameter", NULL, ¶m_node); attri = axiom_attribute_create(env, "name", name, NULL); axiom_element_add_attribute(param_ele, env, attri, param_node); if(value) axiom_element_set_text(param_ele, env, value, param_node); return param_node; }
AXIS2_EXTERN axiom_node_t *AXIS2_CALL remote_registry_util_serialize_tag( const axutil_env_t *env, axis2_char_t *tag) { axiom_node_t *entry_node = NULL; axiom_element_t *entry_element = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *content = NULL; axiom_node_t *content_node = NULL; axiom_element_t *content_element = NULL; axiom_node_t *summary_node = NULL; axiom_element_t *summary_element = NULL; axiom_attribute_t *type_attr = NULL; axis2_char_t *media_type = NULL; ns1 = axiom_namespace_create(env, REMOTE_REGISTRY_ATOM_NS, "ns1"); entry_element = axiom_element_create(env, NULL, "entry", ns1, &entry_node); /* getting variables from the argument and rendering into an XML */ content_element = axiom_element_create(env, entry_node, "content", ns1, &content_node); axiom_element_set_text(content_element, env, tag, content_node); type_attr = axiom_attribute_create(env, "type", "text", NULL); axiom_element_add_attribute(content_element, env, type_attr, content_node); return entry_node; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_payload_for_echo_svc( const axutil_env_t * env) { axiom_node_t *echo_om_node = NULL; axiom_element_t *echo_om_ele = NULL; axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *om_str = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/services/echo", "ns1"); echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node); text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node); axiom_element_set_text(text_om_ele, env, "Hello World!", text_om_node); om_str = axiom_node_to_string(echo_om_node, env); if (om_str) printf("\nSending OM : %s\n", om_str); AXIS2_FREE(env->allocator, om_str); return echo_om_node; }
axiom_node_t* AXIS2_CALL axis2_svc_skel_StatisticsAdmin_on_fault(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *node) { axiom_node_t *error_node = NULL; axiom_element_t *error_ele = NULL; axutil_error_codes_t error_code; axis2_svc_skel_StatisticsAdmin_t *svc_skeleton_wrapper = NULL; svc_skeleton_wrapper = (axis2_svc_skel_StatisticsAdmin_t*)svc_skeleton; error_code = env->error->error_number; if(error_code <= AXIS2_SKEL_STATISTICSADMIN_ERROR_NONE || error_code >= AXIS2_SKEL_STATISTICSADMIN_ERROR_LAST ) { error_ele = axiom_element_create(env, node, "fault", NULL, &error_node); axiom_element_set_text(error_ele, env, "StatisticsAdmin|http://services.statistics.carbon.wso2.org failed", error_node); } return error_node; }
axis2_status_t AXIS2_CALL savan_client_add_sub_id_to_soap_header( savan_client_t *client, const axutil_env_t *env, axis2_svc_client_t *svc_client) { axiom_namespace_t *ns = NULL; axiom_node_t *id_node = NULL; axiom_element_t *id_elem = NULL; /* Create a node with the subscription id and attach it as a soap header * to the service client */ ns = axiom_namespace_create(env, EVENTING_NAMESPACE, EVENTING_NS_PREFIX); id_elem = axiom_element_create(env, NULL, ELEM_NAME_ID, ns, &id_node); if (!id_elem) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[savan] [client] Failed to " "create element for Identifier node"); return AXIS2_FAILURE; } AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "client->sub_id:%s\n", client->sub_id); axiom_element_set_text(id_elem, env, client->sub_id, id_node); axis2_svc_client_add_header(svc_client, env, id_node); return AXIS2_SUCCESS; }
/* Builds the response content */ axiom_node_t * build_response1( const axutil_env_t * env, axis2_char_t * text) { axiom_node_t *mtom_om_node = NULL; axiom_element_t *mtom_om_ele = NULL; axiom_node_t *om_node = NULL; axiom_element_t *om_ele = NULL; axiom_namespace_t *ns1 = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples", "ns1"); mtom_om_ele = axiom_element_create(env, NULL, "response", ns1, &mtom_om_node); om_ele = axiom_element_create(env, mtom_om_node, "string", NULL, &om_node); axiom_element_set_text(mtom_om_ele, env, text, om_node); return mtom_om_node; }
/** * Creates <ds:X509IssuerName> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_issuer_name_element( const axutil_env_t *env, axiom_node_t *parent, axis2_char_t* value) { axiom_node_t *issuer_name_node = NULL; axiom_element_t *issuer_name_ele = NULL; axiom_namespace_t *ns_obj = NULL; ns_obj = axiom_namespace_create(env, OXS_DSIG_NS, OXS_DS); issuer_name_ele = axiom_element_create( env, parent, OXS_NODE_X509_ISSUER_NAME, ns_obj, &issuer_name_node); if (!issuer_name_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating X509IssuerName element."); axiom_namespace_free(ns_obj, env); return NULL; } if (value) { axiom_element_set_text(issuer_name_ele, env, value, issuer_name_node); } return issuer_name_node; }
AXIS2_EXTERN axiom_node_t *AXIS2_CALL remote_registry_comment_serialize( remote_registry_comment_t *comment, const axutil_env_t *env) { axiom_node_t *entry_node = NULL; axiom_element_t *entry_element = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *author = NULL; axis2_char_t *content = NULL; ns1 = axiom_namespace_create(env, REMOTE_REGISTRY_ATOM_NS, "ns1"); entry_element = axiom_element_create(env, NULL, "entry", ns1, &entry_node); /* getting variables from the structure and rendering into an XML */ author = remote_registry_comment_get_user(comment, env); if(author) { axiom_node_t *author_node = NULL; axiom_node_t *name_node = NULL; axiom_element_t *name_ele = NULL; axiom_element_create(env, entry_node, "author", ns1, &author_node); name_ele = axiom_element_create(env, author_node, "name", ns1, &name_node); axiom_element_set_text(name_ele, env, author, name_node); } content = remote_registry_comment_get_text(comment, env); if(content) { axiom_node_t *content_node = NULL; axiom_element_t *content_element = NULL; axiom_attribute_t *type_attr = NULL; axis2_char_t *media_type = NULL; content_element = axiom_element_create(env, entry_node, "content", ns1, &content_node); axiom_element_set_text(content_element, env, content, content_node); type_attr = axiom_attribute_create(env, "type", "text", NULL); axiom_element_add_attribute(content_element, env, type_attr, content_node); } return entry_node; }
axiom_node_t* AXIS2_CALL axis2_svc_skel_TraderExchange_on_fault(axis2_svc_skeleton_t *svc_skeleton, const axutil_env_t *env, axiom_node_t *node) { axiom_node_t *error_node = NULL; axiom_element_t *error_ele = NULL; error_ele = axiom_element_create(env, node, "fault", NULL, &error_node); axiom_element_set_text(error_ele, env, "TraderExchange|http://www.wso2.org failed", error_node); return error_node; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_programatically_mtom( const axutil_env_t * env) { axiom_node_t *mtom_om_node = NULL; axiom_element_t *mtom_om_ele = NULL; axiom_node_t *image_om_node = NULL; axiom_element_t *image_om_ele = NULL; axiom_node_t *file_om_node = NULL; axiom_element_t *file_om_ele = NULL; axiom_node_t *data_om_node = NULL; axiom_text_t *data_text = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *om_str = NULL; const axis2_char_t *image_name = "E:/src/C/Axis2C/build/deploy/samples/bin/resources/axis2.jpg"; const axis2_char_t *to_save_name = "test.jpg"; axis2_bool_t optimized = AXIS2_TRUE; axiom_data_handler_t *data_handler = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples/mtom", "ns1"); mtom_om_ele = axiom_element_create(env, NULL, "mtomSample", ns1, &mtom_om_node); file_om_ele = axiom_element_create(env, mtom_om_node, "fileName", ns1, &file_om_node); axiom_element_set_text(file_om_ele, env, to_save_name, file_om_node); image_om_ele = axiom_element_create(env, mtom_om_node, "image", ns1, &image_om_node); /* This is when we directly give file name */ data_handler = axiom_data_handler_create(env, image_name, "image/jpeg"); /* Uncomment following to set a callback instead of a file */ /*data_handler = axiom_data_handler_create(env, NULL, "image/jpeg"); axiom_data_handler_set_data_handler_type(data_handler, env, AXIOM_DATA_HANDLER_TYPE_CALLBACK); axiom_data_handler_set_user_param(data_handler, env, (void *)image_name);*/ data_text = axiom_text_create_with_data_handler(env, image_om_node, data_handler, &data_om_node); axiom_text_set_optimize(data_text, env, optimized); /*axiom_text_set_is_swa(data_text, env, AXIS2_TRUE);*/ om_str = axiom_node_to_string(mtom_om_node, env); if(om_str) { printf("%s", om_str); AXIS2_FREE(env->allocator, om_str); } return mtom_om_node; }
/* build SOAP request message content using OM (for java interop)*/ axiom_node_t * build_om_payload_for_echo_svc_interop( const axutil_env_t *env) { axiom_node_t *ping_request_om_node = NULL; axiom_element_t* ping_request_om_ele = NULL; axiom_node_t *ping_om_node = NULL; axiom_element_t* ping_om_ele = NULL; axiom_node_t* text_om_node = NULL; axiom_element_t * text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axiom_namespace_t *ns0 = NULL; axis2_char_t *om_str = NULL; ns0 = axiom_namespace_create(env, "http://InteropBaseAddress/interop", "ns0"); ns1 = axiom_namespace_create(env, "http://xmlsoap.org/Ping", "ns1"); ping_request_om_ele = axiom_element_create(env, NULL, "PingRequest", ns0, &ping_request_om_node); ping_om_ele = axiom_element_create(env, ping_request_om_node, "Ping", ns1, &ping_om_node); text_om_ele = axiom_element_create(env, ping_om_node, "scenario", ns1, &text_om_node); axiom_element_set_text(text_om_ele, env, "scenario", text_om_node); text_om_node = NULL; text_om_ele = axiom_element_create(env, ping_om_node, "origin", ns1, &text_om_node); axiom_element_set_text(text_om_ele, env, "origin", text_om_node); text_om_node = NULL; text_om_ele = axiom_element_create(env, ping_om_node, "text", ns1, &text_om_node); axiom_element_set_text(text_om_ele, env, "text", text_om_node); om_str = axiom_node_to_string(ping_request_om_node, env); if(om_str) { printf("\nSending OM : %s\n", om_str); AXIS2_FREE(env->allocator, om_str); om_str = NULL; } return ping_request_om_node; }
axis2_status_t axis2_addr_out_handler_process_any_content_type( const axutil_env_t * env, axis2_any_content_type_t * reference_values, axiom_node_t * parent_ele_node, const axis2_char_t * addr_ns) { axutil_hash_t *value_ht = NULL; axutil_hash_index_t *hash_index = NULL; if(reference_values) { const void *key = NULL; void *val = NULL; axis2_ssize_t len = 0; value_ht = axis2_any_content_type_get_value_map(reference_values, env); if(!value_ht) { return AXIS2_FAILURE; } for(hash_index = axutil_hash_first(value_ht, env); hash_index; hash_index = axutil_hash_next(env, hash_index)) { axutil_hash_this(hash_index, &key, &len, &val); if(key) { axiom_node_t *node = NULL; axiom_element_t *ele = NULL; ele = axiom_element_create(env, parent_ele_node, key, NULL, &node); if(ele) { if(!axutil_strcmp(AXIS2_WSA_NAMESPACE, addr_ns)) { axiom_namespace_t *addr_ns_obj = NULL; axiom_attribute_t *att = NULL; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); att = axiom_attribute_create(env, AXIS2_WSA_IS_REFERENCE_PARAMETER_ATTRIBUTE, AXIS2_WSA_TYPE_ATTRIBUTE_VALUE, addr_ns_obj); } axiom_element_set_text(ele, env, val, node); } } } } return AXIS2_SUCCESS; }
/* On fault, handle the fault */ axiom_node_t* AXIS2_CALL echo_on_fault(axis2_svc_skeleton_t *svc_skeli, const axutil_env_t *env, axiom_node_t *node) { /* Here we are just setting a simple error message inside an element * called 'EchoServiceError' */ axiom_node_t *error_node = NULL; axiom_node_t *text_node = NULL; axiom_element_t *error_ele = NULL; error_ele = axiom_element_create(env, NULL, "EchoServiceError", NULL, &error_node); axiom_element_set_text(error_ele, env, "Echo service failed ", text_node); return error_node; }
axiom_node_t * axis2_addr_out_handler_process_string_info( const axutil_env_t * env, const axis2_char_t * value, const axis2_char_t * type, axiom_soap_header_t ** soap_header_p, const axis2_char_t * addr_ns, axis2_bool_t set_must_understand) { axiom_soap_header_t *soap_header = NULL; axiom_soap_header_block_t *header_block = NULL; axiom_node_t *header_block_node = NULL; axiom_element_t *header_block_ele = NULL; AXIS2_ENV_CHECK(env, NULL); AXIS2_PARAM_CHECK(env->error, value, NULL); AXIS2_PARAM_CHECK(env->error, type, NULL); AXIS2_PARAM_CHECK(env->error, soap_header_p, NULL); AXIS2_PARAM_CHECK(env->error, addr_ns, NULL); soap_header = *(soap_header_p); if(value && *value) { axiom_namespace_t *addr_ns_obj = NULL; addr_ns_obj = axiom_namespace_create(env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); header_block = axiom_soap_header_add_header_block(soap_header, env, type, addr_ns_obj); header_block_node = axiom_soap_header_block_get_base_node(header_block, env); header_block_ele = (axiom_element_t *)axiom_node_get_data_element(header_block_node, env); if(header_block_ele) { axiom_namespace_t *dec_ns = NULL; axiom_element_set_text(header_block_ele, env, value, header_block_node); dec_ns = axiom_element_find_declared_namespace(header_block_ele, env, addr_ns, AXIS2_WSA_DEFAULT_PREFIX); if(!dec_ns) { axiom_namespace_free(addr_ns_obj, env); addr_ns_obj = NULL; } } if(set_must_understand) { axiom_soap_header_block_set_must_understand_with_bool(header_block, env, AXIS2_TRUE); } } return header_block_node; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_fault_value_set_text( axiom_soap_fault_value_t * fault_value, const axutil_env_t * env, axis2_char_t * text) { AXIS2_PARAM_CHECK(env->error, text, AXIS2_FAILURE); if(fault_value->om_ele_node && axiom_node_get_node_type(fault_value->om_ele_node, env) == AXIOM_ELEMENT) { axiom_element_t *om_ele = NULL; om_ele = (axiom_element_t *)axiom_node_get_data_element(fault_value->om_ele_node, env); return axiom_element_set_text(om_ele, env, text, fault_value->om_ele_node); } return AXIS2_FAILURE; }
/** * Creates <wsc:Length> element */ AXIS2_EXTERN axiom_node_t* AXIS2_CALL oxs_token_build_length_element( const axutil_env_t *env, axiom_node_t *parent, int length, axis2_char_t *wsc_ns_uri) { axiom_node_t *length_node = NULL; axiom_element_t *length_ele = NULL; axis2_status_t ret; axiom_namespace_t *ns_obj = NULL; axis2_char_t *length_val = NULL; if(!wsc_ns_uri) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element. SecConv namespace uri is not valid.", OXS_NODE_LENGTH); return NULL; } ns_obj = axiom_namespace_create(env, wsc_ns_uri, OXS_WSC); length_ele = axiom_element_create(env, parent, OXS_NODE_LENGTH, ns_obj, &length_node); if(!length_ele) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s Token element.", OXS_NODE_LENGTH); axiom_namespace_free(ns_obj, env); return NULL; } if(length > 0) { length_val = (axis2_char_t *) AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 32); sprintf(length_val, "%d", length ); } if(length_val) { ret = axiom_element_set_text(length_ele, env, length_val, length_node); AXIS2_FREE(env->allocator, length_val); } return length_node; }
/* Builds the response content */ axiom_node_t * build_om_programatically( const axutil_env_t * env, axis2_char_t * text) { axiom_node_t *echo_om_node = NULL; axiom_element_t *echo_om_ele = NULL; axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples", "ns1"); echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node); text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node); axiom_element_set_text(text_om_ele, env, text, text_om_node); axiom_namespace_free(ns1, env); return echo_om_node; }
/** Add a node with an element to root_node, either as child or as sibling. * The element name is in the same namespace as the root node's name. * The element may optionally include one attribute; if no attribute * is desired then pass 'NULL'. * * Example with attribute: * node_id.name="foo"; node.value="bar"; * attribute.name="attr"; attribute.value="Zar"; * Result : <ns:foo attr="Zar">bar</ns:foo> * * @param env * @param root_node * @param node_id * node_id.name: name of element to be added, * node_id.value: text of element * @param attribute optional Name_value pair for setting an attribute, * may be NULL. * @param sibling 1: add as sibling, 0: add as child. * @param whitespace: whitespace added before the newly added element (the * newly added element is indented by this space. * @return ptr to the the newly added node. */ static axiom_node_t *rp_add_node( const axutil_env_t *env, axiom_node_t *root_node, Name_value *node_id, Name_value *attribute, int sibling, const axis2_char_t *whitespace ) { sp_add_whspace(env, root_node, whitespace); axiom_namespace_t * ns = rp_get_namespace (env, root_node); axiom_node_t *new_node = axiom_node_create(env); axiom_element_t *new_ele = axiom_element_create(env, NULL, node_id->name, ns, &new_node); if (NULL != node_id->value) { axiom_element_set_text(new_ele, env, node_id->value, new_node); } if (NULL != attribute) { axiom_attribute_t *attr = axiom_attribute_create (env, attribute->name, attribute->value, NULL); axiom_element_add_attribute (new_ele, env, attr, new_node); } axis2_status_t success = ( sibling ? axiom_node_insert_sibling_after (root_node, env, new_node) : axiom_node_add_child (root_node, env, new_node) ); if (AXIS2_SUCCESS != success) { rp_log_error(env, "*** S2P(%s:%d): Failed to add node name='%s'\n", __FILE__, __LINE__, node_id->name); } return new_node; }
void axis2_addr_in_create_fault_envelope( const axutil_env_t * env, const axis2_char_t * header_name, const axis2_char_t * addr_ns_str, axis2_msg_ctx_t * msg_ctx) { axiom_soap_envelope_t *envelope = NULL; axutil_array_list_t *sub_codes = NULL; int soap_version = AXIOM_SOAP12; axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; if (axis2_msg_ctx_get_is_soap_11(msg_ctx, env)) { soap_version = AXIOM_SOAP11; } ns1 = axiom_namespace_create(env, addr_ns_str, AXIS2_WSA_DEFAULT_PREFIX); text_om_ele = axiom_element_create(env, NULL, "ProblemHeaderQName", ns1, &text_om_node); axiom_element_set_text(text_om_ele, env, header_name, text_om_node); sub_codes = axutil_array_list_create(env, 2); if (sub_codes) { axutil_array_list_add(sub_codes, env, "wsa:InvalidAddressingHeader"); axutil_array_list_add(sub_codes, env, "wsa:InvalidCardinality"); } envelope = axiom_soap_envelope_create_default_soap_fault_envelope(env, "soapenv:Sender", "A header representing a Message Addressing Property is not valid and the message cannot be processed", soap_version, sub_codes, text_om_node); axis2_msg_ctx_set_fault_soap_envelope(msg_ctx, env, envelope); axis2_msg_ctx_set_wsa_action(msg_ctx, env, "http://www.w3.org/2005/08/addressing/fault"); return; }
axiom_node_t * AXIS2_CALL create_saml_assertion(const axutil_env_t *env) { saml_assertion_t *assertion = NULL; saml_attr_stmt_t *attr_stmt = NULL; saml_subject_t *subject = NULL; saml_named_id_t *named_id = NULL; saml_attr_t *attr = NULL; axiom_node_t *attr_val = NULL; axiom_element_t *e = NULL; saml_stmt_t *stmt = NULL; assertion = saml_assertion_create(env); attr_stmt = saml_attr_stmt_create(env); subject = saml_subject_create(env); saml_assertion_set_issue_instant(assertion, env, axutil_date_time_create(env)); saml_assertion_set_issuer(assertion, env, "www.mrt.ac.lk"); saml_assertion_set_minor_version(assertion, env, 1); saml_subject_add_confirmation(subject, env, SAML_SUB_CONFIRMATION_SENDER_VOUCHES); named_id = saml_named_id_create(env); saml_named_id_set_name(named_id, env, "cse07"); saml_subject_set_named_id(subject, env, named_id); attr = saml_attr_create(env); saml_attr_set_name(attr, env, "csestudent"); saml_attr_set_namespace(attr, env, "www.mrt.ac.lk/cse"); e = axiom_element_create(env, NULL, "noofstudent", NULL, &attr_val); axiom_element_set_text(e, env, "10", attr_val); saml_attr_add_value(attr, env, attr_val); saml_attr_stmt_set_subject(attr_stmt, env, subject); saml_attr_stmt_add_attribute(attr_stmt, env, attr); stmt = saml_stmt_create(env); saml_stmt_set_stmt(stmt, env, attr_stmt, SAML_STMT_ATTRIBUTESTATEMENT); saml_assertion_add_statement(assertion, env, stmt); return saml_assertion_to_om(assertion, NULL, env); }
/* build SOAP request message content using OM */ axiom_node_t * build_om_payload_for_echo_svc( const axutil_env_t *env, axis2_char_t *text) { axiom_node_t *echo_om_node = NULL; axiom_element_t* echo_om_ele = NULL; axiom_node_t* text_om_node = NULL; axiom_element_t * text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axis2_char_t *ns = NULL; ns = "http://tempuri.org/"; ns1 = axiom_namespace_create (env, ns, "ns1"); echo_om_ele = axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node); text_om_ele = axiom_element_create(env, echo_om_node, "Text", NULL, &text_om_node); axiom_element_set_text(text_om_ele, env, text, text_om_node); return echo_om_node; }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_soap_fault_role_set_role_value( axiom_soap_fault_role_t * fault_role, const axutil_env_t * env, axis2_char_t * uri) { axiom_element_t *role_ele = NULL; AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE); if(!fault_role->om_ele_node) { return AXIS2_FAILURE; } role_ele = (axiom_element_t *)axiom_node_get_data_element(fault_role->om_ele_node, env); if(role_ele) { return axiom_element_set_text(role_ele, env, uri, fault_role->om_ele_node); } return AXIS2_FAILURE; }
/* build SOAP request message content using OM */ axiom_node_t * build_om_payload_for_echo_svc( const axutil_env_t * env, const axis2_char_t * echo_text) { axiom_node_t *echo_om_node = NULL; /*axiom_element_t *echo_om_ele = NULL; */ axiom_node_t *text_om_node = NULL; axiom_element_t *text_om_ele = NULL; axiom_namespace_t *ns1 = NULL; ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/c/samples", "ns1"); /*echo_om_ele =*/ axiom_element_create(env, NULL, "echoString", ns1, &echo_om_node); text_om_ele = axiom_element_create(env, echo_om_node, "text", NULL, &text_om_node); axiom_element_set_text(text_om_ele, env, echo_text, text_om_node); return echo_om_node; }