AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_serialize_namespace( axiom_text_t * om_text, const axutil_env_t * env, const axiom_namespace_t * om_namespace, axiom_output_t * om_output) { axiom_xml_writer_t *xml_writer = NULL; axis2_char_t *namespace_uri = NULL; axis2_char_t *namespace_prefix = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); (void)om_output; xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); /* What does this code do? */ /* om_namespace = axiom_namespace_create(env, "", ""); if(om_namespace) */ { namespace_uri = axiom_namespace_get_uri(om_text->ns, env); namespace_prefix = axiom_namespace_get_prefix(om_text->ns, env); axiom_xml_writer_write_namespace(xml_writer, env, namespace_prefix, namespace_uri); axiom_xml_writer_set_prefix(xml_writer, env, namespace_prefix, namespace_uri); } return AXIS2_SUCCESS; }
char * wsf_util_serialize_om ( const axutil_env_t * env, axiom_node_t * ret_node) { axiom_xml_writer_t *writer = NULL; axiom_output_t *om_output = NULL; axis2_char_t *buffer = NULL, *new_buffer = NULL; unsigned int buffer_len = 0; writer = axiom_xml_writer_create_for_memory (env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); om_output = axiom_output_create (env, writer); axiom_node_serialize (ret_node, env, om_output); buffer = (axis2_char_t *) axiom_xml_writer_get_xml (writer, env); buffer_len = axutil_strlen (buffer); new_buffer = AXIS2_MALLOC (env->allocator, sizeof (axis2_char_t) * (buffer_len + 1)); memcpy (new_buffer, buffer, buffer_len); new_buffer[buffer_len] = '\0'; axiom_output_free(om_output, env); return new_buffer; }
axis2_status_t AXIS2_CALL om_node_serialize( axiom_node_t * node, const axutil_env_t * env) { axiom_output_t *om_output = NULL; axiom_xml_writer_t *writer = NULL; axis2_char_t *output_buffer = NULL; axis2_status_t status = AXIS2_FAILURE; writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); om_output = axiom_output_create(env, writer); status = axiom_node_serialize(node, env, om_output); if (status != AXIS2_SUCCESS) { printf("\naxiom_node_serialize failed\n"); return 0; } else printf("\naxiom_node_serialize success\n"); /* end serializing stuff */ /*axiom_node_free_tree(node1, env); */ output_buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env); printf("\nend test_om_serialize\n"); }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axiom_text_serialize_attribute( axiom_text_t * om_text, const axutil_env_t * env, axiom_output_t * om_output, axiom_attribute_t * om_attribute) { axiom_xml_writer_t *xml_writer = NULL; axiom_namespace_t *om_namespace = NULL; axis2_char_t *namespace_uri = NULL; axis2_char_t *prefix = NULL; axis2_char_t *attribute_local_name = NULL; axis2_char_t *attribute_value = NULL; AXIS2_ENV_CHECK(env, AXIS2_FAILURE); (void)om_output; xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); om_namespace = axiom_namespace_create(env, "", ""); namespace_uri = axiom_namespace_get_uri(om_text->ns, env); attribute_local_name = axiom_attribute_get_localname(om_attribute, env); if(om_namespace) { prefix = axiom_namespace_get_prefix(om_text->ns, env); attribute_value = axiom_attribute_get_value(om_attribute, env); if(prefix) { axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value); } else { axiom_xml_writer_write_attribute_with_namespace(xml_writer, env, attribute_local_name, attribute_value, namespace_uri); } } else { axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value); } axiom_namespace_free(om_namespace, env); return AXIS2_SUCCESS; }
axiom_node_t * build_om_programatically( const axutil_env_t * env) { axiom_node_t *version_om_node = NULL; axiom_element_t *version_om_ele = NULL; axiom_namespace_t *ns1 = NULL; axiom_xml_writer_t *xml_writer = NULL; axiom_output_t *om_output = NULL; axis2_char_t *buffer = NULL; ns1 = axiom_namespace_create(env, "urn:aewebservices71", "ns1"); version_om_ele = axiom_element_create(env, NULL, "GetVersion", ns1, &version_om_node); xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, AXIS2_XML_PARSER_TYPE_BUFFER); om_output = axiom_output_create(env, xml_writer); axiom_node_serialize(version_om_node, env, om_output); buffer = (axis2_char_t *) axiom_xml_writer_get_xml(xml_writer, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n", buffer); if (om_output) { axiom_output_free(om_output, env); om_output = NULL; } axiom_namespace_free(ns1, env); return version_om_node; }
int main( int argc, char **argv) { axis2_stub_t *stub = NULL; axiom_node_t *node = NULL; axis2_status_t status = AXIS2_FAILURE; const axutil_env_t *env = NULL; const axis2_char_t *address = NULL; const axis2_char_t *client_home = NULL; axiom_node_t *ret_node = NULL; const axis2_char_t *operation = "get_version"; const axis2_char_t *param1 = "40"; const axis2_char_t *param2 = "8"; env = axutil_env_create_all("version_blocking.log", AXIS2_LOG_LEVEL_TRACE); client_home = AXIS2_GETENV("AXIS2C_HOME"); if (!client_home || !strcmp(client_home, "")) client_home = "../.."; address = "http://localhost:9090/axis2/services/version"; if (argc > 1) operation = argv[1]; if (axutil_strcmp(operation, "-h") == 0) { printf("Usage : %s [operation] [param1] [param2] [endpoint_url]\n", argv[0]); printf("use -h for help\n"); printf("default operation get_version\n"); printf("default param1 %s\n", param1); printf("default param2 %s\n", param2); printf("default endpoint_url %s\n", address); printf ("NOTE: command line arguments must appear in given order, with trailing ones being optional\n"); return 0; } if (argc > 2) param1 = argv[2]; if (argc > 3) param2 = argv[3]; if (argc > 4) address = argv[4]; printf("Using endpoint : %s\n", address); printf("\nInvoking operation %s\n", operation); node = build_om_programatically(env); stub = axis2_version_stub_create_with_endpoint_uri_and_client_home(env, address, client_home); /* create node and invoke version */ if (stub) { ret_node = axis2_version_stub_get_version(stub, env, node); } if (ret_node) { if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT) { axis2_char_t *result = NULL; axiom_element_t *result_ele = (axiom_element_t *) axiom_node_get_data_element(ret_node, env); result = axiom_element_get_text(result_ele, env, ret_node); printf("\nResult = %s\n", result); } else { axiom_xml_writer_t *writer = NULL; axiom_output_t *om_output = NULL; axis2_char_t *buffer = NULL; writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); om_output = axiom_output_create(env, writer); axiom_node_serialize(ret_node, env, om_output); buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, env); printf("\nReceived invalid OM as result : %s\n", buffer); if (buffer) { AXIS2_FREE(env->allocator, buffer); buffer = NULL; } if (om_output) { axiom_output_free(om_output, env); om_output = NULL; } axiom_xml_writer_free(writer, env); } } 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("version stub invoke FAILED!\n"); } if (stub) { axis2_stub_free(stub, env); } if (env) { axutil_env_free((axutil_env_t *) env); env = NULL; } return status; }
static int ngx_squ_xml_serialize(squ_State *l) { int top; char *uri, *prefix; axiom_node_t *node; axutil_env_t *env; axutil_log_t *log; axutil_error_t *error; axiom_output_t *output; ngx_squ_thread_t *thr; axiom_namespace_t *ns; axiom_soap_body_t *body; axutil_allocator_t *a; axiom_xml_writer_t *writer; axiom_soap_header_t *header; axiom_soap_envelope_t *envelope; thr = ngx_squ_thread(l); ngx_log_debug0(NGX_LOG_DEBUG_CORE, thr->log, 0, "squ xml serialize"); top = squ_gettop(l); if (!squ_istable(l, top)) { return squL_error(l, "invalid argument, must be a table"); } a = ngx_squ_axis2c_allocator_create(thr); log = ngx_squ_axis2c_log_create(thr); error = axutil_error_create(a); env = axutil_env_create_with_error_log(a, error, log); squ_getfield(l, top, "uri"); uri = (char *) squL_optstring(l, -1, "http://www.w3.org/2003/05/soap-envelope"); squ_getfield(l, top, "prefix"); prefix = (char *) squL_optstring(l, -1, "soap"); ns = axiom_namespace_create(env, uri, prefix); envelope = axiom_soap_envelope_create(env, ns); squ_getfield(l, top, "header"); if (!squ_isnil(l, -1)) { if (!squ_istable(l, -1)) { return squL_error(l, "the value of \"header\" must be a table"); } header = axiom_soap_header_create_with_parent(env, envelope); node = axiom_soap_header_get_base_node(header, env); ngx_squ_xml_serialize_tables(l, env, node); } squ_getfield(l, top, "body"); if (!squ_isnil(l, -1)) { if (!squ_istable(l, -1)) { return squL_error(l, "the value of \"body\" must be a table"); } body = axiom_soap_body_create_with_parent(env, envelope); node = axiom_soap_body_get_base_node(body, env); ngx_squ_xml_serialize_tables(l, env, node); } squ_settop(l, top); writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE, AXIS2_FALSE, AXIS2_XML_PARSER_TYPE_BUFFER); output = axiom_output_create(env, writer); axiom_soap_envelope_serialize(envelope, env, output, AXIS2_FALSE); squ_pushstring(l, axiom_xml_writer_get_xml(writer, env)); return 1; }
axis2_status_t wsclient_soap_out (const axutil_env_t *env, axis2_svc_client_t *svc_client, int soap_out) { axis2_op_client_t *op_client; axis2_msg_ctx_t *msg_ctx; axiom_soap_envelope_t *soap_envelope = NULL; axiom_xml_writer_t *writer; axiom_output_t *om_output = NULL; axis2_char_t *buffer; axis2_status_t status = 0; op_client = axis2_svc_client_get_op_client(svc_client, env); if (op_client) { if (soap_out) msg_ctx = (axis2_msg_ctx_t *) axis2_op_client_get_msg_ctx (op_client, env, AXIS2_WSDL_MESSAGE_LABEL_IN); else msg_ctx = (axis2_msg_ctx_t *) axis2_op_client_get_msg_ctx (op_client, env, AXIS2_WSDL_MESSAGE_LABEL_OUT); if (msg_ctx) soap_envelope = axis2_msg_ctx_get_soap_envelope (msg_ctx, env); else return AXIS2_FAILURE; writer = axiom_xml_writer_create_for_memory (env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); if (writer) om_output = axiom_output_create(env, writer); else return AXIS2_FAILURE; if (soap_envelope && om_output) status = axiom_soap_envelope_serialize(soap_envelope, env, om_output, 0); else return AXIS2_FAILURE; if (status == AXIS2_SUCCESS) { buffer = (axis2_char_t *) axiom_xml_writer_get_xml (writer, env); if (buffer) { printf ("%s", buffer); AXIS2_FREE (env->allocator, buffer); } } else return AXIS2_FAILURE; } return AXIS2_SUCCESS; }