/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef AXIS2_LIBCURL_ENABLED #include "libcurl/axis2_libcurl.h" #endif /** * HTTP Transport Sender struct impl * Axis2 HTTP Transport Sender impl */ typedef struct axis2_http_transport_sender_impl { axis2_transport_sender_t transport_sender; axis2_char_t *http_version; axis2_bool_t chunked; int connection_timeout; int so_timeout; axis2_bool_t keep_alive; #ifdef AXIS2_LIBCURL_ENABLED axis2_libcurl_t *libcurl; #endif } axis2_http_transport_sender_impl_t; #define AXIS2_WS_RM_ANONYMOUS_URL "http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id=" #define AXIS2_INTF_TO_IMPL(transport_sender) \ ((axis2_http_transport_sender_impl_t *)\ (transport_sender)) /***************************** Function headers *******************************/ axis2_status_t AXIS2_CALL axis2_http_transport_sender_invoke( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx); axis2_status_t AXIS2_CALL axis2_http_transport_sender_clean_up( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx); axis2_status_t AXIS2_CALL axis2_http_transport_sender_init( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_conf_ctx_t * conf_ctx, axis2_transport_out_desc_t * out_desc); axis2_status_t AXIS2_CALL axis2_http_transport_sender_write_message( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, axis2_endpoint_ref_t * epr, axiom_soap_envelope_t * out, axiom_output_t * om_output); void AXIS2_CALL axis2_http_transport_sender_free( axis2_transport_sender_t * transport_sender, const axutil_env_t * env); static const axis2_transport_sender_ops_t http_transport_sender_ops_var = { axis2_http_transport_sender_init, axis2_http_transport_sender_invoke, axis2_http_transport_sender_clean_up, axis2_http_transport_sender_free }; axis2_transport_sender_t *AXIS2_CALL axis2_http_transport_sender_create( const axutil_env_t * env) { axis2_http_transport_sender_impl_t *transport_sender_impl = NULL; transport_sender_impl = (axis2_http_transport_sender_impl_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_transport_sender_impl_t)); if(!transport_sender_impl) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } memset((void *)transport_sender_impl, 0, sizeof(axis2_http_transport_sender_impl_t)); transport_sender_impl->http_version = axutil_strdup(env, AXIS2_HTTP_HEADER_PROTOCOL_11); transport_sender_impl->chunked = AXIS2_TRUE; transport_sender_impl->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT; transport_sender_impl->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT; transport_sender_impl->keep_alive = AXIS2_TRUE; transport_sender_impl->transport_sender.ops = &http_transport_sender_ops_var; #ifdef AXIS2_LIBCURL_ENABLED transport_sender_impl->libcurl = axis2_libcurl_create(env); if (!transport_sender_impl->libcurl) { AXIS2_FREE(env->allocator, transport_sender_impl); AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } #endif return &(transport_sender_impl->transport_sender); } void AXIS2_CALL axis2_http_transport_sender_free( axis2_transport_sender_t * transport_sender, const axutil_env_t * env) { axis2_http_transport_sender_impl_t *transport_sender_impl = NULL; if(!transport_sender) { return; } transport_sender_impl = AXIS2_INTF_TO_IMPL(transport_sender); if(transport_sender_impl->http_version) { AXIS2_FREE(env->allocator, transport_sender_impl->http_version); transport_sender_impl->http_version = NULL; } #ifdef AXIS2_LIBCURL_ENABLED if (transport_sender_impl->libcurl) { axis2_libcurl_free(transport_sender_impl->libcurl, env); } #endif AXIS2_FREE(env->allocator, transport_sender_impl); return; } axis2_status_t AXIS2_CALL axis2_http_transport_sender_invoke( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { const axis2_char_t *char_set_enc = NULL; axutil_string_t *char_set_enc_str = NULL; axis2_endpoint_ref_t *epr = NULL; axis2_char_t *transport_url = NULL; axiom_xml_writer_t *xml_writer = NULL; axiom_output_t *om_output = NULL; axis2_char_t *buffer = NULL; axiom_soap_envelope_t *soap_data_out = NULL; axis2_bool_t do_mtom; axutil_property_t *property = NULL; axiom_node_t *data_out = NULL; int buffer_size = 0; axis2_status_t status = AXIS2_SUCCESS; axis2_conf_ctx_t *conf_ctx = NULL; axis2_conf_t *conf = NULL; axis2_transport_out_desc_t *trans_desc = NULL; axutil_param_t *write_xml_declaration_param = NULL; axutil_hash_t *transport_attrs = NULL; axis2_bool_t write_xml_declaration = AXIS2_FALSE; axis2_bool_t fault = AXIS2_FALSE; AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_http_transport_sender_invoke"); AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env); if(char_set_enc_str) { char_set_enc = axutil_string_get_buffer(char_set_enc_str, env); } if(!char_set_enc) { axis2_op_ctx_t *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); if(property) { char_set_enc = axutil_property_get_value(property, env); property = NULL; } } } } /** * If we still can't find the char set enc we will * use default */ if(!char_set_enc) { char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING; } do_mtom = axis2_http_transport_utils_do_write_mtom(env, msg_ctx); transport_url = axis2_msg_ctx_get_transport_url(msg_ctx, env); if(transport_url) { AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "transport_url:%s", transport_url); epr = axis2_endpoint_ref_create(env, transport_url); } else { /* when transport url is not available in msg_ctx */ axis2_endpoint_ref_t *ctx_epr = axis2_msg_ctx_get_to(msg_ctx, env); if(ctx_epr) AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "ctx_epr:%s", axis2_endpoint_ref_get_address( ctx_epr, env)); if(ctx_epr && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL_SUBMISSION, axis2_endpoint_ref_get_address(ctx_epr, env)) && axutil_strcmp(AXIS2_WSA_ANONYMOUS_URL, axis2_endpoint_ref_get_address(ctx_epr, env)) && !(axutil_strstr( axis2_endpoint_ref_get_address(ctx_epr, env), AXIS2_WS_RM_ANONYMOUS_URL))) { epr = ctx_epr; } } soap_data_out = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); if(!soap_data_out) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_SOAP_ENVELOPE_IN_MSG_CTX, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", AXIS2_ERROR_GET_MESSAGE(env->error)); return AXIS2_SUCCESS; } xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER); if(!xml_writer) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create xml_writer for \ AXIS2_XML_PARSER_TYPE_BUFFER"); return AXIS2_FAILURE; } om_output = axiom_output_create(env, xml_writer); if(!om_output) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create om_output for xml writer of \ AXIS2_XML_PARSER_TYPE_BUFFER"); axiom_xml_writer_free(xml_writer, env); xml_writer = NULL; return AXIS2_FAILURE; } /* setting SOAP version for OM_OUTPUT. */ axiom_output_set_soap11(om_output, env, axis2_msg_ctx_get_is_soap_11(msg_ctx, env)); /* This is the case where normal client send the requet using a http_client*/ if(epr) { if(axutil_strcmp(AXIS2_WSA_NONE_URL_SUBMISSION, axis2_endpoint_ref_get_address(epr, env)) == 0 || axutil_strcmp(AXIS2_WSA_NONE_URL, axis2_endpoint_ref_get_address(epr, env)) == 0) { epr = NULL; } else { status = axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx, epr, soap_data_out, om_output); } } /* If no endpoint reference could be derived from the the message context. It could well be the * single channel two way scenario in the application server side send. */ if(!epr) { axutil_stream_t *out_stream = axis2_msg_ctx_get_transport_out_stream(msg_ctx, env); if(AXIS2_TRUE == axis2_msg_ctx_get_server_side(msg_ctx, env)) { axis2_http_out_transport_info_t *out_info = NULL; axis2_bool_t is_soap11 = AXIS2_FALSE; axis2_op_ctx_t *op_ctx = NULL; /*axis2_char_t *header_value = NULL;*/ out_info = (axis2_http_out_transport_info_t *)axis2_msg_ctx_get_out_transport_info( msg_ctx, env); if(!out_info) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE); axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; return AXIS2_FAILURE; } /*header_value = axis2_http_transport_utils_get_session(env, msg_ctx); if(header_value) { AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_COOKIE_HEADER(out_info, env, header_value); }*/ is_soap11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_info, env, char_set_enc); if(AXIS2_TRUE == is_soap11) { /* SOAP1.1 */ AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML); } else { /* SOAP1.2 */ AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP); } conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); if(conf_ctx) { conf = axis2_conf_ctx_get_conf(conf_ctx, env); } if(conf) { /* get access to HTTP transport for sending */ trans_desc = axis2_conf_get_transport_out(conf, env, AXIS2_TRANSPORT_ENUM_HTTP); } if(trans_desc) { /* accessing parameter in axis2.xml which set to have * an ability to send xml versoin processing * instruction */ write_xml_declaration_param = axutil_param_container_get_param( axis2_transport_out_desc_param_container(trans_desc, env), env, AXIS2_XML_DECLARATION); } if(write_xml_declaration_param) { transport_attrs = axutil_param_get_attributes(write_xml_declaration_param, env); if(transport_attrs) { /* Accessing attribute values */ axutil_generic_obj_t *obj = NULL; axiom_attribute_t *write_xml_declaration_attr = NULL; axis2_char_t *write_xml_declaration_attr_value = NULL; obj = axutil_hash_get(transport_attrs, AXIS2_ADD_XML_DECLARATION, AXIS2_HASH_KEY_STRING); if(obj) { write_xml_declaration_attr = (axiom_attribute_t *)axutil_generic_obj_get_value(obj, env); } if(write_xml_declaration_attr) { write_xml_declaration_attr_value = axiom_attribute_get_value( write_xml_declaration_attr, env); } if(write_xml_declaration_attr_value && 0 == axutil_strcasecmp( write_xml_declaration_attr_value, AXIS2_VALUE_TRUE)) { write_xml_declaration = AXIS2_TRUE; } } } if(write_xml_declaration) { axiom_output_write_xml_version_encoding(om_output, env); } if(AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env)) { axiom_node_t *body_node = NULL; /* axis2_bool_t fault = AXIS2_FALSE;*/ axiom_soap_fault_t *soap_fault; axiom_soap_body_t *soap_body = axiom_soap_envelope_get_body(soap_data_out, env); axiom_soap_fault_detail_t *soap_fault_detial; if(!soap_body) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL, AXIS2_FAILURE); axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; return AXIS2_FAILURE; } fault = axiom_soap_body_has_fault(soap_body, env); if(fault == AXIS2_TRUE) { soap_fault = axiom_soap_body_get_fault(soap_body, env); if(!soap_fault) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Rest fault has occur, error described below"); axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; return AXIS2_FAILURE; } soap_fault_detial = axiom_soap_fault_get_detail(soap_fault, env); if(!soap_fault_detial) { axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Returning failure to obtain soap_fault_detail from soap_fault"); return AXIS2_FAILURE; } body_node = axiom_soap_fault_detail_get_base_node(soap_fault_detial, env); if(!body_node) { axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "failure to get base node from soap_fault_detail."); return AXIS2_FAILURE; } } else { body_node = axiom_soap_body_get_base_node(soap_body, env); if(!body_node) { axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "failure to get base node from soap_body."); return AXIS2_FAILURE; } } data_out = axiom_node_get_first_element(body_node, env); if(!data_out || axiom_node_get_node_type(data_out, env) != AXIOM_ELEMENT) { axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "unable to get first element from soap_body, base node."); return AXIS2_FAILURE; } axiom_node_serialize(data_out, env, om_output); buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env); buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); axutil_stream_write(out_stream, env, buffer, buffer_size); /* Finish Rest Processing */ } else { axiom_soap_body_t *body = NULL; body = axiom_soap_envelope_get_body(soap_data_out, env); fault = axiom_soap_body_has_fault(body, env); /* SOAP Processing */ axiom_output_set_do_optimize(om_output, env, do_mtom); axiom_soap_envelope_serialize(soap_data_out, env, om_output, AXIS2_FALSE); if(do_mtom && !fault) { axis2_status_t mtom_status = AXIS2_FAILURE; axis2_char_t *content_type = NULL; axutil_array_list_t *mime_parts = NULL; /*Create the attachment related data and put them to an *array_list */ mtom_status = axiom_output_flush(om_output, env); if(mtom_status == AXIS2_SUCCESS) { mime_parts = axiom_output_get_mime_parts(om_output, env); if(!mime_parts) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to create the mime_part list from om_output"); return AXIS2_FAILURE; } else { axis2_msg_ctx_set_mime_parts(msg_ctx, env, mime_parts); } } /*om_out put has the details of content_type */ content_type = (axis2_char_t *)axiom_output_get_content_type(om_output, env); AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env, content_type); } else { buffer = (axis2_char_t *)axiom_xml_writer_get_xml(xml_writer, env); buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env); /* This is where it actually fill the buffer in out_stream. In application server * side this is the out_stream passed to the in message context from http_worker * function and then copied to the out message context. */ axutil_stream_write(out_stream, env, buffer, buffer_size); } } op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env); axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE); } } axiom_output_free(om_output, env); om_output = NULL; xml_writer = NULL; if(transport_url) { if(epr) { axis2_endpoint_ref_free(epr, env); epr = NULL; } } AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_http_transport_sender_invoke"); return status; } axis2_status_t AXIS2_CALL axis2_http_transport_sender_clean_up( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx) { AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); /* * Clean up is not used. If the http sender needs * to be cleaned up it should be done here. */ return AXIS2_SUCCESS; } axis2_status_t AXIS2_CALL axis2_http_transport_sender_init( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_conf_ctx_t * conf_ctx, axis2_transport_out_desc_t * out_desc) { axutil_param_t *version_param = NULL; axis2_char_t *version = NULL; axis2_char_t *temp = NULL; axutil_param_t *temp_param = NULL; AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); /* Getting HTTP version from axis2.xml */ version_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( out_desc, env), env, AXIS2_HTTP_PROTOCOL_VERSION); if(version_param) { version = axutil_param_get_value(version_param, env); } if(version) { /* handling HTTP 1.1 */ if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_11)) { axis2_char_t *encoding = NULL; axutil_param_t *encoding_param = NULL; if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version) { AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version); } AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version); AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_TRUE; encoding_param = axutil_param_container_get_param( axis2_transport_out_desc_param_container(out_desc, env), env, AXIS2_HTTP_HEADER_TRANSFER_ENCODING); if(encoding_param) { encoding = axutil_param_get_value(encoding_param, env); } if(encoding && 0 == axutil_strcmp(encoding, AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED)) { AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_TRUE; } else { AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE; } } else if(0 == axutil_strcmp(version, AXIS2_HTTP_HEADER_PROTOCOL_10)) { axutil_param_t *keepalive_param = NULL; /* Handling HTTP 1.0 */ if(AXIS2_INTF_TO_IMPL(transport_sender)->http_version) { AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(transport_sender)->http_version); } AXIS2_INTF_TO_IMPL(transport_sender)->http_version = axutil_strdup(env, version); AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE; keepalive_param = axutil_param_container_get_param( axis2_transport_out_desc_param_container(out_desc, env), env, AXIS2_HTTP_HEADER_CONNECTION_KEEPALIVE); if(keepalive_param) { axis2_char_t *keepalive_value = NULL; keepalive_value = axutil_param_get_value(keepalive_param, env); if(!axutil_strcmp(keepalive_value, AXIS2_VALUE_FALSE)) { AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive = AXIS2_FALSE; } } } } else { /* HTTP version is not available in axis2.xml */ AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_HTTP_VERSION, AXIS2_FAILURE); return AXIS2_FAILURE; } /* Getting HTTP_SO_TIMEOUT value from axis2.xml */ temp_param = axutil_param_container_get_param(axis2_transport_out_desc_param_container( out_desc, env), env, AXIS2_HTTP_SO_TIMEOUT); if(temp_param) { temp = axutil_param_get_value(temp_param, env); } if(temp) { AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp); } /* Getting HTTP_CONNECTION_TIMEOUT from axis2.xml */ temp = (axis2_char_t *)axutil_param_container_get_param( axis2_transport_out_desc_param_container(out_desc, env), env, AXIS2_HTTP_CONNECTION_TIMEOUT); if(temp_param) { temp = axutil_param_get_value(temp_param, env); } /* set axis2.xml connection timeout value to http_sender */ if(temp) { AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout = AXIS2_ATOI(temp); } return AXIS2_SUCCESS; } axis2_status_t AXIS2_CALL axis2_http_transport_sender_write_message( axis2_transport_sender_t * transport_sender, const axutil_env_t * env, axis2_msg_ctx_t * msg_ctx, axis2_endpoint_ref_t * epr, axiom_soap_envelope_t * out, axiom_output_t * om_output) { const axis2_char_t *soap_action = NULL; const axis2_char_t *url = NULL; axis2_http_sender_t *sender = NULL; axis2_status_t status = AXIS2_FAILURE; const axis2_char_t *soap_ns_uri = NULL; axiom_soap_envelope_t *response_envelope = NULL; axis2_op_t *op = NULL; AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, epr, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, om_output, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, transport_sender, AXIS2_FAILURE); AXIS2_PARAM_CHECK(env->error, out, AXIS2_FAILURE); /* epr is already passed NULL checking */ url = axis2_endpoint_ref_get_address(epr, env); soap_action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env); if(!soap_action) { soap_action = ""; } sender = axis2_http_sender_create(env); if(!sender) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "http sender creation failed"); return AXIS2_FAILURE; } axis2_http_sender_set_keep_alive(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->keep_alive); /* For the MTOM case we should on chunking. And for chunking to work the * protocol should be http 1.1*/ if(axis2_msg_ctx_get_doing_mtom(msg_ctx, env)) { AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_TRUE); AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, AXIS2_HTTP_HEADER_PROTOCOL_11); } else { AXIS2_HTTP_SENDER_SET_CHUNKED(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->chunked); AXIS2_HTTP_SENDER_SET_HTTP_VERSION(sender, env, AXIS2_INTF_TO_IMPL(transport_sender)->http_version); } AXIS2_HTTP_SENDER_SET_OM_OUTPUT(sender, env, om_output); #ifdef AXIS2_LIBCURL_ENABLED AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "using axis2 libcurl http sender."); status = axis2_libcurl_http_send(AXIS2_INTF_TO_IMPL(transport_sender)->libcurl, sender, env, msg_ctx, out, url, soap_action); #else AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "using axis2 native http sender."); status = AXIS2_HTTP_SENDER_SEND(sender, env, msg_ctx, out, url, soap_action); #endif /* if the send was not successful, do not process any response */ if(status != AXIS2_SUCCESS) { AXIS2_HTTP_SENDER_FREE(sender, env); sender = NULL; return status; } op = axis2_msg_ctx_get_op(msg_ctx, env); if(op) { /* handle one way case */ const axis2_char_t *mep = axis2_op_get_msg_exchange_pattern(op, env); AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "OP name axutil_qname_get_localpart = %s", mep); if(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 || axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0 || axutil_strcmp(mep, AXIS2_MEP_URI_IN_ONLY) == 0) { AXIS2_HTTP_SENDER_FREE(sender, env); sender = NULL; return status; } else { /* AXIS2_MEP_URI_IN_OUT case , we have a response this * time */ soap_ns_uri = axis2_msg_ctx_get_is_soap_11(msg_ctx, env) ? AXIOM_SOAP11_SOAP_ENVELOPE_NAMESPACE_URI : AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI; response_envelope = axis2_http_transport_utils_create_soap_msg(env, msg_ctx, soap_ns_uri); if(response_envelope) { axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, response_envelope); } } } AXIS2_HTTP_SENDER_FREE(sender, env); sender = NULL; return status; } /** * Following block distinguish the exposed part of the dll. */ /* When building for static deployment, give the get and remove methods * unique names. This avoids having the linker fail with duplicate symbol * errors. */ AXIS2_EXPORT int #ifndef AXIS2_STATIC_DEPLOY axis2_get_instance( #else axis2_http_transport_sender_get_instance( #endif struct axis2_transport_sender **inst, const axutil_env_t * env) { *inst = axis2_http_transport_sender_create(env); if(!(*inst)) { return AXIS2_FAILURE; } return AXIS2_SUCCESS; } AXIS2_EXPORT int #ifndef AXIS2_STATIC_DEPLOY axis2_remove_instance( #else axis2_http_transport_sender_remove_instance( #endif axis2_transport_sender_t * inst, const axutil_env_t * env) { if(inst) { AXIS2_TRANSPORT_SENDER_FREE(inst, env); } return AXIS2_SUCCESS; }