| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <axis2_http_transport_utils.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <axis2_conf.h> |
| #include <axis2_op.h> |
| #include <axis2_qname.h> |
| #include <axis2_http_transport.h> |
| #include <axiom_soap_builder.h> |
| #include <axis2_engine.h> |
| #include <axiom_soap_body.h> |
| #include <axis2_utils.h> |
| #include <axiom_namespace.h> |
| #include <axiom_node.h> |
| #include <axis2_hash.h> |
| #include <axiom_soap_const.h> |
| #include <axis2_http_header.h> |
| #include <axis2_property.h> |
| #include <axis2_utils.h> |
| #include <axiom_mime_parser.h> |
| #include <xml_schema_type.h> |
| #include <xml_schema_group_base.h> |
| #include <xml_schema_obj_collection.h> |
| #include <xml_schema_particle.h> |
| #include <xml_schema_complex_type.h> |
| #include <axis2_disp.h> |
| #include <axis2_msg.h> |
| |
| #define AXIOM_MIME_BOUNDARY_BYTE 45 |
| |
| /***************************** Function headers *******************************/ |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_process_http_post_request( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_stream_t *out_stream, |
| const axis2_char_t *content_type, |
| const int content_length, |
| axis2_char_t *soap_action_header, |
| const axis2_char_t *request_uri); |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_process_http_get_request( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_stream_t *out_stream, |
| const axis2_char_t *content_type, |
| axis2_char_t *soap_action_header, |
| const axis2_char_t *request_uri, |
| axis2_conf_ctx_t *conf_ctx, |
| axis2_hash_t *request_params); |
| |
| AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL |
| axis2_http_transport_utils_select_builder_for_mime( |
| const axis2_env_t *env, |
| axis2_char_t *request_uri, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_char_t *content_type); |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_optimized( |
| const axis2_env_t *env, |
| axiom_element_t *om_element); |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_do_write_mtom( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx); |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_doing_rest( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx); |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_doing_rest_through_post( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx); |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_strdecode( |
| const axis2_env_t *env, |
| axis2_char_t *dest, |
| axis2_char_t *src); |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axis2_http_transport_utils_hexit( |
| axis2_char_t c); |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_services_html( |
| const axis2_env_t *env, |
| axis2_conf_ctx_t *conf_ctx); |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_charset_enc( |
| const axis2_env_t *env, |
| const axis2_char_t *content_type); |
| |
| int AXIS2_CALL |
| axis2_http_transport_utils_on_data_request( |
| char *buffer, |
| int size, |
| void *ctx); |
| |
| AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL |
| axis2_http_transport_utils_create_soap_msg( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_char_t *soap_ns_uri); |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_value_from_content_type( |
| const axis2_env_t *env, |
| const axis2_char_t *content_type, |
| const axis2_char_t *key); |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_dispatch_and_verify( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx); |
| |
| AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL |
| axis2_http_transport_utils_handle_media_type_url_encoded( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_hash_t *param_map, |
| axis2_char_t *method, |
| xml_schema_element_t *schema_element); |
| |
| /***************************** End of function headers ************************/ |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_process_http_post_request( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_stream_t *out_stream, |
| const axis2_char_t *content_type, |
| const int content_length, |
| axis2_char_t *soap_action_header, |
| const axis2_char_t *request_uri) |
| { |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| axiom_soap_builder_t *soap_builder = NULL; |
| axiom_stax_builder_t *om_builder = NULL; |
| axis2_bool_t is_soap11 = AXIS2_FALSE; |
| axiom_xml_reader_t *xml_reader = NULL; |
| axis2_char_t *char_set = NULL; |
| /*axis2_char_t *xml_char_set = NULL;*/ |
| axis2_conf_ctx_t *conf_ctx = NULL; |
| axis2_callback_info_t callback_ctx; |
| axis2_hash_t *headers = NULL; |
| axis2_engine_t *engine = NULL; |
| axiom_soap_body_t *soap_body = NULL; |
| axis2_property_t *property = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| axis2_hash_t *binary_data_map = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); |
| |
| conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env); |
| |
| callback_ctx.in_stream = in_stream; |
| callback_ctx.env = env; |
| callback_ctx.content_length = content_length; |
| callback_ctx.unread_len = content_length; |
| callback_ctx.chunked_stream = NULL; |
| |
| if (soap_action_header && (strlen(soap_action_header) > 0)) |
| { |
| /* remove leading and trailing " s */ |
| if ('"' == soap_action_header[0]) |
| { |
| memmove(soap_action_header, soap_action_header + sizeof(axis2_char_t), |
| strlen(soap_action_header) + sizeof(axis2_char_t)); |
| } |
| if ('"' == soap_action_header[strlen(soap_action_header) -1]) |
| { |
| soap_action_header[strlen(soap_action_header) -1] = '\0'; |
| } |
| } |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_HEADERS, |
| AXIS2_FALSE); |
| if (property) |
| { |
| headers = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| if (headers) |
| { |
| axis2_http_header_t *encoding_header = NULL; |
| encoding_header = (axis2_http_header_t *)axis2_hash_get(headers, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING, |
| AXIS2_HASH_KEY_STRING); |
| if (encoding_header) |
| { |
| axis2_char_t *encoding_value = NULL; |
| encoding_value = AXIS2_HTTP_HEADER_GET_VALUE(encoding_header, env); |
| if (encoding_value && 0 == AXIS2_STRCASECMP(encoding_value, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) |
| { |
| callback_ctx.chunked_stream = axis2_http_chunked_stream_create( |
| env, in_stream); |
| if (NULL == callback_ctx.chunked_stream) |
| { |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error occured in" |
| " creating in chunked stream."); |
| return AXIS2_FAILURE; |
| } |
| AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "HTTP" |
| " stream chunked"); |
| } |
| } |
| } |
| else |
| { |
| /* check content encoding from msg ctx property */ |
| axis2_property_t *property = NULL; |
| axis2_char_t *value = NULL; |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING, |
| AXIS2_FALSE); |
| if (property) |
| value = (axis2_char_t *)AXIS2_PROPERTY_GET_VALUE(property, env); |
| |
| if (value && AXIS2_STRSTR(value, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) |
| { |
| /* this is an UGLY hack to get some of the trnaports working |
| e.g. PHP transport where it strips the chunking info in case of chunking |
| and also gives out a content lenght of 0. |
| We need to fix the transport design to fix sutuations like this. |
| */ |
| callback_ctx.content_length = 1000000; |
| callback_ctx.unread_len = callback_ctx.content_length; |
| } |
| } |
| |
| if (strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)) |
| { |
| /* get mime boundry */ |
| axis2_char_t *mime_boundary = |
| axis2_http_transport_utils_get_value_from_content_type(env, |
| content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); |
| |
| if (mime_boundary) |
| { |
| axiom_mime_parser_t *mime_parser = NULL; |
| axis2_stream_t *stream = NULL; |
| int soap_body_len = 0; |
| axis2_char_t *soap_body_str = NULL; |
| |
| mime_parser = axiom_mime_parser_create(env); |
| if (mime_parser) |
| { |
| binary_data_map = AXIOM_MIME_PARSER_PARSE(mime_parser, env, |
| axis2_http_transport_utils_on_data_request, |
| (void *) & callback_ctx, mime_boundary); |
| |
| soap_body_len = AXIOM_MIME_PARSER_GET_SOAP_BODY_LENGTH( |
| mime_parser, env); |
| soap_body_str = AXIOM_MIME_PARSER_GET_SOAP_BODY_STR( |
| mime_parser, env); |
| } |
| |
| stream = axis2_stream_create_basic(env); |
| if (stream) |
| { |
| AXIS2_STREAM_WRITE(stream, env, soap_body_str, soap_body_len); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "axis2_http_transport_utils_process_http_post_request soap_body_str = %s...%d soap_body_len=%d", |
| soap_body_str, strlen(soap_body_str), soap_body_len); |
| callback_ctx.in_stream = stream; |
| callback_ctx.chunked_stream = NULL; |
| callback_ctx.content_length = soap_body_len; |
| callback_ctx.unread_len = soap_body_len; |
| } |
| } |
| AXIS2_FREE(env->allocator, mime_boundary); |
| } |
| |
| AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx, env, soap_action_header); |
| AXIS2_MSG_CTX_SET_SOAP_ACTION(msg_ctx, env, soap_action_header); |
| AXIS2_MSG_CTX_SET_TO(msg_ctx, env, axis2_endpoint_ref_create(env, |
| request_uri)); |
| |
| AXIS2_MSG_CTX_SET_SERVER_SIDE(msg_ctx, env, AXIS2_TRUE); |
| |
| char_set = axis2_http_transport_utils_get_charset_enc(env, content_type); |
| xml_reader = axiom_xml_reader_create_for_io(env, |
| axis2_http_transport_utils_on_data_request, NULL, |
| (void *) & callback_ctx, char_set); |
| |
| if (NULL == xml_reader) |
| { |
| return AXIS2_FAILURE; |
| } |
| |
| property = axis2_property_create(env); |
| AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); |
| AXIS2_PROPERTY_SET_VALUE(property, env, char_set); |
| AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_CHARACTER_SET_ENCODING, |
| property, AXIS2_TRUE); |
| |
| om_builder = axiom_stax_builder_create(env, xml_reader); |
| if (NULL == om_builder) |
| { |
| AXIOM_XML_READER_FREE(xml_reader, env); |
| xml_reader = NULL; |
| return AXIS2_FAILURE; |
| } |
| |
| if (strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)) |
| { |
| is_soap11 = AXIS2_FALSE; |
| soap_builder = axiom_soap_builder_create(env, om_builder, |
| AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI); |
| if (NULL == soap_builder) |
| { |
| /* We should not be freeing om_builder here as it is done by |
| axiom_soap_builder_create in case of error - Samisa*/ |
| /*AXIOM_STAX_BUILDER_FREE(om_builder, env);*/ |
| om_builder = NULL; |
| xml_reader = NULL; |
| return AXIS2_FAILURE; |
| } |
| |
| soap_envelope = AXIOM_SOAP_BUILDER_GET_SOAP_ENVELOPE(soap_builder, |
| env); |
| if (NULL == soap_envelope) |
| { |
| AXIOM_STAX_BUILDER_FREE(om_builder, env); |
| om_builder = NULL; |
| xml_reader = NULL; |
| AXIOM_SOAP_BUILDER_FREE(soap_builder, env); |
| soap_builder = NULL; |
| return AXIS2_FAILURE; |
| } |
| } |
| else if (strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)) |
| { |
| is_soap11 = AXIS2_TRUE; |
| if (soap_action_header) |
| { |
| soap_builder = axiom_soap_builder_create(env, om_builder, |
| AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI); |
| if (NULL == soap_builder) |
| { |
| /* We should not be freeing om_builder here as it is done by |
| axiom_soap_builder_create in case of error - Samisa*/ |
| /*AXIOM_STAX_BUILDER_FREE(om_builder, env);*/ |
| om_builder = NULL; |
| xml_reader = NULL; |
| return AXIS2_FAILURE; |
| } |
| soap_envelope = AXIOM_SOAP_BUILDER_GET_SOAP_ENVELOPE( |
| soap_builder, env); |
| if (NULL == soap_envelope) |
| { |
| AXIOM_SOAP_BUILDER_FREE(soap_builder, env); |
| om_builder = NULL; |
| xml_reader = NULL; |
| soap_builder = NULL; |
| return AXIS2_FAILURE; |
| } |
| } |
| else |
| { |
| /* REST support */ |
| axis2_param_t *rest_param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, env |
| , AXIS2_ENABLE_REST); |
| if (rest_param && 0 == AXIS2_STRCMP(AXIS2_VALUE_TRUE, |
| AXIS2_PARAM_GET_VALUE(rest_param, env))) |
| { |
| /* TODO we have to check for NULLs */ |
| axiom_soap_body_t *def_body = NULL; |
| axiom_document_t *om_doc = NULL; |
| axiom_node_t *root_node = NULL; |
| soap_envelope = axiom_soap_envelope_create_default_soap_envelope |
| (env, AXIOM_SOAP11); |
| def_body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env); |
| om_doc = AXIOM_STAX_BUILDER_GET_DOCUMENT(om_builder, env); |
| root_node = AXIOM_DOCUMENT_BUILD_ALL(om_doc, env); |
| AXIOM_SOAP_BODY_ADD_CHILD(def_body, env, root_node); |
| AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, env, AXIS2_TRUE); |
| } |
| } |
| |
| } |
| |
| if (binary_data_map) |
| { |
| AXIOM_SOAP_BUILDER_SET_MIME_BODY_PARTS(soap_builder, env, |
| binary_data_map); |
| } |
| |
| /* xml_char_set = AXIOM_DOCUMENT_GET_CHARSET_ENC( |
| * AXIOM_STAX_BUILDER_GET_DOCUMENT(env om_builder), |
| * env); |
| * |
| *if(0 != AXIS2_STRCMP(char_set, xml_char_set)) |
| *{ |
| * AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CHARSET_MISMATCH, |
| * AXIS2_FAILURE); |
| * AXIOM_SOAP_ENVELOPE_FREE(envelope, env); |
| * envelope = NULL; |
| * AXIOM_XML_READER_FREE(xml_reader, env); |
| * xml_reader = NULL; |
| * AXIOM_STAX_BUILDER_FREE(om_builder, env); |
| * om_builder = NULL; |
| * if( soap_builder) |
| * { |
| * AXIOM_SOAP_BUILDER_FREE(soap_builder, env); |
| * soap_builder = NULL; |
| * } |
| * return AXIS2_FAILURE; |
| *} |
| */ |
| |
| AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx, env, soap_envelope); |
| |
| engine = axis2_engine_create(env, conf_ctx); |
| |
| if (!soap_envelope) |
| return AXIS2_FAILURE; |
| |
| soap_body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, |
| env); |
| |
| if (NULL == soap_body) |
| return AXIS2_FAILURE; |
| |
| if (AXIS2_TRUE == AXIOM_SOAP_BODY_HAS_FAULT(soap_body, env)) |
| { |
| status = AXIS2_ENGINE_RECEIVE_FAULT(engine, env, msg_ctx); |
| } |
| else |
| { |
| status = AXIS2_ENGINE_RECEIVE(engine, env, msg_ctx); |
| } |
| if (NULL == AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env) && |
| AXIS2_FALSE == is_soap11) |
| { |
| axiom_soap_envelope_t *def_envelope = |
| axiom_soap_envelope_create_default_soap_envelope(env, |
| AXIOM_SOAP12); |
| AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx, env, def_envelope); |
| } |
| if (engine) |
| { |
| AXIS2_ENGINE_FREE(engine, env); |
| } |
| return status; |
| } |
| |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_process_http_get_request( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_stream_t *out_stream, |
| const axis2_char_t *content_type, |
| axis2_char_t *soap_action_header, |
| const axis2_char_t *request_uri, |
| axis2_conf_ctx_t *conf_ctx, |
| axis2_hash_t *request_params) |
| { |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| axis2_engine_t *engine = NULL; |
| axis2_property_t *property = NULL; |
| axis2_op_t *op = NULL; |
| xml_schema_element_t *schema_element = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FALSE); |
| AXIS2_PARAM_CHECK(env->error, in_stream, AXIS2_FALSE); |
| AXIS2_PARAM_CHECK(env->error, out_stream, AXIS2_FALSE); |
| /*AXIS2_PARAM_CHECK(env->error, content_type, AXIS2_FALSE);*/ |
| AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FALSE); |
| AXIS2_PARAM_CHECK(env->error, request_params, AXIS2_FALSE); |
| |
| |
| AXIS2_MSG_CTX_SET_TO(msg_ctx, env, axis2_endpoint_ref_create(env, |
| request_uri)); |
| |
| property = axis2_property_create(env); |
| AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST); |
| AXIS2_PROPERTY_SET_FREE_FUNC(property, env, axis2_stream_free_void_arg); |
| AXIS2_PROPERTY_SET_VALUE(property, env, out_stream); |
| AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, |
| AXIS2_TRANSPORT_OUT, property, AXIS2_FALSE); |
| |
| AXIS2_MSG_CTX_SET_SERVER_SIDE(msg_ctx, env, AXIS2_TRUE); |
| if (AXIS2_SUCCESS != axis2_http_transport_utils_dispatch_and_verify(env, |
| msg_ctx)) |
| { |
| return AXIS2_FALSE; |
| } |
| op = AXIS2_MSG_CTX_GET_OP(msg_ctx, env); |
| if (op) |
| { |
| axis2_msg_t *msg = NULL; |
| msg = AXIS2_OP_GET_MSG(op, env, AXIS2_MSG_IN); |
| schema_element = AXIS2_MSG_GET_SCHEMA_ELEMENT(msg, env); |
| } |
| soap_envelope = axis2_http_transport_utils_handle_media_type_url_encoded( |
| env, msg_ctx, request_params, AXIS2_HTTP_HEADER_GET, |
| schema_element); |
| if (NULL == soap_envelope) |
| { |
| return AXIS2_FALSE; |
| } |
| else |
| { |
| AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx, env, AXIS2_TRUE); |
| AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx, env, soap_envelope); |
| engine = axis2_engine_create(env, conf_ctx); |
| AXIS2_ENGINE_RECEIVE(engine, env, msg_ctx); |
| return AXIS2_TRUE; |
| } |
| return AXIS2_FALSE; |
| } |
| |
| AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL |
| axis2_http_transport_utils_select_builder_for_mime( |
| const axis2_env_t *env, |
| axis2_char_t *request_uri, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_stream_t *in_stream, |
| axis2_char_t *content_type) |
| { |
| /* |
| TODO implement when MTOM support is added |
| */ |
| return NULL; |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_optimized( |
| const axis2_env_t *env, |
| axiom_element_t *om_element) |
| { |
| /* |
| TODO implement when MTOM support is added |
| */ |
| return AXIS2_FALSE; |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_do_write_mtom( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx) |
| { |
| axis2_property_t *property = NULL; |
| axis2_param_t *param = NULL; |
| axis2_char_t *value = NULL; |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); |
| |
| param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx, env, AXIS2_ENABLE_MTOM); |
| if (param) |
| value = AXIS2_PARAM_GET_VALUE(param, env); |
| |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, |
| AXIS2_ENABLE_MTOM, AXIS2_FALSE); |
| if (property) |
| value = (axis2_char_t *)AXIS2_PROPERTY_GET_VALUE(property, env); |
| |
| if (value) |
| { |
| return (AXIS2_STRCMP(value, AXIS2_VALUE_TRUE) == 0); |
| } |
| return AXIS2_FALSE; |
| } |
| |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_doing_rest( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx) |
| { |
| /* |
| TODO implement when REST support is added |
| */ |
| return AXIS2_FALSE; |
| } |
| |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axis2_http_transport_utils_is_doing_rest_through_post( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx) |
| { |
| /* |
| TODO implement when REST support is added |
| */ |
| return AXIS2_FALSE; |
| } |
| |
| AXIS2_EXTERN axis2_hash_t *AXIS2_CALL |
| axis2_http_transport_utils_get_request_params( |
| const axis2_env_t *env, |
| axis2_char_t *request_uri) |
| { |
| |
| |
| axis2_char_t *query_str = NULL; |
| axis2_char_t *tmp = strchr(request_uri, '?'); |
| axis2_char_t *tmp2 = NULL; |
| axis2_char_t *tmp_name = NULL; |
| axis2_char_t *tmp_value = NULL; |
| axis2_hash_t *ret = NULL; |
| |
| AXIS2_PARAM_CHECK(env->error, request_uri, AXIS2_FAILURE); |
| |
| if (NULL == tmp || '\0' == *(tmp + 1)) |
| { |
| return NULL; |
| } |
| query_str = AXIS2_STRDUP(tmp + 1, env); |
| |
| for (tmp2 = tmp = query_str; *tmp != '\0'; ++tmp) |
| { |
| if ('=' == *tmp) |
| { |
| *tmp = '\0'; |
| tmp_name = AXIS2_STRDUP(tmp2, env); |
| axis2_http_transport_utils_strdecode(env, tmp_name, tmp_name); |
| tmp2 = tmp + 1; |
| } |
| if ('&' == *tmp) |
| { |
| *tmp = '\0'; |
| tmp_value = AXIS2_STRDUP(tmp2, env); |
| axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); |
| tmp2 = tmp + 1; |
| } |
| if (tmp_name && NULL != tmp_value) |
| { |
| if (NULL == ret) |
| { |
| ret = axis2_hash_make(env); |
| } |
| axis2_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); |
| tmp_name = NULL; |
| tmp_value = NULL; |
| } |
| } |
| if (tmp_name && '\0' != *tmp2) |
| { |
| if (NULL == ret) |
| { |
| ret = axis2_hash_make(env); |
| } |
| tmp_value = AXIS2_STRDUP(tmp2, env); |
| axis2_http_transport_utils_strdecode(env, tmp_value, tmp_value); |
| axis2_hash_set(ret, tmp_name, AXIS2_HASH_KEY_STRING, tmp_value); |
| } |
| |
| return ret; |
| } |
| |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_strdecode( |
| const axis2_env_t *env, |
| axis2_char_t *dest, |
| axis2_char_t *src) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, dest, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, src, AXIS2_FAILURE); |
| |
| for (; *src != '\0'; ++dest, ++src) |
| { |
| if (src[0] == '%' && isxdigit(src[1]) && isxdigit(src[2])) |
| { |
| *dest = axis2_http_transport_utils_hexit(src[1]) * 16 + |
| axis2_http_transport_utils_hexit(src[2]); |
| src += 2; |
| } |
| else |
| { |
| *dest = *src; |
| } |
| } |
| *dest = '\0'; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axis2_http_transport_utils_hexit( |
| axis2_char_t c) |
| { |
| if (c >= '0' && c <= '9') |
| { |
| return c - '0'; |
| } |
| if (c >= 'a' && c <= 'f') |
| { |
| return c - 'a' + 10; |
| } |
| if (c >= 'A' && c <= 'F') |
| { |
| return c - 'A' + 10; |
| } |
| return 0; /* shouldn't happen, we're guarded by isxdigit() */ |
| } |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_services_html( |
| const axis2_env_t *env, |
| axis2_conf_ctx_t *conf_ctx) |
| { |
| axis2_hash_t *services_map = NULL; |
| axis2_hash_t *errorneous_svc_map = NULL; |
| axis2_char_t *ret = NULL; |
| axis2_char_t *tmp2 = (axis2_char_t *)"<h2>Deployed Services</h2>"; |
| axis2_hash_index_t *hi = NULL; |
| axis2_bool_t svcs_exists = AXIS2_FALSE; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL); |
| |
| services_map = AXIS2_CONF_GET_ALL_SVCS(AXIS2_CONF_CTX_GET_CONF(conf_ctx, env), |
| env); |
| errorneous_svc_map = AXIS2_CONF_GET_ALL_FAULTY_SVCS(AXIS2_CONF_CTX_GET_CONF( |
| conf_ctx, env), env); |
| if (services_map && 0 != axis2_hash_count(services_map)) |
| { |
| void *service = NULL; |
| axis2_char_t *sname = NULL; |
| axis2_hash_t *ops = NULL; |
| svcs_exists = AXIS2_TRUE; |
| |
| for (hi = axis2_hash_first(services_map, env); |
| hi; hi = axis2_hash_next(env, hi)) |
| { |
| axis2_hash_this(hi, NULL, NULL, &service); |
| sname = AXIS2_QNAME_GET_LOCALPART(AXIS2_SVC_GET_QNAME( |
| ((axis2_svc_t *)service), env), env); |
| ret = AXIS2_STRACAT(tmp2, "<h3><u>", env); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, sname, env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, "</u></h3>", env); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT (tmp2, "<p>", env); |
| tmp2 = ret; |
| /** |
| *setting services description */ |
| ret = AXIS2_STRACAT (tmp2, AXIS2_SVC_GET_SVC_DESC ((axis2_svc_t *)service, env), env); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT (tmp2, "</p>", env); |
| tmp2 = ret; |
| ops = AXIS2_SVC_GET_ALL_OPS(((axis2_svc_t *)service), env); |
| if (ops && 0 != axis2_hash_count(ops)) |
| { |
| axis2_hash_index_t *hi2 = NULL; |
| void *op = NULL; |
| axis2_char_t *oname = NULL; |
| |
| ret = AXIS2_STRACAT(tmp2, "<i>Available Operations</i> <ul>", |
| env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| for (hi2 = axis2_hash_first(ops, env); hi2; |
| hi2 = axis2_hash_next(env, hi2)) |
| { |
| axis2_hash_this(hi2, NULL, NULL, &op); |
| oname = AXIS2_QNAME_GET_LOCALPART(AXIS2_OP_GET_QNAME( |
| ((axis2_op_t *)op), env), env); |
| ret = AXIS2_STRACAT(tmp2, "<li>", env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| |
| ret = AXIS2_STRACAT(tmp2, oname, env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, "</li>", env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| } |
| ret = AXIS2_STRACAT(tmp2, "</ul>", env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| } |
| else |
| { |
| ret = AXIS2_STRACAT(tmp2, "No operations Available", env); |
| /*AXIS2_FREE(env->allocator, tmp);*/ |
| tmp2 = ret; |
| } |
| } |
| } |
| if (errorneous_svc_map && 0 != axis2_hash_count(errorneous_svc_map)) |
| { |
| void *fsname = NULL; |
| svcs_exists = AXIS2_TRUE; |
| ret = AXIS2_STRACAT(tmp2, "<hr><h2><font color=\"red\">Faulty \ |
| Services</font></h2>" |
| , env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| |
| for (hi = axis2_hash_first(errorneous_svc_map, env); hi; |
| axis2_hash_next(env, hi)) |
| { |
| axis2_hash_this(hi, (const void **)&fsname, NULL, NULL); |
| ret = AXIS2_STRACAT(tmp2, "<h3><font color=\"red\">", env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, (axis2_char_t *)fsname, env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, "</font></h3>", env); |
| AXIS2_FREE(env->allocator, tmp2); |
| tmp2 = ret; |
| } |
| } |
| if (AXIS2_FALSE == svcs_exists) |
| { |
| ret = AXIS2_STRDUP("<h2>There are no services deployed</h2>", env); |
| } |
| ret = AXIS2_STRACAT("<html><head><title>Axis2C :: Services</title></head>" |
| "<body><font face=\"courier\">" |
| , tmp2, env); |
| /*AXIS2_FREE(env->allocator, tmp2);*/ |
| tmp2 = ret; |
| ret = AXIS2_STRACAT(tmp2, "</font></body></html>\r\n", env); |
| /*AXIS2_FREE(env->allocator, tmp);*/ |
| |
| return ret; |
| } |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_charset_enc( |
| const axis2_env_t *env, |
| const axis2_char_t *content_type) |
| { |
| axis2_char_t *tmp = NULL; |
| axis2_char_t *tmp_content_type = NULL; |
| axis2_char_t *tmp2 = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, content_type, NULL); |
| |
| tmp_content_type = AXIS2_STRDUP(content_type, env); |
| if (NULL == tmp_content_type) |
| { |
| return AXIS2_STRDUP(AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING, env); |
| } |
| tmp = strstr(tmp_content_type, AXIS2_HTTP_CHAR_SET_ENCODING); |
| if (NULL == tmp) |
| { |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| return AXIS2_STRDUP(AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING, env); |
| } |
| tmp = strchr(tmp, '='); |
| tmp2 = strchr(tmp, ';'); |
| if (tmp2) |
| { |
| if ('\'' == *(tmp2 - sizeof(axis2_char_t)) || |
| '\"' == *(tmp2 - sizeof(axis2_char_t))) |
| { |
| tmp2 -= sizeof(axis2_char_t); |
| } |
| *tmp2 = '\0'; |
| } |
| if (NULL == tmp) |
| { |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| return AXIS2_STRDUP(AXIS2_HTTP_HEADER_DEFAULT_CHAR_ENCODING, env); |
| } |
| /* Following formats are acceptable |
| * charset="UTF-8" |
| * charser='UTF-8' |
| * charset=UTF-8 |
| * But for our requirements charset we get should be UTF-8 |
| */ |
| if ('\'' == *(tmp + sizeof(axis2_char_t)) || '\"' == *(tmp + |
| sizeof(axis2_char_t))) |
| { |
| tmp += 2 * sizeof(axis2_char_t); |
| } |
| else |
| { |
| tmp += sizeof(axis2_char_t); |
| } |
| tmp2 = AXIS2_STRDUP(tmp, env); |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| return tmp2; |
| } |
| |
| int AXIS2_CALL |
| axis2_http_transport_utils_on_data_request( |
| char *buffer, |
| int size, |
| void *ctx) |
| { |
| const axis2_env_t *env = NULL; |
| int len = -1; |
| axis2_callback_info_t *cb_ctx = (axis2_callback_info_t *)ctx; |
| |
| if (NULL == buffer || NULL == ctx) |
| { |
| return 0; |
| } |
| env = ((axis2_callback_info_t *)ctx)->env; |
| if (cb_ctx->unread_len <= 0 && -1 != cb_ctx->content_length) |
| { |
| return 0; |
| } |
| if (cb_ctx->chunked_stream) |
| { |
| len = AXIS2_HTTP_CHUNKED_STREAM_READ(cb_ctx->chunked_stream, env, |
| buffer, size); |
| buffer[len] = '\0'; |
| return len; |
| } |
| else |
| { |
| axis2_stream_t *in_stream = NULL; |
| int read_len = size; |
| in_stream = (axis2_stream_t *)((axis2_callback_info_t *)ctx)->in_stream; |
| /* For managed streams such as Apache2 streams we do not need to |
| * calculate lenghts |
| */ |
| /*if(AXIS2_STREAM_MANAGED == AXIS2_STREAM_GET_TYPE(in_stream, env)) |
| { |
| read_len = size; |
| } |
| else |
| { |
| if(size > ((axis2_callback_info_t *)ctx)->unread_len && |
| -1 != ((axis2_callback_info_t *)ctx)->unread_len) |
| { |
| read_len = ((axis2_callback_info_t *)ctx)->unread_len; |
| } |
| else |
| { |
| read_len = size; |
| } |
| }*/ |
| len = AXIS2_STREAM_READ(in_stream, env, buffer, read_len); |
| if (len > 0) |
| { |
| buffer[len] = '\0'; |
| /*if(AXIS2_STREAM_MANAGED != AXIS2_STREAM_GET_TYPE(in_stream, env)) |
| {*/ |
| ((axis2_callback_info_t *)ctx)->unread_len -= len; |
| /*}*/ |
| } |
| return len; |
| } |
| return 0; |
| } |
| |
| AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL |
| axis2_http_transport_utils_create_soap_msg( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| const axis2_char_t *soap_ns_uri) |
| { |
| axis2_op_ctx_t *op_ctx = NULL; |
| const axis2_char_t *char_set_enc = NULL; |
| axis2_char_t *content_type = NULL; |
| axis2_stream_t *in_stream = NULL; |
| axis2_callback_info_t *callback_ctx = NULL; |
| axis2_char_t *trans_enc = NULL; |
| int *content_length = NULL; |
| axis2_property_t *property = NULL; |
| axis2_hash_t *binary_data_map = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, soap_ns_uri, NULL); |
| |
| |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, |
| AXIS2_TRANSPORT_IN, AXIS2_FALSE); |
| if (property) |
| { |
| in_stream = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| /* TODO free this when xml pulling is over */ |
| callback_ctx = AXIS2_MALLOC(env->allocator, sizeof(axis2_callback_info_t)); |
| if (NULL == callback_ctx) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| callback_ctx->in_stream = in_stream; |
| callback_ctx->env = env; |
| callback_ctx->content_length = -1; |
| callback_ctx->unread_len = -1; |
| callback_ctx->chunked_stream = NULL; |
| |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, |
| AXIS2_HTTP_HEADER_CONTENT_LENGTH, AXIS2_FALSE); |
| if (property) |
| { |
| content_length = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| if (content_length) |
| { |
| callback_ctx->content_length = *content_length; |
| callback_ctx->unread_len = *content_length; |
| } |
| if (NULL == in_stream) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_IN_STREAM_IN_MSG_CTX, |
| AXIS2_FAILURE); |
| return NULL; |
| } |
| property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING, AXIS2_FALSE); |
| if (property) |
| { |
| trans_enc = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| if (trans_enc && 0 == AXIS2_STRCMP(trans_enc, |
| AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) |
| { |
| callback_ctx->chunked_stream = axis2_http_chunked_stream_create(env, |
| in_stream); |
| if (NULL == callback_ctx->chunked_stream) |
| { |
| return NULL; |
| } |
| } |
| |
| |
| op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env); |
| if (op_ctx) |
| { |
| axis2_ctx_t *ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env); |
| if (ctx) |
| { |
| property = AXIS2_CTX_GET_PROPERTY(ctx, env, |
| AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE); |
| if (property) |
| { |
| char_set_enc = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| property = AXIS2_CTX_GET_PROPERTY(ctx, env, |
| MTOM_RECIVED_CONTENT_TYPE, AXIS2_FALSE); |
| if (property) |
| { |
| content_type = AXIS2_PROPERTY_GET_VALUE(property, env); |
| property = NULL; |
| } |
| |
| } |
| } |
| if (NULL == char_set_enc) |
| { |
| char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; |
| } |
| if (content_type) |
| { |
| axis2_char_t *mime_boundary = NULL; |
| AXIS2_MSG_CTX_SET_DOING_MTOM(msg_ctx, env, AXIS2_TRUE); |
| /* get mime boundry */ |
| mime_boundary = axis2_http_transport_utils_get_value_from_content_type(env, content_type, AXIS2_HTTP_HEADER_CONTENT_TYPE_MIME_BOUNDARY); |
| |
| if (mime_boundary) |
| { |
| axiom_mime_parser_t *mime_parser = NULL; |
| axis2_stream_t *stream = NULL; |
| int soap_body_len = 0; |
| axis2_char_t *soap_body_str = NULL; |
| |
| mime_parser = axiom_mime_parser_create(env); |
| if (mime_parser) |
| { |
| binary_data_map = AXIOM_MIME_PARSER_PARSE(mime_parser, env, |
| axis2_http_transport_utils_on_data_request, |
| (void *)callback_ctx, mime_boundary); |
| |
| soap_body_len = AXIOM_MIME_PARSER_GET_SOAP_BODY_LENGTH( |
| mime_parser, env); |
| soap_body_str = AXIOM_MIME_PARSER_GET_SOAP_BODY_STR( |
| mime_parser, env); |
| } |
| |
| stream = axis2_stream_create_basic(env); |
| if (stream) |
| { |
| AXIS2_STREAM_WRITE(stream, env, soap_body_str, soap_body_len); |
| callback_ctx->in_stream = stream; |
| callback_ctx->chunked_stream = NULL; |
| callback_ctx->content_length = soap_body_len; |
| callback_ctx->unread_len = soap_body_len; |
| } |
| } |
| /** |
| * TODO MTOM stuff - create builder and get envelope |
| */ |
| } |
| |
| if (AXIS2_TRUE != AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env)) |
| { |
| axiom_xml_reader_t *xml_reader = NULL; |
| axiom_stax_builder_t *om_builder = NULL; |
| axiom_soap_builder_t *soap_builder = NULL; |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| |
| xml_reader = axiom_xml_reader_create_for_io(env, |
| axis2_http_transport_utils_on_data_request, NULL, |
| (void *)callback_ctx, char_set_enc); |
| if (NULL == xml_reader) |
| { |
| return NULL; |
| } |
| om_builder = axiom_stax_builder_create(env, xml_reader); |
| if (NULL == om_builder) |
| { |
| AXIOM_XML_READER_FREE(xml_reader, env); |
| xml_reader = NULL; |
| return NULL; |
| } |
| soap_builder = axiom_soap_builder_create(env, om_builder, |
| soap_ns_uri); |
| if (NULL == soap_builder) |
| { |
| /* We should not be freeing om_builder here as it is done by |
| axiom_soap_builder_create in case of error - Samisa*/ |
| /*AXIOM_STAX_BUILDER_FREE(om_builder, env);*/ |
| om_builder = NULL; |
| xml_reader = NULL; |
| return NULL; |
| } |
| |
| soap_envelope = AXIOM_SOAP_BUILDER_GET_SOAP_ENVELOPE(soap_builder, env); |
| |
| if (binary_data_map) |
| { |
| AXIOM_SOAP_BUILDER_SET_MIME_BODY_PARTS(soap_builder, env, |
| binary_data_map); |
| } |
| |
| if (soap_envelope && content_type) |
| { |
| /* hack to get around MTOM problem */ |
| axiom_soap_body_t *soap_body = |
| AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env); |
| |
| if (soap_body) |
| { |
| AXIOM_SOAP_BODY_HAS_FAULT(soap_body, env); |
| } |
| } |
| |
| return soap_envelope; |
| } |
| else |
| { |
| axiom_xml_reader_t *xml_reader = NULL; |
| axiom_stax_builder_t *om_builder = NULL; |
| axiom_soap_envelope_t *soap_envelope = NULL; |
| axiom_soap_body_t *def_body = NULL; |
| axiom_document_t *om_doc = NULL; |
| axiom_node_t *root_node = NULL; |
| |
| xml_reader = axiom_xml_reader_create_for_io(env, |
| axis2_http_transport_utils_on_data_request, NULL, |
| (void *)callback_ctx, char_set_enc); |
| if (NULL == xml_reader) |
| { |
| return NULL; |
| } |
| om_builder = axiom_stax_builder_create(env, xml_reader); |
| if (NULL == om_builder) |
| { |
| AXIOM_XML_READER_FREE(xml_reader, env); |
| xml_reader = NULL; |
| return NULL; |
| } |
| soap_envelope = axiom_soap_envelope_create_default_soap_envelope |
| (env, AXIOM_SOAP11); |
| def_body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_envelope, env); |
| om_doc = AXIOM_STAX_BUILDER_GET_DOCUMENT(om_builder, env); |
| root_node = AXIOM_DOCUMENT_BUILD_ALL(om_doc, env); |
| AXIOM_SOAP_BODY_ADD_CHILD(def_body, env, root_node); |
| |
| return soap_envelope; |
| } |
| return NULL; |
| } |
| |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| axis2_http_transport_utils_get_value_from_content_type( |
| const axis2_env_t *env, |
| const axis2_char_t *content_type, |
| const axis2_char_t *key) |
| { |
| axis2_char_t *tmp = NULL; |
| axis2_char_t *tmp_content_type = NULL; |
| axis2_char_t *tmp2 = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, content_type, NULL); |
| AXIS2_PARAM_CHECK(env->error, key, NULL); |
| |
| tmp_content_type = AXIS2_STRDUP(content_type, env); |
| if (NULL == tmp_content_type) |
| { |
| return NULL; |
| } |
| tmp = strstr(tmp_content_type, key); |
| if (NULL == tmp) |
| { |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| return NULL; |
| } |
| |
| tmp = strchr(tmp, '='); |
| tmp2 = strchr(tmp, ';'); |
| |
| if (tmp2) |
| { |
| *tmp2 = '\0'; |
| } |
| if (NULL == tmp) |
| { |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| return NULL; |
| } |
| tmp2 = AXIS2_STRDUP(tmp + 1, env); |
| |
| AXIS2_FREE(env->allocator, tmp_content_type); |
| if (*tmp2 == '"') |
| { |
| tmp = tmp2; |
| tmp2 = AXIS2_STRDUP(tmp + 1, env); |
| tmp2[strlen(tmp2) - 1] = '\0'; |
| } |
| return tmp2; |
| } |
| |
| AXIS2_EXTERN axiom_soap_envelope_t *AXIS2_CALL |
| axis2_http_transport_utils_handle_media_type_url_encoded( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx, |
| axis2_hash_t *param_map, |
| axis2_char_t *method, |
| xml_schema_element_t *schema_element) |
| { |
| axiom_soap_envelope_t *soap_env = NULL; |
| axiom_soap_body_t *soap_body = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL); |
| AXIS2_PARAM_CHECK(env->error, method, NULL); |
| |
| |
| soap_env = axiom_soap_envelope_create_default_soap_envelope(env, |
| AXIOM_SOAP11); |
| soap_body = AXIOM_SOAP_ENVELOPE_GET_BODY(soap_env, env); |
| if (NULL == soap_body) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, |
| AXIS2_FAILURE); |
| return NULL; |
| } |
| if (NULL == schema_element) |
| { |
| axiom_element_t *body_child = NULL; |
| axiom_node_t *body_child_node = NULL; |
| |
| body_child = axiom_element_create_with_qname(env, NULL, |
| AXIS2_OP_GET_QNAME(AXIS2_MSG_CTX_GET_OP(msg_ctx, env), |
| env), &body_child_node); |
| AXIOM_SOAP_BODY_ADD_CHILD(soap_body, env, body_child_node); |
| if (param_map) |
| { |
| axis2_hash_index_t *hi = NULL; |
| for (hi = axis2_hash_first(param_map, env); hi ; |
| hi = axis2_hash_next(env, hi)) |
| { |
| void *name = NULL; |
| void *value = NULL; |
| axiom_node_t *node = NULL; |
| axiom_element_t *element = NULL; |
| |
| axis2_hash_this(hi, (const void **)&name, NULL, (void **)&value); |
| element = axiom_element_create(env, NULL, (axis2_char_t *)name, |
| NULL, &node); |
| AXIOM_ELEMENT_SET_TEXT(element, env, (axis2_char_t *)value, node); |
| AXIOM_NODE_ADD_CHILD(body_child_node, env, node); |
| } |
| } |
| } |
| else |
| { |
| axis2_char_t *target_ns = NULL; |
| axis2_qname_t *bfc_qname = NULL; |
| axiom_element_t *body_child = NULL; |
| axiom_node_t *body_child_node = NULL; |
| |
| target_ns = AXIS2_QNAME_GET_URI(XML_SCHEMA_ELEMENT_GET_QNAME( |
| schema_element, env), env); |
| bfc_qname = axis2_qname_create(env, XML_SCHEMA_ELEMENT_GET_NAME( |
| schema_element, env), target_ns, NULL); |
| |
| body_child = axiom_element_create_with_qname(env, NULL, bfc_qname, |
| &body_child_node); |
| AXIOM_SOAP_BODY_ADD_CHILD(soap_body, env, body_child_node); |
| if (0 == AXIS2_STRCMP(method, AXIS2_HTTP_HEADER_GET) || |
| 0 == AXIS2_STRCMP(method, AXIS2_HTTP_HEADER_POST)) |
| { |
| xml_schema_type_t *schema_type = NULL; |
| schema_type = XML_SCHEMA_ELEMENT_GET_SCHEMA_TYPE(schema_element, |
| env); |
| if (XML_SCHEMA_COMPLEX_TYPE == XML_SCHEMA_TYPE_GET_TYPE(schema_type, |
| env)) |
| { |
| xml_schema_particle_t *schema_particle = NULL; |
| schema_particle = XML_SCHEMA_COMPLEX_TYPE_GET_PARTICLE( |
| schema_type, env); |
| if (XML_SCHEMA_SEQUENCE == |
| XML_SCHEMA_PARTICLE_GET_TYPE(schema_particle, env)) |
| { |
| xml_schema_group_base_t *sequence = NULL; |
| xml_schema_obj_collection_t *seq_items = NULL; |
| int count = 0; |
| int i = 0; |
| |
| sequence = (xml_schema_group_base_t *)schema_particle; |
| seq_items = XML_SCHEMA_GROUP_BASE_GET_ITEMS(sequence, env); |
| count = XML_SCHEMA_OBJ_COLLECTION_GET_COUNT(seq_items, env); |
| for (i = 0; i < count; i++) |
| { |
| xml_schema_element_t *inner_element = NULL; |
| axis2_char_t *element_name = NULL; |
| axis2_char_t *param_val = NULL; |
| axiom_element_t *om_element = NULL; |
| axiom_node_t *om_node = NULL; |
| |
| inner_element = (xml_schema_element_t *) |
| XML_SCHEMA_OBJ_COLLECTION_GET_ITEM(seq_items, env, |
| i); |
| element_name = XML_SCHEMA_ELEMENT_GET_NAME(inner_element, |
| env); |
| param_val = axis2_hash_get(param_map, element_name, |
| AXIS2_HASH_KEY_STRING); |
| if (NULL == param_val) |
| { |
| AXIS2_ERROR_SET(env->error, |
| AXIS2_ERROR_REQD_PARAM_MISSING, AXIS2_FAILURE); |
| return NULL; |
| } |
| om_element = axiom_element_create(env, body_child_node, |
| element_name, NULL, &om_node); |
| AXIOM_ELEMENT_SET_TEXT(om_element, env, param_val, |
| om_node); |
| } |
| } |
| } |
| else |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_UNSUPPORTED_SCHEMA_TYPE, |
| AXIS2_FAILURE); |
| return NULL; |
| } |
| } |
| } |
| return soap_env; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axis2_http_transport_utils_dispatch_and_verify( |
| const axis2_env_t *env, |
| axis2_msg_ctx_t *msg_ctx) |
| { |
| axis2_disp_t *req_uri_disp = NULL; |
| axis2_handler_t *handler = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); |
| |
| req_uri_disp = axis2_req_uri_disp_create(env); |
| handler = AXIS2_DISP_GET_BASE(req_uri_disp, env); |
| AXIS2_HANDLER_INVOKE(handler, env, msg_ctx); |
| |
| if (NULL == AXIS2_MSG_CTX_GET_SVC(msg_ctx, env) || NULL == |
| AXIS2_MSG_CTX_GET_OP(msg_ctx, env)) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_OR_OP_NOT_FOUND, |
| AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| return AXIS2_SUCCESS; |
| } |
