You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by di...@apache.org on 2007/10/29 07:40:57 UTC
svn commit: r589520 [2/3] - in /webservices/axis2/trunk/c:
samples/client/echo/echo.c src/core/deployment/conf_init.c
src/core/transport/http/sender/http_sender.c
src/core/transport/tcp/receiver/simple_tcp_svr_conn.c
Modified: webservices/axis2/trunk/c/src/core/transport/http/sender/http_sender.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/transport/http/sender/http_sender.c?rev=589520&r1=589519&r2=589520&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/transport/http/sender/http_sender.c (original)
+++ webservices/axis2/trunk/c/src/core/transport/http/sender/http_sender.c Sun Oct 28 23:40:52 2007
@@ -40,1421 +40,1406 @@
struct axis2_http_sender
{
- axis2_char_t *http_version;
- axis2_bool_t chunked;
- int so_timeout;
- int connection_timeout;
- axiom_output_t *om_output;
- axis2_http_client_t *client;
- axis2_bool_t is_soap;
+ axis2_char_t *http_version;
+ axis2_bool_t chunked;
+ int so_timeout;
+ int connection_timeout;
+ axiom_output_t *om_output;
+ axis2_http_client_t *client;
+ axis2_bool_t is_soap;
};
-static axis2_char_t *axutil_url_encode(
- const axutil_env_t * env,
- axis2_char_t * dest,
- axis2_char_t * buff,
- int len);
+static axis2_char_t *axutil_url_encode (const axutil_env_t * env,
+ axis2_char_t * dest,
+ axis2_char_t * buff, int len);
-static int is_safe_or_unreserve(
- char c);
+static int is_safe_or_unreserve (char c);
#ifndef AXIS2_LIBCURL_ENABLED
-static void axis2_http_sender_add_header_list(
- axis2_http_simple_request_t * request,
- const axutil_env_t * env,
- axutil_array_list_t * array_list);
-
-static axis2_status_t axis2_http_sender_configure_proxy(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx);
-
-static axis2_status_t axis2_http_sender_configure_server_cert(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx);
-
-static axis2_status_t axis2_http_sender_configure_key_file(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx);
-
-static axis2_status_t axis2_http_sender_configure_http_auth(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_request_t * request);
-
-static axis2_status_t axis2_http_sender_configure_http_basic_auth(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_request_t * request);
+static void axis2_http_sender_add_header_list (axis2_http_simple_request_t *
+ request,
+ const axutil_env_t * env,
+ axutil_array_list_t *
+ array_list);
+
+static axis2_status_t axis2_http_sender_configure_proxy (axis2_http_sender_t *
+ sender,
+ const axutil_env_t *
+ env,
+ axis2_msg_ctx_t *
+ msg_ctx);
+
+static axis2_status_t
+axis2_http_sender_configure_server_cert (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx);
+
+static axis2_status_t
+axis2_http_sender_configure_key_file (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx);
+
+static axis2_status_t
+axis2_http_sender_configure_http_auth (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_request_t * request);
+
+static axis2_status_t
+axis2_http_sender_configure_http_basic_auth (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_request_t *
+ request);
#endif
AXIS2_EXTERN axis2_http_sender_t *AXIS2_CALL
-axis2_http_sender_create(
- const axutil_env_t * env)
+axis2_http_sender_create (const axutil_env_t * env)
{
- axis2_http_sender_t *sender = NULL;
- AXIS2_ENV_CHECK(env, NULL);
+ axis2_http_sender_t *sender = NULL;
+ AXIS2_ENV_CHECK (env, NULL);
- sender = (axis2_http_sender_t *) AXIS2_MALLOC
- (env->allocator, sizeof(axis2_http_sender_t));
+ sender = (axis2_http_sender_t *) AXIS2_MALLOC
+ (env->allocator, sizeof (axis2_http_sender_t));
- if (!sender)
+ if (!sender)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
+ AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
}
- sender->http_version = (axis2_char_t *) AXIS2_HTTP_HEADER_PROTOCOL_11;
- sender->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT;
- sender->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
- /* unlike the java impl we don't have a default om output
- * it should be explicitly set and it's a MUST
- */
- sender->om_output = NULL;
- sender->chunked = AXIS2_FALSE;
- sender->client = NULL;
+ sender->http_version = (axis2_char_t *) AXIS2_HTTP_HEADER_PROTOCOL_11;
+ sender->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT;
+ sender->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
+ /* unlike the java impl we don't have a default om output
+ * it should be explicitly set and it's a MUST
+ */
+ sender->om_output = NULL;
+ sender->chunked = AXIS2_FALSE;
+ sender->client = NULL;
- return sender;
+ return sender;
}
AXIS2_EXTERN void AXIS2_CALL
-axis2_http_sender_free(
- axis2_http_sender_t * sender,
- const axutil_env_t * env)
+axis2_http_sender_free (axis2_http_sender_t * sender,
+ const axutil_env_t * env)
{
- AXIS2_ENV_CHECK(env, void);
+ AXIS2_ENV_CHECK (env, void);
- if (sender->http_version)
+ if (sender->http_version)
{
- AXIS2_FREE(env->allocator, sender->http_version);
+ AXIS2_FREE (env->allocator, sender->http_version);
}
- /* Do not free this here since it will be required in later processing
- * of the response soap message
- */
- sender->client = NULL;
- AXIS2_FREE(env->allocator, sender);
- return;
+ /* Do not free this here since it will be required in later processing
+ * of the response soap message
+ */
+ sender->client = NULL;
+ AXIS2_FREE (env->allocator, sender);
+ return;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_send(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axiom_soap_envelope_t * out,
- const axis2_char_t * str_url,
- const axis2_char_t * soap_action)
+axis2_http_sender_send (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axiom_soap_envelope_t * out,
+ const axis2_char_t * str_url,
+ const axis2_char_t * soap_action)
{
#ifdef AXIS2_LIBCURL_ENABLED
- return axis2_libcurl_http_send(sender, env, msg_ctx, out, str_url,
- soap_action);
+ return axis2_libcurl_http_send (sender, env, msg_ctx, out, str_url,
+ soap_action);
#else
- axis2_http_simple_request_t *request = NULL;
- axis2_http_request_line_t *request_line = NULL;
- axutil_url_t *url = NULL;
- axiom_xml_writer_t *xml_writer = NULL;
- axis2_char_t *buffer = NULL;
- unsigned int buffer_size = 0;
- const axis2_char_t *char_set_enc = NULL;
- axutil_string_t *char_set_enc_str = NULL;
- int status_code = -1;
- axis2_http_simple_response_t *response = NULL;
- axis2_char_t *content_type = NULL;
- axis2_bool_t content_type_deepl_copy = AXIS2_TRUE;
- axis2_byte_t *output_stream = NULL;
- int output_stream_size = 0;
- axis2_bool_t doing_mtom = AXIS2_FALSE;
- axutil_property_t *dump_property = NULL;
- axutil_param_t *ssl_pp_param = NULL; /* ssl passphrase */
- axis2_char_t *ssl_pp = NULL;
- axutil_property_t *content_type_property = NULL;
- axutil_hash_t *content_type_hash = NULL;
- axis2_char_t *content_type_value = NULL;
- axutil_property_t *method = NULL;
- axis2_char_t *method_value = NULL;
- axis2_bool_t send_via_get = AXIS2_FALSE;
- axiom_node_t *data_out = NULL;
- axiom_node_t *body_node = NULL;
- axiom_soap_body_t *soap_body = NULL;
- axis2_bool_t is_soap = AXIS2_TRUE;
- axutil_property_t *http_property = NULL;
- axutil_array_list_t *array_list;
- soap_body = axiom_soap_envelope_get_body(out, env);
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, out, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, str_url, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, soap_action, AXIS2_FAILURE);
-
- if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest(msg_ctx, env))
- is_soap = AXIS2_FALSE;
- else
- is_soap = AXIS2_TRUE;
-
- url = axutil_url_parse_string(env, str_url);
-
- if (!is_soap)
- {
- if (!soap_body)
- {
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
- AXIS2_FAILURE);
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
- AXIS2_ERROR_GET_MESSAGE(env->error));
- return AXIS2_FAILURE;
- }
- body_node = axiom_soap_body_get_base_node(soap_body, env);
- if (!body_node)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "body_node is NULL");
- return AXIS2_FAILURE;
- }
- data_out = axiom_node_get_first_element(body_node, env);
-
- method = (axutil_property_t *) axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_HTTP_METHOD);
- if (method)
- method_value = (axis2_char_t *) axutil_property_get_value(method,
- env);
-
- /* The default is POST */
- if (method_value && 0 == axutil_strcmp(method_value, AXIS2_HTTP_GET))
- {
- send_via_get = AXIS2_TRUE;
- }
- }
-
- if (!url)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "url is NULL");
- return AXIS2_FAILURE;
- }
-
- if (sender->client)
- {
- axis2_http_client_free(sender->client, env);
- sender->client = NULL;
- }
-
- sender->client = axis2_http_client_create(env, url);
- if (!sender->client)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "sender->client is NULL");
- return AXIS2_FAILURE;
- }
-
- /* configure proxy settings if we have set so
- */
-
- axis2_http_sender_configure_proxy(sender, env, msg_ctx);
-
- if (!send_via_get)
- {
- axutil_property_t *property = NULL;
-
- /* We put the client into msg_ctx so that we can free it once the processing
- * is done at client side
- */
- property = axutil_property_create(env);
- axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
- axutil_property_set_free_func(property, env,
- axis2_http_client_free_void_arg);
- axutil_property_set_value(property, env, sender->client);
- axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_HTTP_CLIENT, property);
-
- doing_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env);
-
- if (!sender->om_output)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_OM_OUTPUT,
- AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
- xml_writer = axiom_output_get_xml_writer(sender->om_output, env);
-
- char_set_enc_str = axis2_msg_ctx_get_charset_encoding(msg_ctx, env);
- if (!char_set_enc_str)
- {
- char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
- }
- else
- {
- char_set_enc = axutil_string_get_buffer(char_set_enc_str, env);
- }
-
- if (is_soap)
- {
- dump_property = axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_DUMP_INPUT_MSG_TRUE);
- if (dump_property)
- {
- axis2_char_t *dump_true =
- axutil_property_get_value(dump_property, env);
- if (0 == axutil_strcmp(dump_true, AXIS2_VALUE_TRUE))
- {
- axis2_http_client_set_dump_input_msg(sender->client,
- env, AXIS2_TRUE);
- }
- }
-
- axiom_output_set_do_optimize(sender->om_output, env, doing_mtom);
- axiom_soap_envelope_serialize(out, env, sender->om_output,
- AXIS2_FALSE);
- }
- else
- {
- axiom_node_serialize(data_out, env, sender->om_output);
- }
-
- if (doing_mtom)
- {
- axiom_output_flush(sender->om_output, env, &output_stream,
- &output_stream_size);
- }
- else
- {
- buffer = axiom_xml_writer_get_xml(xml_writer, env);
- }
-
- if (!buffer && !doing_mtom)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL xml returned"
- "from xml writer");
- return AXIS2_FAILURE;
- }
-
- request_line =
- axis2_http_request_line_create(env, "POST",
- axutil_url_get_path(url, env),
- sender->http_version);
- }
- else
- {
- axis2_char_t *request_params = NULL;
- axis2_char_t *path = NULL;
-
- request_params = axis2_http_sender_get_param_string(sender,
- env, msg_ctx);
- path = axutil_strcat(env,
- axutil_url_get_path(url, env),
- "?", request_params, NULL);
-
- request_line = axis2_http_request_line_create(env, "GET", path,
- sender->http_version);
- }
-
- request = axis2_http_simple_request_create(env, request_line, NULL, 0,
- NULL);
-
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_USER_AGENT, "Axis2/C");
-
- http_property =
- axis2_msg_ctx_get_property(msg_ctx,
- env, AXIS2_TRANSPORT_HEADER_PROPERTY);
- if (http_property)
- {
- array_list = (axutil_array_list_t *)
- axutil_property_get_value(http_property, env);
- axis2_http_sender_add_header_list(request, env, array_list);
- }
-
- if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
- {
- if ('\"' != *soap_action)
- {
- axis2_char_t *tmp_soap_action = NULL;
- tmp_soap_action =
- AXIS2_MALLOC(env->allocator,
- (axutil_strlen(soap_action) +
- 5) * sizeof(axis2_char_t));
- sprintf(tmp_soap_action, "\"%s\"", soap_action);
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_SOAP_ACTION,
- tmp_soap_action);
- AXIS2_FREE(env->allocator, tmp_soap_action);
- }
- else
- {
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_SOAP_ACTION,
- (const axis2_char_t *)
- soap_action);
- }
- }
-
- if (!send_via_get)
- {
- buffer_size = axiom_xml_writer_get_xml_size(xml_writer, env);
-
- if (AXIS2_FALSE == sender->chunked)
- {
- axis2_char_t tmp_buf[10];
- if (!buffer)
- {
- buffer_size = output_stream_size;
- }
-
- if (buffer_size)
- {
- sprintf(tmp_buf, "%d", buffer_size);
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_CONTENT_LENGTH,
- tmp_buf);
- }
- }
- else
- {
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
- }
-
- if (is_soap)
- {
- if (doing_mtom)
- {
- content_type =
- (axis2_char_t *) axiom_output_get_content_type(sender->
- om_output,
- env);
- if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11(msg_ctx, env) &&
- axutil_strcmp(soap_action, ""))
- {
- /* handle SOAP action for SOAP 1.2 case */
- axis2_char_t *temp_content_type = NULL;
- temp_content_type = axutil_stracat(env,
- content_type,
- ";action=\"");
- content_type = temp_content_type;
- temp_content_type = axutil_stracat(env,
- content_type,
- soap_action);
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- temp_content_type = axutil_stracat(env, content_type, "\"");
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- }
- else
- {
- content_type_deepl_copy = AXIS2_FALSE;
- }
- }
- else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11(msg_ctx, env))
- {
- axis2_char_t *temp_content_type = NULL;
- content_type =
- (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
- content_type = axutil_stracat(env, content_type, ";charset=");
- temp_content_type = axutil_stracat(env,
- content_type, char_set_enc);
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- }
- else
- {
- axis2_char_t *temp_content_type = NULL;
- content_type =
- (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP;
- content_type = axutil_stracat(env, content_type, ";charset=");
- temp_content_type = axutil_stracat(env,
- content_type, char_set_enc);
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- if (axutil_strcmp(soap_action, ""))
- {
- temp_content_type = axutil_stracat(env,
- content_type,
- ";action=\"");
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- temp_content_type = axutil_stracat(env,
- content_type,
- soap_action);
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- temp_content_type = axutil_stracat(env, content_type, "\"");
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type;
- }
- /*temp_content_type = axutil_stracat(env, content_type, ";");
- AXIS2_FREE(env->allocator, content_type);
- content_type = temp_content_type; */
- }
- }
- else
- {
- content_type_property = (axutil_property_t *)
- axis2_msg_ctx_get_property(msg_ctx,
- env,
- AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE);
-
- if (content_type_property)
- {
- content_type_hash = (axutil_hash_t *)
- axutil_property_get_value(content_type_property, env);
- if (content_type_hash)
- {
- content_type_value =
- (char *) axutil_hash_get(content_type_hash,
- AXIS2_HTTP_HEADER_CONTENT_TYPE,
- AXIS2_HASH_KEY_STRING);
- }
- }
- if (content_type_value)
- content_type = content_type_value;
- else
- content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
-
- content_type_deepl_copy = AXIS2_FALSE;
- }
-
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_CONTENT_TYPE,
- content_type);
-
- if (content_type_deepl_copy && content_type)
- {
- AXIS2_FREE(env->allocator, content_type);
- content_type = NULL;
- }
- }
-
- if (0 == axutil_strcmp(sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_11))
- {
- axis2_char_t *header = NULL;
- int server_len = 0;
- server_len = axutil_strlen(axutil_url_get_server(url, env));
- header = AXIS2_MALLOC(env->allocator,
- server_len + 10 * sizeof(axis2_char_t));
- sprintf(header, "%s:%d",
- axutil_url_get_server(url, env), axutil_url_get_port(url, env));
- axis2_http_sender_util_add_header(env,
- request,
- AXIS2_HTTP_HEADER_HOST, header);
- AXIS2_FREE(env->allocator, header);
- header = NULL;
- }
-
- if (doing_mtom)
- {
- axutil_stream_t *stream = axis2_http_simple_request_get_body(request,
- env);
- if (stream)
- {
- axutil_stream_write(stream, env, output_stream, output_stream_size);
- }
- }
- else
- {
- axis2_http_simple_request_set_body_string(request,
- env, buffer, buffer_size);
- }
-
- axis2_http_sender_configure_server_cert(sender, env, msg_ctx);
-
- axis2_http_sender_configure_key_file(sender, env, msg_ctx);
-
- axis2_http_sender_get_timeout_values(sender, env, msg_ctx);
- axis2_http_client_set_timeout(sender->client, env, sender->so_timeout);
-
- ssl_pp_param = axis2_msg_ctx_get_parameter(msg_ctx,
- env, AXIS2_SSL_PASSPHRASE);
-
- if (ssl_pp_param)
- {
- ssl_pp = axutil_param_get_value(ssl_pp_param, env);
- }
-
- /* how should this status_code be handled? */
- status_code = axis2_http_client_send(sender->client, env, request, ssl_pp);
-
- status_code = axis2_http_client_recieve_header(sender->client, env);
-
- if (AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL == status_code)
- {
- axis2_status_t auth_status;
- auth_status = axis2_http_sender_configure_http_auth(sender,
- env,
- msg_ctx, request);
-
- if (auth_status != AXIS2_SUCCESS)
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in setting HTTP"
- " Authentication header");
-
- status_code = axis2_http_client_send(sender->client,
- env, request, ssl_pp);
-
- status_code = axis2_http_client_recieve_header(sender->client, env);
- }
- /*AXIS2_FREE(env->allocator, buffer);
- buffer = NULL; */
-
- axis2_http_simple_request_free(request, env);
- request = NULL;
-
- AXIS2_FREE(env->allocator, output_stream);
- output_stream = NULL;
-
- if (status_code < 0)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "status_code < 0");
- return AXIS2_FAILURE;
- }
- response = axis2_http_client_get_response(sender->client, env);
- if (AXIS2_HTTP_RESPONSE_OK_CODE_VAL == status_code ||
- AXIS2_HTTP_RESPONSE_ACK_CODE_VAL == status_code)
- {
- return axis2_http_sender_process_response(sender, env,
- msg_ctx, response);
- }
- else if (AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL == status_code)
- {
- axis2_http_header_t *tmp_header = NULL;
- axis2_char_t *tmp_header_val = NULL;
- axis2_op_t *op = NULL;
-
- op = axis2_msg_ctx_get_op(msg_ctx, env);
- if (op)
- {
- const axis2_char_t *mep =
- axis2_op_get_msg_exchange_pattern(op, env);
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
- AXIS2_FAILURE);
- /* handle one way case */
-
- if (axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 ||
- axutil_strcmp(mep, AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "mep is AXIS2_MEP_URI_OUT_ONLY or"
- "AXIS2_MEP_URI_ROBUST_OUT_ONLY");
- return AXIS2_FAILURE;
- }
- }
-
- /* set an error to indicate error code status */
- tmp_header =
- axis2_http_simple_response_get_first_header(response,
- env,
- AXIS2_HTTP_HEADER_CONTENT_TYPE);
- if (tmp_header)
- {
- tmp_header_val = axis2_http_header_get_value(tmp_header, env);
- }
-
- if (tmp_header_val && (axutil_strstr(tmp_header_val,
- AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)
- || axutil_strstr(tmp_header_val,
- AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)))
- {
- return axis2_http_sender_process_response(sender,
- env, msg_ctx, response);
- }
- }
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE);
- return AXIS2_FAILURE;
+ axis2_http_simple_request_t *request = NULL;
+ axis2_http_request_line_t *request_line = NULL;
+ axutil_url_t *url = NULL;
+ axiom_xml_writer_t *xml_writer = NULL;
+ axis2_char_t *buffer = NULL;
+ unsigned int buffer_size = 0;
+ const axis2_char_t *char_set_enc = NULL;
+ axutil_string_t *char_set_enc_str = NULL;
+ int status_code = -1;
+ axis2_http_simple_response_t *response = NULL;
+ axis2_char_t *content_type = NULL;
+ axis2_bool_t content_type_deepl_copy = AXIS2_TRUE;
+ axis2_byte_t *output_stream = NULL;
+ int output_stream_size = 0;
+ axis2_bool_t doing_mtom = AXIS2_FALSE;
+ axutil_property_t *dump_property = NULL;
+ axutil_param_t *ssl_pp_param = NULL; /* ssl passphrase */
+ axis2_char_t *ssl_pp = NULL;
+ axutil_property_t *content_type_property = NULL;
+ axutil_hash_t *content_type_hash = NULL;
+ axis2_char_t *content_type_value = NULL;
+ axutil_property_t *method = NULL;
+ axis2_char_t *method_value = NULL;
+ axis2_bool_t send_via_get = AXIS2_FALSE;
+ axiom_node_t *data_out = NULL;
+ axiom_node_t *body_node = NULL;
+ axiom_soap_body_t *soap_body = NULL;
+ axis2_bool_t is_soap = AXIS2_TRUE;
+ axutil_property_t *http_property = NULL;
+ axutil_array_list_t *array_list;
+ soap_body = axiom_soap_envelope_get_body (out, env);
+
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, out, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, str_url, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, soap_action, AXIS2_FAILURE);
+
+ if (AXIS2_TRUE == axis2_msg_ctx_get_doing_rest (msg_ctx, env))
+ is_soap = AXIS2_FALSE;
+ else
+ is_soap = AXIS2_TRUE;
+
+ url = axutil_url_parse_string (env, str_url);
+
+ if (!is_soap)
+ {
+ if (!soap_body)
+ {
+ AXIS2_ERROR_SET (env->error,
+ AXIS2_ERROR_SOAP_ENVELOPE_OR_SOAP_BODY_NULL,
+ AXIS2_FAILURE);
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "%s",
+ AXIS2_ERROR_GET_MESSAGE (env->error));
+ return AXIS2_FAILURE;
+ }
+ body_node = axiom_soap_body_get_base_node (soap_body, env);
+ if (!body_node)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "body_node is NULL");
+ return AXIS2_FAILURE;
+ }
+ data_out = axiom_node_get_first_element (body_node, env);
+
+ method = (axutil_property_t *) axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_HTTP_METHOD);
+ if (method)
+ method_value = (axis2_char_t *) axutil_property_get_value (method,
+ env);
+
+ /* The default is POST */
+ if (method_value && 0 == axutil_strcmp (method_value, AXIS2_HTTP_GET))
+ {
+ send_via_get = AXIS2_TRUE;
+ }
+ }
+
+ if (!url)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "url is NULL");
+ return AXIS2_FAILURE;
+ }
+
+ if (sender->client)
+ {
+ axis2_http_client_free (sender->client, env);
+ sender->client = NULL;
+ }
+
+ sender->client = axis2_http_client_create (env, url);
+ if (!sender->client)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "sender->client is NULL");
+ return AXIS2_FAILURE;
+ }
+
+ /* configure proxy settings if we have set so
+ */
+
+ axis2_http_sender_configure_proxy (sender, env, msg_ctx);
+
+ if (!send_via_get)
+ {
+ axutil_property_t *property = NULL;
+
+ /* We put the client into msg_ctx so that we can free it once the processing
+ * is done at client side
+ */
+ property = axutil_property_create (env);
+ axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
+ axutil_property_set_free_func (property, env,
+ axis2_http_client_free_void_arg);
+ axutil_property_set_value (property, env, sender->client);
+ axis2_msg_ctx_set_property (msg_ctx, env, AXIS2_HTTP_CLIENT, property);
+
+ doing_mtom = axis2_msg_ctx_get_doing_mtom (msg_ctx, env);
+
+ if (!sender->om_output)
+ {
+ AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NULL_OM_OUTPUT,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ xml_writer = axiom_output_get_xml_writer (sender->om_output, env);
+
+ char_set_enc_str = axis2_msg_ctx_get_charset_encoding (msg_ctx, env);
+ if (!char_set_enc_str)
+ {
+ char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
+ }
+ else
+ {
+ char_set_enc = axutil_string_get_buffer (char_set_enc_str, env);
+ }
+
+ if (is_soap)
+ {
+ dump_property = axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_DUMP_INPUT_MSG_TRUE);
+ if (dump_property)
+ {
+ axis2_char_t *dump_true =
+ axutil_property_get_value (dump_property, env);
+ if (0 == axutil_strcmp (dump_true, AXIS2_VALUE_TRUE))
+ {
+ axis2_http_client_set_dump_input_msg (sender->client,
+ env, AXIS2_TRUE);
+ }
+ }
+
+ axiom_output_set_do_optimize (sender->om_output, env, doing_mtom);
+ axiom_soap_envelope_serialize (out, env, sender->om_output,
+ AXIS2_FALSE);
+ }
+ else
+ {
+ axiom_node_serialize (data_out, env, sender->om_output);
+ }
+
+ if (doing_mtom)
+ {
+ axiom_output_flush (sender->om_output, env, &output_stream,
+ &output_stream_size);
+ }
+ else
+ {
+ buffer = axiom_xml_writer_get_xml (xml_writer, env);
+ }
+
+ if (!buffer && !doing_mtom)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "NULL xml returned"
+ "from xml writer");
+ return AXIS2_FAILURE;
+ }
+
+ request_line =
+ axis2_http_request_line_create (env, "POST",
+ axutil_url_get_path (url, env),
+ sender->http_version);
+ }
+ else
+ {
+ axis2_char_t *request_params = NULL;
+ axis2_char_t *path = NULL;
+
+ request_params = axis2_http_sender_get_param_string (sender,
+ env, msg_ctx);
+ path = axutil_strcat (env,
+ axutil_url_get_path (url, env),
+ "?", request_params, NULL);
+
+ request_line = axis2_http_request_line_create (env, "GET", path,
+ sender->http_version);
+ }
+
+ request = axis2_http_simple_request_create (env, request_line, NULL, 0,
+ NULL);
+
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_USER_AGENT, "Axis2/C");
+
+ http_property =
+ axis2_msg_ctx_get_property (msg_ctx,
+ env, AXIS2_TRANSPORT_HEADER_PROPERTY);
+ if (http_property)
+ {
+ array_list = (axutil_array_list_t *)
+ axutil_property_get_value (http_property, env);
+ axis2_http_sender_add_header_list (request, env, array_list);
+ }
+
+ if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11 (msg_ctx, env))
+ {
+ if ('\"' != *soap_action)
+ {
+ axis2_char_t *tmp_soap_action = NULL;
+ tmp_soap_action =
+ AXIS2_MALLOC (env->allocator,
+ (axutil_strlen (soap_action) +
+ 5) * sizeof (axis2_char_t));
+ sprintf (tmp_soap_action, "\"%s\"", soap_action);
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_SOAP_ACTION,
+ tmp_soap_action);
+ AXIS2_FREE (env->allocator, tmp_soap_action);
+ }
+ else
+ {
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_SOAP_ACTION,
+ (const axis2_char_t *)
+ soap_action);
+ }
+ }
+
+ if (!send_via_get)
+ {
+ buffer_size = axiom_xml_writer_get_xml_size (xml_writer, env);
+
+ if (AXIS2_FALSE == sender->chunked)
+ {
+ axis2_char_t tmp_buf[10];
+ if (!buffer)
+ {
+ buffer_size = output_stream_size;
+ }
+
+ if (buffer_size)
+ {
+ sprintf (tmp_buf, "%d", buffer_size);
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_CONTENT_LENGTH,
+ tmp_buf);
+ }
+ }
+ else
+ {
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
+ }
+
+ if (is_soap)
+ {
+ if (doing_mtom)
+ {
+ content_type =
+ (axis2_char_t *) axiom_output_get_content_type (sender->
+ om_output,
+ env);
+ if (AXIS2_TRUE != axis2_msg_ctx_get_is_soap_11 (msg_ctx, env) &&
+ axutil_strcmp (soap_action, ""))
+ {
+ /* handle SOAP action for SOAP 1.2 case */
+ axis2_char_t *temp_content_type = NULL;
+ temp_content_type = axutil_stracat (env,
+ content_type,
+ ";action=\"");
+ content_type = temp_content_type;
+ temp_content_type = axutil_stracat (env,
+ content_type,
+ soap_action);
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ temp_content_type =
+ axutil_stracat (env, content_type, "\"");
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ }
+ else
+ {
+ content_type_deepl_copy = AXIS2_FALSE;
+ }
+ }
+ else if (AXIS2_TRUE == axis2_msg_ctx_get_is_soap_11 (msg_ctx, env))
+ {
+ axis2_char_t *temp_content_type = NULL;
+ content_type =
+ (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
+ content_type = axutil_stracat (env, content_type, ";charset=");
+ temp_content_type = axutil_stracat (env,
+ content_type, char_set_enc);
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ }
+ else
+ {
+ axis2_char_t *temp_content_type = NULL;
+ content_type =
+ (axis2_char_t *) AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP;
+ content_type = axutil_stracat (env, content_type, ";charset=");
+ temp_content_type = axutil_stracat (env,
+ content_type, char_set_enc);
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ if (axutil_strcmp (soap_action, ""))
+ {
+ temp_content_type = axutil_stracat (env,
+ content_type,
+ ";action=\"");
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ temp_content_type = axutil_stracat (env,
+ content_type,
+ soap_action);
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ temp_content_type =
+ axutil_stracat (env, content_type, "\"");
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = temp_content_type;
+ }
+ /*temp_content_type = axutil_stracat(env, content_type, ";");
+ AXIS2_FREE(env->allocator, content_type);
+ content_type = temp_content_type; */
+ }
+ }
+ else
+ {
+ content_type_property = (axutil_property_t *)
+ axis2_msg_ctx_get_property (msg_ctx,
+ env,
+ AXIS2_USER_DEFINED_HTTP_HEADER_CONTENT_TYPE);
+
+ if (content_type_property)
+ {
+ content_type_hash = (axutil_hash_t *)
+ axutil_property_get_value (content_type_property, env);
+ if (content_type_hash)
+ {
+ content_type_value =
+ (char *) axutil_hash_get (content_type_hash,
+ AXIS2_HTTP_HEADER_CONTENT_TYPE,
+ AXIS2_HASH_KEY_STRING);
+ }
+ }
+ if (content_type_value)
+ content_type = content_type_value;
+ else
+ content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
+
+ content_type_deepl_copy = AXIS2_FALSE;
+ }
+
+ axis2_http_sender_util_add_header (env,
+ request,
+ AXIS2_HTTP_HEADER_CONTENT_TYPE,
+ content_type);
+
+ if (content_type_deepl_copy && content_type)
+ {
+ AXIS2_FREE (env->allocator, content_type);
+ content_type = NULL;
+ }
+ }
+
+ if (0 ==
+ axutil_strcmp (sender->http_version, AXIS2_HTTP_HEADER_PROTOCOL_11))
+ {
+ axis2_char_t *header = NULL;
+ int server_len = 0;
+ server_len = axutil_strlen (axutil_url_get_server (url, env));
+ header = AXIS2_MALLOC (env->allocator,
+ server_len + 10 * sizeof (axis2_char_t));
+ sprintf (header, "%s:%d",
+ axutil_url_get_server (url, env), axutil_url_get_port (url,
+ env));
+ axis2_http_sender_util_add_header (env, request, AXIS2_HTTP_HEADER_HOST,
+ header);
+ AXIS2_FREE (env->allocator, header);
+ header = NULL;
+ }
+
+ if (doing_mtom)
+ {
+ axutil_stream_t *stream = axis2_http_simple_request_get_body (request,
+ env);
+ if (stream)
+ {
+ axutil_stream_write (stream, env, output_stream,
+ output_stream_size);
+ }
+ }
+ else
+ {
+ axis2_http_simple_request_set_body_string (request,
+ env, buffer, buffer_size);
+ }
+
+ axis2_http_sender_configure_server_cert (sender, env, msg_ctx);
+
+ axis2_http_sender_configure_key_file (sender, env, msg_ctx);
+
+ axis2_http_sender_get_timeout_values (sender, env, msg_ctx);
+ axis2_http_client_set_timeout (sender->client, env, sender->so_timeout);
+
+ ssl_pp_param = axis2_msg_ctx_get_parameter (msg_ctx,
+ env, AXIS2_SSL_PASSPHRASE);
+
+ if (ssl_pp_param)
+ {
+ ssl_pp = axutil_param_get_value (ssl_pp_param, env);
+ }
+
+ /* how should this status_code be handled? */
+ status_code = axis2_http_client_send (sender->client, env, request, ssl_pp);
+
+ status_code = axis2_http_client_recieve_header (sender->client, env);
+
+ if (AXIS2_HTTP_RESPONSE_HTTP_UNAUTHORIZED_CODE_VAL == status_code)
+ {
+ axis2_status_t auth_status;
+ auth_status = axis2_http_sender_configure_http_auth (sender,
+ env,
+ msg_ctx, request);
+
+ if (auth_status != AXIS2_SUCCESS)
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Error in setting HTTP"
+ " Authentication header");
+
+ status_code = axis2_http_client_send (sender->client,
+ env, request, ssl_pp);
+
+ status_code = axis2_http_client_recieve_header (sender->client, env);
+ }
+ /*AXIS2_FREE(env->allocator, buffer);
+ buffer = NULL; */
+
+ axis2_http_simple_request_free (request, env);
+ request = NULL;
+
+ AXIS2_FREE (env->allocator, output_stream);
+ output_stream = NULL;
+
+ if (status_code < 0)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "status_code < 0");
+ return AXIS2_FAILURE;
+ }
+
+ response = axis2_http_client_get_response (sender->client, env);
+ if (AXIS2_HTTP_RESPONSE_OK_CODE_VAL == status_code ||
+ AXIS2_HTTP_RESPONSE_ACK_CODE_VAL == status_code)
+ {
+ return axis2_http_sender_process_response (sender, env,
+ msg_ctx, response);
+ }
+ else if (AXIS2_HTTP_RESPONSE_INTERNAL_SERVER_ERROR_CODE_VAL == status_code)
+ {
+ axis2_http_header_t *tmp_header = NULL;
+ axis2_char_t *tmp_header_val = NULL;
+ axis2_op_t *op = NULL;
+
+ op = axis2_msg_ctx_get_op (msg_ctx, env);
+ if (op)
+ {
+ const axis2_char_t *mep =
+ axis2_op_get_msg_exchange_pattern (op, env);
+ AXIS2_ERROR_SET (env->error,
+ AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
+ AXIS2_FAILURE);
+ /* handle one way case */
+
+ if (axutil_strcmp (mep, AXIS2_MEP_URI_OUT_ONLY) == 0 ||
+ axutil_strcmp (mep, AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0)
+ {
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI,
+ "mep is AXIS2_MEP_URI_OUT_ONLY or"
+ "AXIS2_MEP_URI_ROBUST_OUT_ONLY");
+ return AXIS2_FAILURE;
+ }
+ }
+
+ /* set an error to indicate error code status */
+ tmp_header =
+ axis2_http_simple_response_get_first_header (response,
+ env,
+ AXIS2_HTTP_HEADER_CONTENT_TYPE);
+ if (tmp_header)
+ {
+ tmp_header_val = axis2_http_header_get_value (tmp_header, env);
+ }
+
+ if (tmp_header_val && (axutil_strstr (tmp_header_val,
+ AXIS2_HTTP_HEADER_ACCEPT_APPL_SOAP)
+ || axutil_strstr (tmp_header_val,
+ AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML)))
+ {
+ return axis2_http_sender_process_response (sender,
+ env, msg_ctx, response);
+ }
+ }
+ AXIS2_ERROR_SET (env->error,
+ AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
#endif
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_set_chunked(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_bool_t chunked)
+axis2_http_sender_set_chunked (axis2_http_sender_t * sender,
+ const axutil_env_t * env, axis2_bool_t chunked)
{
- sender->chunked = chunked;
- return AXIS2_SUCCESS;
+ sender->chunked = chunked;
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_set_om_output(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axiom_output_t * om_output)
+axis2_http_sender_set_om_output (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axiom_output_t * om_output)
{
- sender->om_output = om_output;
- return AXIS2_SUCCESS;
+ sender->om_output = om_output;
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_get_header_info(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_response_t * response)
-{
- axutil_array_list_t *headers = NULL;
- axis2_char_t *charset = NULL;
- int i = 0;
- axis2_bool_t response_chunked = AXIS2_FALSE;
- int *content_length = NULL;
- axutil_property_t *property = NULL;
- axis2_char_t *content_type = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE);
-
- headers = axis2_http_simple_response_get_headers(response, env);
- if (headers == NULL)
- {
- return AXIS2_SUCCESS;
- }
- for (i = 0; i < axutil_array_list_size(headers, env); i++)
- {
- axis2_http_header_t *header = axutil_array_list_get(headers, env, i);
- axis2_char_t *name = axis2_http_header_get_name((axis2_http_header_t *)
- header, env);
- if (name)
- {
- if (0 == axutil_strcmp(name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING) &&
- 0 == axutil_strcmp(axis2_http_header_get_value(header, env),
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
- {
- axis2_char_t *transfer_encoding = NULL;
- transfer_encoding =
- axutil_strdup(env,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
- response_chunked = AXIS2_TRUE;
- axis2_msg_ctx_set_transfer_encoding(msg_ctx,
- env, transfer_encoding);
-
- }
- if (0 != axutil_strcmp(name, AXIS2_HTTP_HEADER_CONTENT_TYPE))
- {
- axis2_char_t *tmp_charset = NULL;
- axis2_char_t *content_type = axis2_http_header_get_value(header,
- env);
- tmp_charset = strstr(content_type,
- AXIS2_HTTP_CHAR_SET_ENCODING);
- if (charset)
- {
- charset = axutil_strdup(env, tmp_charset);
- break;
- }
- }
- }
- }
- content_type =
- (axis2_char_t *) axis2_http_simple_response_get_content_type(response,
- env);
- if (content_type)
- {
- if (strstr(content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)
- && strstr(content_type, AXIS2_HTTP_HEADER_XOP_XML))
- {
- axis2_ctx_t *axis_ctx =
- axis2_op_ctx_get_base(axis2_msg_ctx_get_op_ctx(msg_ctx, env),
- env);
- property = axutil_property_create(env);
- axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
- axutil_property_set_value(property,
- env, axutil_strdup(env, content_type));
- axis2_ctx_set_property(axis_ctx,
- env, MTOM_RECIVED_CONTENT_TYPE, property);
- }
- }
- if (charset)
- {
- axis2_ctx_t *axis_ctx =
- axis2_op_ctx_get_base(axis2_msg_ctx_get_op_ctx(msg_ctx, env), env);
- if (axis_ctx)
- {
- property = axutil_property_create(env);
- axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
- axutil_property_set_value(property, env, charset);
- axis2_ctx_set_property(axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING,
- property);
- }
- }
- if (AXIS2_FALSE == response_chunked)
- {
- int tmp_len = 0;
- content_length = AXIS2_MALLOC(env->allocator, sizeof(int));
- if (!content_length)
- {
- return AXIS2_FAILURE;
- }
- tmp_len = axis2_http_simple_response_get_content_length(response, env);
- memcpy(content_length, &tmp_len, sizeof(int));
- property = axutil_property_create(env);
- axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
- axutil_property_set_value(property, env, content_length);
- axis2_msg_ctx_set_property(msg_ctx, env,
- AXIS2_HTTP_HEADER_CONTENT_LENGTH, property);
+axis2_http_sender_get_header_info (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_response_t * response)
+{
+ axutil_array_list_t *headers = NULL;
+ axis2_char_t *charset = NULL;
+ int i = 0;
+ axis2_bool_t response_chunked = AXIS2_FALSE;
+ int *content_length = NULL;
+ axutil_property_t *property = NULL;
+ axis2_char_t *content_type = NULL;
+
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, response, AXIS2_FAILURE);
+
+ headers = axis2_http_simple_response_get_headers (response, env);
+ if (headers == NULL)
+ {
+ return AXIS2_SUCCESS;
+ }
+ for (i = 0; i < axutil_array_list_size (headers, env); i++)
+ {
+ axis2_http_header_t *header = axutil_array_list_get (headers, env, i);
+ axis2_char_t *name = axis2_http_header_get_name ((axis2_http_header_t *)
+ header, env);
+ if (name)
+ {
+ if (0 == axutil_strcmp (name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING)
+ && 0 ==
+ axutil_strcmp (axis2_http_header_get_value (header, env),
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
+ {
+ axis2_char_t *transfer_encoding = NULL;
+ transfer_encoding =
+ axutil_strdup (env,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
+ response_chunked = AXIS2_TRUE;
+ axis2_msg_ctx_set_transfer_encoding (msg_ctx,
+ env, transfer_encoding);
+
+ }
+ if (0 != axutil_strcmp (name, AXIS2_HTTP_HEADER_CONTENT_TYPE))
+ {
+ axis2_char_t *tmp_charset = NULL;
+ axis2_char_t *content_type =
+ axis2_http_header_get_value (header,
+ env);
+ tmp_charset = strstr (content_type,
+ AXIS2_HTTP_CHAR_SET_ENCODING);
+ if (charset)
+ {
+ charset = axutil_strdup (env, tmp_charset);
+ break;
+ }
+ }
+ }
+ }
+ content_type =
+ (axis2_char_t *) axis2_http_simple_response_get_content_type (response,
+ env);
+ if (content_type)
+ {
+ if (strstr (content_type, AXIS2_HTTP_HEADER_ACCEPT_MULTIPART_RELATED)
+ && strstr (content_type, AXIS2_HTTP_HEADER_XOP_XML))
+ {
+ axis2_ctx_t *axis_ctx =
+ axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env),
+ env);
+ property = axutil_property_create (env);
+ axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
+ axutil_property_set_value (property,
+ env, axutil_strdup (env, content_type));
+ axis2_ctx_set_property (axis_ctx,
+ env, MTOM_RECIVED_CONTENT_TYPE, property);
+ }
+ }
+ if (charset)
+ {
+ axis2_ctx_t *axis_ctx =
+ axis2_op_ctx_get_base (axis2_msg_ctx_get_op_ctx (msg_ctx, env), env);
+ if (axis_ctx)
+ {
+ property = axutil_property_create (env);
+ axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
+ axutil_property_set_value (property, env, charset);
+ axis2_ctx_set_property (axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING,
+ property);
+ }
+ }
+ if (AXIS2_FALSE == response_chunked)
+ {
+ int tmp_len = 0;
+ content_length = AXIS2_MALLOC (env->allocator, sizeof (int));
+ if (!content_length)
+ {
+ return AXIS2_FAILURE;
+ }
+ tmp_len = axis2_http_simple_response_get_content_length (response, env);
+ memcpy (content_length, &tmp_len, sizeof (int));
+ property = axutil_property_create (env);
+ axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
+ axutil_property_set_value (property, env, content_length);
+ axis2_msg_ctx_set_property (msg_ctx, env,
+ AXIS2_HTTP_HEADER_CONTENT_LENGTH, property);
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_process_response(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_response_t * response)
-{
- axutil_stream_t *in_stream = NULL;
- axutil_property_t *property = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE);
-
- in_stream = axis2_http_simple_response_get_body(response, env);
- if (!in_stream)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY,
- AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
-
- axis2_http_sender_get_header_info(sender, env, msg_ctx, response);
- /*axis_ctx = axis2_op_ctx_get_base( axis2_msg_ctx_get_op_ctx(msg_ctx, env),
- env); */
- property = axutil_property_create(env);
- axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST);
- axutil_property_set_free_func(property, env, axutil_stream_free_void_arg);
- axutil_property_set_value(property, env, in_stream);
- /*axis2_ctx_set_property(axis_ctx, env, AXIS2_TRANSPORT_IN, property); */
- axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property);
- return AXIS2_SUCCESS;
+axis2_http_sender_process_response (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_response_t * response)
+{
+ axutil_stream_t *in_stream = NULL;
+ axutil_property_t *property = NULL;
+
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, response, AXIS2_FAILURE);
+
+ in_stream = axis2_http_simple_response_get_body (response, env);
+ if (!in_stream)
+ {
+ AXIS2_ERROR_SET (env->error, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ axis2_http_sender_get_header_info (sender, env, msg_ctx, response);
+ /*axis_ctx = axis2_op_ctx_get_base( axis2_msg_ctx_get_op_ctx(msg_ctx, env),
+ env); */
+ property = axutil_property_create (env);
+ axutil_property_set_scope (property, env, AXIS2_SCOPE_REQUEST);
+ axutil_property_set_free_func (property, env, axutil_stream_free_void_arg);
+ axutil_property_set_value (property, env, in_stream);
+ /*axis2_ctx_set_property(axis_ctx, env, AXIS2_TRANSPORT_IN, property); */
+ axis2_msg_ctx_set_property (msg_ctx, env, AXIS2_TRANSPORT_IN, property);
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_get_timeout_values(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx)
-{
- axis2_char_t *so_str = NULL;
- axis2_char_t *connection_str = NULL;
- axutil_param_t *tmp_param = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
- tmp_param = axis2_msg_ctx_get_parameter(msg_ctx,
- env, AXIS2_HTTP_SO_TIMEOUT);
-
- if (tmp_param)
- {
- so_str = (axis2_char_t *) axutil_param_get_value(tmp_param, env);
- if (so_str)
- {
- sender->so_timeout = AXIS2_ATOI(so_str);
- }
- }
- tmp_param = axis2_msg_ctx_get_parameter(msg_ctx, env,
- AXIS2_HTTP_CONNECTION_TIMEOUT);
- if (tmp_param)
- {
- connection_str =
- (axis2_char_t *) axutil_param_get_value(tmp_param, env);
- if (connection_str)
- {
- sender->connection_timeout = AXIS2_ATOI(connection_str);
- }
+axis2_http_sender_get_timeout_values (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
+{
+ axis2_char_t *so_str = NULL;
+ axis2_char_t *connection_str = NULL;
+ axutil_param_t *tmp_param = NULL;
+
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+
+ tmp_param = axis2_msg_ctx_get_parameter (msg_ctx,
+ env, AXIS2_HTTP_SO_TIMEOUT);
+
+ if (tmp_param)
+ {
+ so_str = (axis2_char_t *) axutil_param_get_value (tmp_param, env);
+ if (so_str)
+ {
+ sender->so_timeout = AXIS2_ATOI (so_str);
+ }
+ }
+ tmp_param = axis2_msg_ctx_get_parameter (msg_ctx, env,
+ AXIS2_HTTP_CONNECTION_TIMEOUT);
+ if (tmp_param)
+ {
+ connection_str =
+ (axis2_char_t *) axutil_param_get_value (tmp_param, env);
+ if (connection_str)
+ {
+ sender->connection_timeout = AXIS2_ATOI (connection_str);
+ }
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_http_sender_set_http_version(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_char_t * version)
-{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- sender->http_version = axutil_strdup(env, version);
- if (!sender->http_version)
+axis2_http_sender_set_http_version (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_char_t * version)
+{
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ sender->http_version = axutil_strdup (env, version);
+ if (!sender->http_version)
{
- return AXIS2_FAILURE;
+ return AXIS2_FAILURE;
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
#ifndef AXIS2_LIBCURL_ENABLED
static void
-axis2_http_sender_add_header_list(
- axis2_http_simple_request_t * request,
- const axutil_env_t * env,
- axutil_array_list_t * array_list)
-{
- int ii = 0;
- int kk = 0;
- axis2_http_header_t *http_header = NULL;
- ii = axutil_array_list_size(array_list, env);
- for (; kk < ii; kk++)
- {
- http_header =
- (axis2_http_header_t *) axutil_array_list_get(array_list, env, kk);
- axis2_http_simple_request_add_header(request, env, http_header);
+axis2_http_sender_add_header_list (axis2_http_simple_request_t * request,
+ const axutil_env_t * env,
+ axutil_array_list_t * array_list)
+{
+ int ii = 0;
+ int kk = 0;
+ axis2_http_header_t *http_header = NULL;
+ ii = axutil_array_list_size (array_list, env);
+ for (; kk < ii; kk++)
+ {
+ http_header =
+ (axis2_http_header_t *) axutil_array_list_get (array_list, env, kk);
+ axis2_http_simple_request_add_header (request, env, http_header);
}
}
static axis2_status_t
-axis2_http_sender_configure_proxy(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx)
-{
- axis2_conf_ctx_t *conf_ctx = NULL;
- axis2_conf_t *conf = NULL;
- axis2_transport_out_desc_t *trans_desc = NULL;
- axutil_param_t *proxy_param = NULL;
- axutil_hash_t *transport_attrs = NULL;
- axis2_char_t *proxy_host = NULL;
- axis2_char_t *proxy_port = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
-
- conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
- if (!conf_ctx)
- {
- return AXIS2_FAILURE;
- }
- conf = axis2_conf_ctx_get_conf(conf_ctx, env);
- if (!conf)
- {
- return AXIS2_FAILURE;
- }
-
- trans_desc = axis2_conf_get_transport_out(conf,
- env, AXIS2_TRANSPORT_ENUM_HTTP);
- if (!trans_desc)
- {
- return AXIS2_FAILURE;
- }
-
- proxy_param =
- axutil_param_container_get_param
- (axis2_transport_out_desc_param_container(trans_desc, env), env,
- AXIS2_HTTP_PROXY);
- if (proxy_param)
- {
- transport_attrs = axutil_param_get_attributes(proxy_param, env);
- if (transport_attrs)
- {
- axutil_generic_obj_t *obj = NULL;
- axiom_attribute_t *host_attr = NULL;
- axiom_attribute_t *port_attr = NULL;
-
- obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_HOST,
- AXIS2_HASH_KEY_STRING);
- if (!obj)
- {
- return AXIS2_FAILURE;
- }
- host_attr = (axiom_attribute_t *) axutil_generic_obj_get_value(obj,
- env);
- if (!host_attr)
- {
- return AXIS2_FAILURE;
- }
- proxy_host = axiom_attribute_get_value(host_attr, env);
- if (!proxy_host)
- {
- return AXIS2_FAILURE;
- }
- /* Now we get the port */
- obj = NULL;
-
- obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PORT,
- AXIS2_HASH_KEY_STRING);
- port_attr = (axiom_attribute_t *) axutil_generic_obj_get_value(obj,
- env);
- if (!port_attr)
- {
- return AXIS2_FAILURE;
- }
- proxy_port = axiom_attribute_get_value(port_attr, env);
- if (!proxy_port)
- {
- return AXIS2_FAILURE;
- }
- }
- }
- else
- {
- proxy_param =
- axutil_param_container_get_param
- (axis2_transport_out_desc_param_container(trans_desc, env), env,
- AXIS2_HTTP_PROXY_API);
- if (proxy_param)
- {
- transport_attrs = axutil_param_get_attributes(proxy_param, env);
- if (transport_attrs)
- {
- axutil_generic_obj_t *obj = NULL;
- axiom_attribute_t *host_attr = NULL;
- axiom_attribute_t *port_attr = NULL;
-
- obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_HOST,
- AXIS2_HASH_KEY_STRING);
- if (!obj)
- {
- return AXIS2_FAILURE;
- }
- host_attr =
- (axiom_attribute_t *) axutil_generic_obj_get_value(obj,
- env);
- if (!host_attr)
- {
- return AXIS2_FAILURE;
- }
- proxy_host = axiom_attribute_get_localname(host_attr, env);
- if (!proxy_host)
- {
- return AXIS2_FAILURE;
- }
- /* Now we get the port */
- obj = NULL;
-
- obj = axutil_hash_get(transport_attrs, AXIS2_HTTP_PROXY_PORT,
- AXIS2_HASH_KEY_STRING);
- port_attr =
- (axiom_attribute_t *) axutil_generic_obj_get_value(obj,
- env);
- if (!port_attr)
- {
- return AXIS2_FAILURE;
- }
-
- proxy_port = axiom_attribute_get_localname(port_attr, env);
- if (!proxy_port)
- {
- return AXIS2_FAILURE;
- }
-
- }
- }
+axis2_http_sender_configure_proxy (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
+{
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ axis2_conf_t *conf = NULL;
+ axis2_transport_out_desc_t *trans_desc = NULL;
+ axutil_param_t *proxy_param = NULL;
+ axutil_hash_t *transport_attrs = NULL;
+ axis2_char_t *proxy_host = NULL;
+ axis2_char_t *proxy_port = NULL;
+
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
+
+ conf_ctx = axis2_msg_ctx_get_conf_ctx (msg_ctx, env);
+ if (!conf_ctx)
+ {
+ return AXIS2_FAILURE;
+ }
+ conf = axis2_conf_ctx_get_conf (conf_ctx, env);
+ if (!conf)
+ {
+ return AXIS2_FAILURE;
+ }
+
+ trans_desc = axis2_conf_get_transport_out (conf,
+ env, AXIS2_TRANSPORT_ENUM_HTTP);
+ if (!trans_desc)
+ {
+ return AXIS2_FAILURE;
+ }
+
+ proxy_param =
+ axutil_param_container_get_param
+ (axis2_transport_out_desc_param_container (trans_desc, env), env,
+ AXIS2_HTTP_PROXY);
+ if (proxy_param)
+ {
+ transport_attrs = axutil_param_get_attributes (proxy_param, env);
+ if (transport_attrs)
+ {
+ axutil_generic_obj_t *obj = NULL;
+ axiom_attribute_t *host_attr = NULL;
+ axiom_attribute_t *port_attr = NULL;
+
+ obj = axutil_hash_get (transport_attrs, AXIS2_HTTP_PROXY_HOST,
+ AXIS2_HASH_KEY_STRING);
+ if (!obj)
+ {
+ return AXIS2_FAILURE;
+ }
+ host_attr = (axiom_attribute_t *) axutil_generic_obj_get_value (obj,
+ env);
+ if (!host_attr)
+ {
+ return AXIS2_FAILURE;
+ }
+ proxy_host = axiom_attribute_get_value (host_attr, env);
+ if (!proxy_host)
+ {
+ return AXIS2_FAILURE;
+ }
+ /* Now we get the port */
+ obj = NULL;
+
+ obj = axutil_hash_get (transport_attrs, AXIS2_HTTP_PROXY_PORT,
+ AXIS2_HASH_KEY_STRING);
+ port_attr = (axiom_attribute_t *) axutil_generic_obj_get_value (obj,
+ env);
+ if (!port_attr)
+ {
+ return AXIS2_FAILURE;
+ }
+ proxy_port = axiom_attribute_get_value (port_attr, env);
+ if (!proxy_port)
+ {
+ return AXIS2_FAILURE;
+ }
+ }
+ }
+ else
+ {
+ proxy_param =
+ axutil_param_container_get_param
+ (axis2_transport_out_desc_param_container (trans_desc, env), env,
+ AXIS2_HTTP_PROXY_API);
+ if (proxy_param)
+ {
+ transport_attrs = axutil_param_get_attributes (proxy_param, env);
+ if (transport_attrs)
+ {
+ axutil_generic_obj_t *obj = NULL;
+ axiom_attribute_t *host_attr = NULL;
+ axiom_attribute_t *port_attr = NULL;
+
+ obj = axutil_hash_get (transport_attrs, AXIS2_HTTP_PROXY_HOST,
+ AXIS2_HASH_KEY_STRING);
+ if (!obj)
+ {
+ return AXIS2_FAILURE;
+ }
+ host_attr =
+ (axiom_attribute_t *) axutil_generic_obj_get_value (obj, env);
+ if (!host_attr)
+ {
+ return AXIS2_FAILURE;
+ }
+ proxy_host = axiom_attribute_get_localname (host_attr, env);
+ if (!proxy_host)
+ {
+ return AXIS2_FAILURE;
+ }
+ /* Now we get the port */
+ obj = NULL;
+
+ obj = axutil_hash_get (transport_attrs, AXIS2_HTTP_PROXY_PORT,
+ AXIS2_HASH_KEY_STRING);
+ port_attr =
+ (axiom_attribute_t *) axutil_generic_obj_get_value (obj, env);
+ if (!port_attr)
+ {
+ return AXIS2_FAILURE;
+ }
+
+ proxy_port = axiom_attribute_get_localname (port_attr, env);
+ if (!proxy_port)
+ {
+ return AXIS2_FAILURE;
+ }
+
+ }
+ }
}
- if (proxy_port && proxy_host)
+ if (proxy_port && proxy_host)
{
- axis2_http_client_set_proxy(sender->client, env, proxy_host,
- AXIS2_ATOI(proxy_port));
+ axis2_http_client_set_proxy (sender->client, env, proxy_host,
+ AXIS2_ATOI (proxy_port));
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
#endif
#ifndef AXIS2_LIBCURL_ENABLED
static axis2_status_t
-axis2_http_sender_configure_server_cert(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx)
+axis2_http_sender_configure_server_cert (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
{
- axutil_property_t *server_cert_property = NULL;
- axutil_param_t *server_cert_param = NULL;
- axis2_char_t *server_cert = NULL;
- axis2_status_t status = AXIS2_FAILURE;
+ axutil_property_t *server_cert_property = NULL;
+ axutil_param_t *server_cert_param = NULL;
+ axis2_char_t *server_cert = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
- server_cert_property = axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_SSL_SERVER_CERT);
- if (server_cert_property)
+ server_cert_property = axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_SSL_SERVER_CERT);
+ if (server_cert_property)
{
- server_cert =
- (axis2_char_t *) axutil_property_get_value(server_cert_property,
- env);
+ server_cert =
+ (axis2_char_t *) axutil_property_get_value (server_cert_property,
+ env);
}
- else
+ else
{
- server_cert_param = axis2_msg_ctx_get_parameter(msg_ctx,
- env,
- AXIS2_SSL_SERVER_CERT);
- if (server_cert_param)
- {
- server_cert =
- (axis2_char_t *) axutil_param_get_value(server_cert_param, env);
- }
+ server_cert_param = axis2_msg_ctx_get_parameter (msg_ctx,
+ env,
+ AXIS2_SSL_SERVER_CERT);
+ if (server_cert_param)
+ {
+ server_cert =
+ (axis2_char_t *) axutil_param_get_value (server_cert_param, env);
+ }
}
- if (server_cert)
+ if (server_cert)
{
- status = axis2_http_client_set_server_cert(sender->client,
- env, server_cert);
+ status = axis2_http_client_set_server_cert (sender->client,
+ env, server_cert);
}
- return status;
+ return status;
}
#endif
#ifndef AXIS2_LIBCURL_ENABLED
static axis2_status_t
-axis2_http_sender_configure_key_file(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx)
+axis2_http_sender_configure_key_file (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
{
- axutil_property_t *key_file_property = NULL;
- axutil_param_t *key_file_param = NULL;
- axis2_char_t *key_file = NULL;
- axis2_status_t status = AXIS2_FAILURE;
+ axutil_property_t *key_file_property = NULL;
+ axutil_param_t *key_file_param = NULL;
+ axis2_char_t *key_file = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK (env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, AXIS2_FAILURE);
- key_file_property = axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_SSL_KEY_FILE);
- if (key_file_property)
+ key_file_property = axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_SSL_KEY_FILE);
+ if (key_file_property)
{
- key_file =
- (axis2_char_t *) axutil_property_get_value(key_file_property, env);
+ key_file =
+ (axis2_char_t *) axutil_property_get_value (key_file_property, env);
}
- else
+ else
{
- key_file_param = axis2_msg_ctx_get_parameter(msg_ctx, env,
- AXIS2_SSL_KEY_FILE);
- if (key_file_param)
- {
- key_file =
- (axis2_char_t *) axutil_param_get_value(key_file_param, env);
- }
+ key_file_param = axis2_msg_ctx_get_parameter (msg_ctx, env,
+ AXIS2_SSL_KEY_FILE);
+ if (key_file_param)
+ {
+ key_file =
+ (axis2_char_t *) axutil_param_get_value (key_file_param, env);
+ }
}
- if (key_file)
+ if (key_file)
{
- status = axis2_http_client_set_key_file(sender->client, env, key_file);
+ status = axis2_http_client_set_key_file (sender->client, env, key_file);
}
- return status;
+ return status;
}
#endif
#ifndef AXIS2_LIBCURL_ENABLED
static axis2_status_t
-axis2_http_sender_configure_http_basic_auth(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_request_t * request)
-{
- axutil_property_t *http_auth_un = NULL;
- axutil_property_t *http_auth_pw = NULL;
- axis2_char_t *uname = NULL;
- axis2_char_t *passwd = NULL;
-
- http_auth_un = axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_HTTP_AUTH_UNAME);
- http_auth_pw = axis2_msg_ctx_get_property(msg_ctx, env,
- AXIS2_HTTP_AUTH_PASSWD);
- if (http_auth_un && http_auth_pw)
- {
- uname = (axis2_char_t *) axutil_property_get_value(http_auth_un, env);
- passwd = (axis2_char_t *) axutil_property_get_value(http_auth_pw, env);
-
- if (uname && passwd)
- {
- int elen;
- int plen = axutil_strlen(uname) + axutil_strlen(passwd) + 1;
- axis2_char_t *to_encode =
- (axis2_char_t
- *) (AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * plen));
- axis2_char_t *encoded = NULL;
- axis2_char_t *auth_str = NULL;
- sprintf(to_encode, "%s:%s", uname, passwd);
- elen = axutil_base64_encode_len(plen);
- encoded = (axis2_char_t *) (AXIS2_MALLOC(env->allocator,
- sizeof(axis2_char_t) *
- elen));
- auth_str =
- (axis2_char_t
- *) (AXIS2_MALLOC(env->allocator,
- sizeof(axis2_char_t) * (elen + 6)));
- axutil_base64_encode(encoded, to_encode, plen);
- sprintf(auth_str, "%s %s", AXIS2_HTTP_AUTH_TYPE_BASIC, encoded);
- axis2_http_sender_util_add_header(env, request,
- AXIS2_HTTP_HEADER_AUTHORIZATION,
- auth_str);
-
- AXIS2_FREE(env->allocator, to_encode);
- to_encode = NULL;
- AXIS2_FREE(env->allocator, encoded);
- encoded = NULL;
- AXIS2_FREE(env->allocator, auth_str);
- auth_str = NULL;
+axis2_http_sender_configure_http_basic_auth (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_request_t *
+ request)
+{
+ axutil_property_t *http_auth_un = NULL;
+ axutil_property_t *http_auth_pw = NULL;
+ axis2_char_t *uname = NULL;
+ axis2_char_t *passwd = NULL;
+
+ http_auth_un = axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_HTTP_AUTH_UNAME);
+ http_auth_pw = axis2_msg_ctx_get_property (msg_ctx, env,
+ AXIS2_HTTP_AUTH_PASSWD);
+ if (http_auth_un && http_auth_pw)
+ {
+ uname = (axis2_char_t *) axutil_property_get_value (http_auth_un, env);
+ passwd = (axis2_char_t *) axutil_property_get_value (http_auth_pw, env);
+
+ if (uname && passwd)
+ {
+ int elen;
+ int plen = axutil_strlen (uname) + axutil_strlen (passwd) + 1;
+ axis2_char_t *to_encode =
+ (axis2_char_t
+ *) (AXIS2_MALLOC (env->allocator, sizeof (axis2_char_t) * plen));
+ axis2_char_t *encoded = NULL;
+ axis2_char_t *auth_str = NULL;
+ sprintf (to_encode, "%s:%s", uname, passwd);
+ elen = axutil_base64_encode_len (plen);
+ encoded = (axis2_char_t *) (AXIS2_MALLOC (env->allocator,
+ sizeof (axis2_char_t) *
+ elen));
+ auth_str =
+ (axis2_char_t
+ *) (AXIS2_MALLOC (env->allocator,
+ sizeof (axis2_char_t) * (elen + 6)));
+ axutil_base64_encode (encoded, to_encode, plen);
+ sprintf (auth_str, "%s %s", AXIS2_HTTP_AUTH_TYPE_BASIC, encoded);
+ axis2_http_sender_util_add_header (env, request,
+ AXIS2_HTTP_HEADER_AUTHORIZATION,
+ auth_str);
+
+ AXIS2_FREE (env->allocator, to_encode);
+ to_encode = NULL;
+ AXIS2_FREE (env->allocator, encoded);
+ encoded = NULL;
+ AXIS2_FREE (env->allocator, auth_str);
+ auth_str = NULL;
- return AXIS2_SUCCESS;
- }
+ return AXIS2_SUCCESS;
+ }
}
- return AXIS2_FAILURE;
+ return AXIS2_FAILURE;
}
#endif
#ifndef AXIS2_LIBCURL_ENABLED
static axis2_status_t
-axis2_http_sender_configure_http_digest_auth(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_request_t * request)
+axis2_http_sender_configure_http_digest_auth (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_request_t *
+ request)
{
- /*TODO: Implement Digest Auth */
- return AXIS2_FAILURE;
+ /*TODO: Implement Digest Auth */
+ return AXIS2_FAILURE;
}
#endif
#ifndef AXIS2_LIBCURL_ENABLED
static axis2_status_t
-axis2_http_sender_configure_http_auth(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axis2_http_simple_request_t * request)
+axis2_http_sender_configure_http_auth (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axis2_http_simple_request_t * request)
{
- axis2_status_t status = AXIS2_FALSE;
- axis2_char_t *auth_type = NULL;
- axis2_http_header_t *auth_header = NULL;
- axis2_http_simple_response_t *response = NULL;
- axis2_char_t *auth_type_end = NULL;
+ axis2_status_t status = AXIS2_FALSE;
+ axis2_char_t *auth_type = NULL;
+ axis2_http_header_t *auth_header = NULL;
+ axis2_http_simple_response_t *response = NULL;
+ axis2_char_t *auth_type_end = NULL;
- response = axis2_http_client_get_response(sender->client, env);
+ response = axis2_http_client_get_response (sender->client, env);
- if (response)
- auth_header = axis2_http_simple_response_get_first_header(response, env,
- AXIS2_HTTP_HEADER_WWW_AUTHENTICATE);
+ if (response)
+ auth_header = axis2_http_simple_response_get_first_header (response, env,
+ AXIS2_HTTP_HEADER_WWW_AUTHENTICATE);
- if (auth_header)
- auth_type = axis2_http_header_get_value(auth_header, env);
+ if (auth_header)
+ auth_type = axis2_http_header_get_value (auth_header, env);
- if (auth_type)
+ if (auth_type)
{
- auth_type_end = axutil_strchr(auth_type, ' ');
- *auth_type_end = '\0';
- auth_type_end++;
- /*Read the realm and the rest stuff now from auth_type_end */
+ auth_type_end = axutil_strchr (auth_type, ' ');
+ *auth_type_end = '\0';
+ auth_type_end++;
+ /*Read the realm and the rest stuff now from auth_type_end */
}
- if (auth_type)
+ if (auth_type)
{
- if (axutil_strcmp(auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0)
- status = axis2_http_sender_configure_http_basic_auth(sender, env,
- msg_ctx,
- request);
- else if (axutil_strcmp(auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0)
- status = axis2_http_sender_configure_http_digest_auth(sender, env,
- msg_ctx,
- request);
- else
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Authtype %s is not"
- "supported", auth_type);
+ if (axutil_strcmp (auth_type, AXIS2_HTTP_AUTH_TYPE_BASIC) == 0)
+ status = axis2_http_sender_configure_http_basic_auth (sender, env,
+ msg_ctx,
+ request);
+ else if (axutil_strcmp (auth_type, AXIS2_HTTP_AUTH_TYPE_DIGEST) == 0)
+ status = axis2_http_sender_configure_http_digest_auth (sender, env,
+ msg_ctx,
+ request);
+ else
+ AXIS2_LOG_ERROR (env->log, AXIS2_LOG_SI, "Authtype %s is not"
+ "supported", auth_type);
}
- else
+ else
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET (env->error, AXIS2_ERROR_HTTP_CLIENT_TRANSPORT_ERROR,
+ AXIS2_FAILURE);
}
- return status;
+ return status;
}
#endif
#ifdef AXIS2_LIBCURL_ENABLED
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axis2_libcurl_http_send(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx,
- axiom_soap_envelope_t * out,
- const axis2_char_t * str_url,
- const axis2_char_t * soap_action)
+axis2_libcurl_http_send (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx,
+ axiom_soap_envelope_t * out,
+ const axis2_char_t * str_url,
+ const axis2_char_t * soap_action)
{
- return axis2_libcurl_send(sender->om_output,
- env, msg_ctx, out, str_url, soap_action);
+ return axis2_libcurl_send (sender->om_output,
+ env, msg_ctx, out, str_url, soap_action);
}
#endif
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axis2_http_sender_get_param_string(
- axis2_http_sender_t * sender,
- const axutil_env_t * env,
- axis2_msg_ctx_t * msg_ctx)
-{
- axiom_soap_envelope_t *soap_env = NULL;
- axiom_node_t *body_node = NULL;
- axiom_node_t *data_node = NULL;
- axiom_element_t *data_element = NULL;
- axiom_child_element_iterator_t *iterator = NULL;
- axutil_array_list_t *param_list = NULL;
- axis2_char_t *param_string = NULL;
- int i = 0;
-
- AXIS2_ENV_CHECK(env, NULL);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, NULL);
-
- soap_env = axis2_msg_ctx_get_soap_envelope(msg_ctx, env);
- if (!soap_env)
- {
- return NULL;
- }
- body_node =
- axiom_soap_body_get_base_node(axiom_soap_envelope_get_body
- (soap_env, env), env);
- data_node = axiom_node_get_first_child(body_node, env);
- if (!data_node)
- {
- return NULL;
- }
- param_list =
- axutil_array_list_create(env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
-
- data_element = axiom_node_get_data_element(data_node, env);
-
- iterator = axiom_element_get_child_elements(data_element, env, data_node);
-
- if (iterator)
- {
- while (AXIS2_TRUE ==
- AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(iterator, env))
- {
- axiom_node_t *node = NULL;
- axiom_element_t *element = NULL;
- axis2_char_t *name = NULL;
- axis2_char_t *value = NULL;
- axis2_char_t *encoded_value = NULL;
-
- node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(iterator, env);
- element = axiom_node_get_data_element(node, env);
- name = axiom_element_get_localname(element, env);
- value = axiom_element_get_text(element, env, node);
- if (value)
- {
- encoded_value =
- (axis2_char_t *) AXIS2_MALLOC(env->allocator,
- strlen(value));
- memset(encoded_value, 0, strlen(value));
- encoded_value =
- axutil_url_encode(env, encoded_value, value, strlen(value));
-
- axutil_array_list_add(param_list, env,
- axutil_strcat(env, name, "=",
- encoded_value, NULL));
- }
- }
- }
- for (i = 0; i < axutil_array_list_size(param_list, env); i++)
- {
- axis2_char_t *tmp_string = NULL;
- axis2_char_t *pair = NULL;
-
- pair = axutil_array_list_get(param_list, env, i);
- if (i == 0)
- tmp_string = axutil_stracat(env, param_string, pair);
- else
- tmp_string = axutil_strcat(env, param_string, "&", pair, NULL);
-
- if (param_string)
- {
- AXIS2_FREE(env->allocator, param_string);
- param_string = NULL;
- }
- AXIS2_FREE(env->allocator, pair);
- param_string = tmp_string;
+axis2_http_sender_get_param_string (axis2_http_sender_t * sender,
+ const axutil_env_t * env,
+ axis2_msg_ctx_t * msg_ctx)
+{
+ axiom_soap_envelope_t *soap_env = NULL;
+ axiom_node_t *body_node = NULL;
+ axiom_node_t *data_node = NULL;
+ axiom_element_t *data_element = NULL;
+ axiom_child_element_iterator_t *iterator = NULL;
+ axutil_array_list_t *param_list = NULL;
+ axis2_char_t *param_string = NULL;
+ int i = 0;
+
+ AXIS2_ENV_CHECK (env, NULL);
+ AXIS2_PARAM_CHECK (env->error, msg_ctx, NULL);
+
+ soap_env = axis2_msg_ctx_get_soap_envelope (msg_ctx, env);
+ if (!soap_env)
+ {
+ return NULL;
+ }
+ body_node =
+ axiom_soap_body_get_base_node (axiom_soap_envelope_get_body
+ (soap_env, env), env);
+ data_node = axiom_node_get_first_child (body_node, env);
+ if (!data_node)
+ {
+ return NULL;
+ }
+ param_list =
+ axutil_array_list_create (env, AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+
+ data_element = axiom_node_get_data_element (data_node, env);
+
+ iterator = axiom_element_get_child_elements (data_element, env, data_node);
+
+ if (iterator)
+ {
+ while (AXIS2_TRUE ==
+ AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT (iterator, env))
+ {
+ axiom_node_t *node = NULL;
+ axiom_element_t *element = NULL;
+ axis2_char_t *name = NULL;
+ axis2_char_t *value = NULL;
+ axis2_char_t *encoded_value = NULL;
+
+ node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT (iterator, env);
+ element = axiom_node_get_data_element (node, env);
+ name = axiom_element_get_localname (element, env);
+ value = axiom_element_get_text (element, env, node);
+ if (value)
+ {
+ encoded_value =
+ (axis2_char_t *) AXIS2_MALLOC (env->allocator,
+ strlen (value));
+ memset (encoded_value, 0, strlen (value));
+ encoded_value =
+ axutil_url_encode (env, encoded_value, value, strlen (value));
+
+ axutil_array_list_add (param_list, env,
+ axutil_strcat (env, name, "=",
+ encoded_value, NULL));
+ }
+ }
+ }
+ for (i = 0; i < axutil_array_list_size (param_list, env); i++)
+ {
+ axis2_char_t *tmp_string = NULL;
+ axis2_char_t *pair = NULL;
+
+ pair = axutil_array_list_get (param_list, env, i);
+ if (i == 0)
+ tmp_string = axutil_stracat (env, param_string, pair);
+ else
+ tmp_string = axutil_strcat (env, param_string, "&", pair, NULL);
+
+ if (param_string)
+ {
+ AXIS2_FREE (env->allocator, param_string);
+ param_string = NULL;
+ }
+ AXIS2_FREE (env->allocator, pair);
+ param_string = tmp_string;
}
- axutil_array_list_free(param_list, env);
- return param_string;
+ axutil_array_list_free (param_list, env);
+ return param_string;
}
static axis2_char_t *
-axutil_url_encode(
- const axutil_env_t * env,
- axis2_char_t * dest,
- axis2_char_t * buff,
- int len)
-{
- axis2_char_t string[4];
- axis2_char_t *expand_buffer;
- int i;
- for (i = 0; i < len && buff[i]; i++)
- {
- if (isalnum(buff[i]) || is_safe_or_unreserve(buff[i]))
- {
- sprintf(string, "%c", buff[i]);
- }
- else
- {
- sprintf(string, "%%%x", buff[i]);
- }
-
- if ((strlen(dest) + 4) > len)
- {
- expand_buffer =
- (axis2_char_t *) AXIS2_MALLOC(env->allocator, len * 2);
- memset(expand_buffer, 0, len * 2);
- len *= 2;
- dest = memmove(expand_buffer, dest, strlen(dest));
- }
- strcat(dest, string);
+axutil_url_encode (const axutil_env_t * env,
+ axis2_char_t * dest, axis2_char_t * buff, int len)
+{
+ axis2_char_t string[4];
+ axis2_char_t *expand_buffer;
+ int i;
+ for (i = 0; i < len && buff[i]; i++)
+ {
+ if (isalnum (buff[i]) || is_safe_or_unreserve (buff[i]))
+ {
+ sprintf (string, "%c", buff[i]);
+ }
+ else
+ {
+ sprintf (string, "%%%x", buff[i]);
+ }
+
+ if ((strlen (dest) + 4) > len)
+ {
+ expand_buffer =
+ (axis2_char_t *) AXIS2_MALLOC (env->allocator, len * 2);
+ memset (expand_buffer, 0, len * 2);
+ len *= 2;
+ dest = memmove (expand_buffer, dest, strlen (dest));
+ }
+ strcat (dest, string);
}
- return dest;
+ return dest;
}
static int
-is_safe_or_unreserve(
- char c)
+is_safe_or_unreserve (char c)
{
- char safe[] = { '$', '-', '_', '.', '+' };
- char reserve[] = { ';', '/', '?', ':', '@', '&', '=' };
+ char safe[] = { '$', '-', '_', '.', '+' };
+ char reserve[] = { ';', '/', '?', ':', '@', '&', '=' };
/* reserved = ";" | "/" | "?" | ":" | "@" | "&" | "="
safe = "$" | "-" | "_" | "." | "+" */
- int flag = 0;
- int i = 0;
+ int flag = 0;
+ int i = 0;
- int size = sizeof(safe) / sizeof(safe[0]);
- for (i = 0; i < size; i++)
+ int size = sizeof (safe) / sizeof (safe[0]);
+ for (i = 0; i < size; i++)
{
- if (c == safe[i])
- {
- flag = 1;
- return flag;
- }
+ if (c == safe[i])
+ {
+ flag = 1;
+ return flag;
+ }
}
- size = sizeof(reserve) / sizeof(reserve[0]);
- for (i = 0; i < size; i++)
+ size = sizeof (reserve) / sizeof (reserve[0]);
+ for (i = 0; i < size; i++)
{
- if (c == reserve[i])
- {
- flag = 0;
- return flag;
- }
+ if (c == reserve[i])
+ {
+ flag = 0;
+ return flag;
+ }
}
- return flag;
+ return flag;
}
void AXIS2_CALL
-axis2_http_sender_util_add_header(
- const axutil_env_t * env,
- axis2_http_simple_request_t * request,
- axis2_char_t * header_name,
- const axis2_char_t * header_value)
-{
- axis2_http_header_t *http_header;
[... 12 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org