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 sa...@apache.org on 2006/06/04 05:09:41 UTC
svn commit: r411506 [14/27] - in /webservices/axis2/trunk/c: axiom/include/
axiom/src/attachments/ axiom/src/om/ axiom/src/parser/guththila/
axiom/src/parser/libxml2/ axiom/src/soap/ axiom/test/om/ axiom/test/soap/
guththila/src/ include/ modules/core/...
Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c?rev=411506&r1=411505&r2=411506&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/sender/http_client.c Sat Jun 3 20:09:08 2006
@@ -32,19 +32,19 @@
/**
* @brief HTTP Client struct impl
- * Axis2 HTTP Client impl
+ * Axis2 HTTP Client impl
*/
typedef struct axis2_http_client_impl axis2_http_client_impl_t;
struct axis2_http_client_impl
{
- axis2_http_client_t http_client;
- int sockfd;
- axis2_stream_t *data_stream;
- axis2_url_t *url;
- axis2_http_simple_response_t *response;
- axis2_bool_t request_sent;
- int timeout;
+ axis2_http_client_t http_client;
+ int sockfd;
+ axis2_stream_t *data_stream;
+ axis2_url_t *url;
+ axis2_http_simple_response_t *response;
+ axis2_bool_t request_sent;
+ int timeout;
axis2_bool_t proxy_enabled;
axis2_char_t *proxy_host;
int proxy_port;
@@ -57,23 +57,23 @@
/***************************** Function headers *******************************/
axis2_status_t AXIS2_CALL
axis2_http_client_send (axis2_http_client_t *client, const axis2_env_t *env,
- axis2_http_simple_request_t *request);
+ axis2_http_simple_request_t *request);
int AXIS2_CALL
axis2_http_client_recieve_header (axis2_http_client_t *client,
- const axis2_env_t *env);
+ const axis2_env_t *env);
axis2_http_simple_response_t* AXIS2_CALL
axis2_http_client_get_response (axis2_http_client_t *client, const axis2_env_t *env);
axis2_status_t AXIS2_CALL
axis2_http_client_set_url (axis2_http_client_t *client,
- const axis2_env_t *env, axis2_url_t *url);
+ const axis2_env_t *env, axis2_url_t *url);
axis2_url_t* AXIS2_CALL
axis2_http_client_get_url (axis2_http_client_t *client, const axis2_env_t *env);
axis2_status_t AXIS2_CALL
axis2_http_client_set_timeout (axis2_http_client_t *client, const axis2_env_t *env,
- int timeout_ms);
+ int timeout_ms);
int AXIS2_CALL
axis2_http_client_get_timeout (axis2_http_client_t *client, const axis2_env_t *env);
@@ -93,7 +93,7 @@
axis2_http_client_free (axis2_http_client_t *client, const axis2_env_t *env);
axis2_status_t AXIS2_CALL
-axis2_http_client_free_void_arg (void *client, const axis2_env_t *env);
+axis2_http_client_free_void_arg (void *client, const axis2_env_t *env);
/***************************** End of function headers ************************/
@@ -105,51 +105,51 @@
http_client_impl = (axis2_http_client_impl_t *)AXIS2_MALLOC
(env->allocator, sizeof(axis2_http_client_impl_t));
-
+
if(NULL == http_client_impl)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
- }
+ }
- http_client_impl->url = url;
- http_client_impl->data_stream = NULL;
- http_client_impl->sockfd = -1;
- http_client_impl->response = NULL;
- http_client_impl->request_sent = AXIS2_FALSE;
- http_client_impl->timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
+ http_client_impl->url = url;
+ http_client_impl->data_stream = NULL;
+ http_client_impl->sockfd = -1;
+ http_client_impl->response = NULL;
+ http_client_impl->request_sent = AXIS2_FALSE;
+ http_client_impl->timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
http_client_impl->proxy_enabled = AXIS2_FALSE;
http_client_impl->proxy_port = 0;
http_client_impl->proxy_host = NULL;
http_client_impl->proxy_host_port = NULL;
-
+
http_client_impl->http_client.ops = AXIS2_MALLOC(env->allocator,
- sizeof(axis2_http_client_ops_t));
+ sizeof(axis2_http_client_ops_t));
if(NULL == http_client_impl->http_client.ops)
- {
- axis2_http_client_free((axis2_http_client_t*) http_client_impl, env);
+ {
+ axis2_http_client_free((axis2_http_client_t*) http_client_impl, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
- }
+ }
http_client_impl->http_client.ops->send = axis2_http_client_send;
http_client_impl->http_client.ops->recieve_header =
- axis2_http_client_recieve_header;
+ axis2_http_client_recieve_header;
http_client_impl->http_client.ops->get_response =
- axis2_http_client_get_response;
- http_client_impl->http_client.ops->set_url = axis2_http_client_set_url;
- http_client_impl->http_client.ops->get_url = axis2_http_client_get_url;
- http_client_impl->http_client.ops->set_timeout =
- axis2_http_client_set_timeout;
- http_client_impl->http_client.ops->get_timeout =
- axis2_http_client_get_timeout;
+ axis2_http_client_get_response;
+ http_client_impl->http_client.ops->set_url = axis2_http_client_set_url;
+ http_client_impl->http_client.ops->get_url = axis2_http_client_get_url;
+ http_client_impl->http_client.ops->set_timeout =
+ axis2_http_client_set_timeout;
+ http_client_impl->http_client.ops->get_timeout =
+ axis2_http_client_get_timeout;
http_client_impl->http_client.ops->set_proxy =
axis2_http_client_set_proxy;
http_client_impl->http_client.ops->get_proxy =
axis2_http_client_get_proxy;
http_client_impl->http_client.ops->free = axis2_http_client_free;
- return &(http_client_impl->http_client);
+ return &(http_client_impl->http_client);
}
@@ -157,7 +157,7 @@
axis2_http_client_free (axis2_http_client_t *client, const axis2_env_t *env)
{
axis2_http_client_impl_t *http_client_impl = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
http_client_impl = AXIS2_INTF_TO_IMPL(client);
if(NULL != http_client_impl->url)
@@ -165,21 +165,21 @@
AXIS2_URL_FREE(http_client_impl->url, env);
http_client_impl->url = NULL;
}
- if(NULL != http_client_impl->response)
+ if(NULL != http_client_impl->response)
{
AXIS2_HTTP_SIMPLE_RESPONSE_FREE(http_client_impl->response, env);
http_client_impl->response = NULL;
}
- if(-1 != http_client_impl->sockfd)
- {
- axis2_network_handler_close_socket(env, http_client_impl->sockfd);
- http_client_impl->sockfd = -1;
- }
+ if(-1 != http_client_impl->sockfd)
+ {
+ axis2_network_handler_close_socket(env, http_client_impl->sockfd);
+ http_client_impl->sockfd = -1;
+ }
if(NULL != client->ops)
AXIS2_FREE(env->allocator, client->ops);
- AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(client));
- return AXIS2_SUCCESS;
+ AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(client));
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
@@ -195,58 +195,58 @@
axis2_status_t AXIS2_CALL
axis2_http_client_send (axis2_http_client_t *client, const axis2_env_t *env,
- axis2_http_simple_request_t *request)
+ axis2_http_simple_request_t *request)
{
axis2_http_client_impl_t *client_impl = NULL;
- char *wire_format = NULL;
- axis2_array_list_t *headers = NULL;
- char *str_header = NULL;
- char *str_body = NULL;
- char *str_request_line = NULL;
- int body_size = 0;
- int written = 0;
- axis2_status_t status = AXIS2_FAILURE;
- axis2_bool_t chunking_enabled = AXIS2_FALSE;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ char *wire_format = NULL;
+ axis2_array_list_t *headers = NULL;
+ char *str_header = NULL;
+ char *str_body = NULL;
+ char *str_request_line = NULL;
+ int body_size = 0;
+ int written = 0;
+ axis2_status_t status = AXIS2_FAILURE;
+ axis2_bool_t chunking_enabled = AXIS2_FALSE;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
client_impl = AXIS2_INTF_TO_IMPL(client);
-
- if(NULL == client_impl->url)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_URL, AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
+
+ if(NULL == client_impl->url)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_URL, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
if(AXIS2_TRUE == client_impl->proxy_enabled)
{
if(NULL == client_impl->proxy_host || client_impl->proxy_port <= 0)
{
return AXIS2_FAILURE;
}
- client_impl->sockfd = axis2_network_handler_open_socket(env,
- client_impl->proxy_host, client_impl->proxy_port);
+ client_impl->sockfd = axis2_network_handler_open_socket(env,
+ client_impl->proxy_host, client_impl->proxy_port);
}
else
{
client_impl->sockfd = axis2_network_handler_open_socket(env,
- AXIS2_URL_GET_SERVER(client_impl->url, env),
- AXIS2_URL_GET_PORT(client_impl->url, env));
+ AXIS2_URL_GET_SERVER(client_impl->url, env),
+ AXIS2_URL_GET_PORT(client_impl->url, env));
}
- if(client_impl->sockfd < 0)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
- /* ONLY FOR TESTING
- * client_impl->data_stream = axis2_stream_create_file(env,
- * stdout);
- */
- if(client_impl->timeout > 0)
- {
- axis2_network_handler_set_sock_option(env, client_impl->sockfd,
- SO_RCVTIMEO, client_impl->timeout);
- axis2_network_handler_set_sock_option(env, client_impl->sockfd,
- SO_SNDTIMEO, client_impl->timeout);
- }
+ if(client_impl->sockfd < 0)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ /* ONLY FOR TESTING
+ * client_impl->data_stream = axis2_stream_create_file(env,
+ * stdout);
+ */
+ if(client_impl->timeout > 0)
+ {
+ axis2_network_handler_set_sock_option(env, client_impl->sockfd,
+ SO_RCVTIMEO, client_impl->timeout);
+ axis2_network_handler_set_sock_option(env, client_impl->sockfd,
+ SO_SNDTIMEO, client_impl->timeout);
+ }
if(0 == AXIS2_STRCASECMP(AXIS2_URL_GET_PROTOCOL(client_impl->url, env),
"HTTPS"))
{
@@ -270,55 +270,55 @@
}
else
{
- client_impl->data_stream = axis2_stream_create_socket(env,
- client_impl->sockfd);
+ client_impl->data_stream = axis2_stream_create_socket(env,
+ client_impl->sockfd);
}
-
- if(NULL == client_impl->data_stream)
- {
- axis2_network_handler_close_socket(env, client_impl->sockfd);
- return AXIS2_FAILURE;
- }
-
- headers = AXIS2_HTTP_SIMPLE_REQUEST_GET_HEADERS(request, env);
- if(NULL != headers)
- {
- int header_count = AXIS2_ARRAY_LIST_SIZE(headers, env);
- int i = 0;
- char *str_header2 = NULL;
- for(i = 0; i < header_count; i++)
- {
- axis2_char_t *header_ext_form = NULL;
- axis2_http_header_t *tmp_header = (axis2_http_header_t*)
- AXIS2_ARRAY_LIST_GET(headers, env, i);
- if(NULL == tmp_header)
- {
- continue;
- }
- /* check whether we have transfer encoding and then see whether the
- * value is "chunked" */
- if(0 == AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env),
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && 0 ==
- AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_VALUE(tmp_header,
- env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
- {
- chunking_enabled = AXIS2_TRUE;
- }
- header_ext_form = AXIS2_HTTP_HEADER_TO_EXTERNAL_FORM(
- tmp_header, env);
- str_header2 = AXIS2_STRACAT(str_header, header_ext_form, env);
- AXIS2_FREE(env->allocator, str_header);
- str_header = NULL;
- AXIS2_FREE(env->allocator, header_ext_form);
- header_ext_form = NULL;
- str_header = str_header2;
- }
- }
+
+ if(NULL == client_impl->data_stream)
+ {
+ axis2_network_handler_close_socket(env, client_impl->sockfd);
+ return AXIS2_FAILURE;
+ }
+
+ headers = AXIS2_HTTP_SIMPLE_REQUEST_GET_HEADERS(request, env);
+ if(NULL != headers)
+ {
+ int header_count = AXIS2_ARRAY_LIST_SIZE(headers, env);
+ int i = 0;
+ char *str_header2 = NULL;
+ for(i = 0; i < header_count; i++)
+ {
+ axis2_char_t *header_ext_form = NULL;
+ axis2_http_header_t *tmp_header = (axis2_http_header_t*)
+ AXIS2_ARRAY_LIST_GET(headers, env, i);
+ if(NULL == tmp_header)
+ {
+ continue;
+ }
+ /* check whether we have transfer encoding and then see whether the
+ * value is "chunked" */
+ if(0 == AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_NAME(tmp_header, env),
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && 0 ==
+ AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_VALUE(tmp_header,
+ env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
+ {
+ chunking_enabled = AXIS2_TRUE;
+ }
+ header_ext_form = AXIS2_HTTP_HEADER_TO_EXTERNAL_FORM(
+ tmp_header, env);
+ str_header2 = AXIS2_STRACAT(str_header, header_ext_form, env);
+ AXIS2_FREE(env->allocator, str_header);
+ str_header = NULL;
+ AXIS2_FREE(env->allocator, header_ext_form);
+ header_ext_form = NULL;
+ str_header = str_header2;
+ }
+ }
if(AXIS2_FALSE == client_impl->proxy_enabled)
{
str_request_line = AXIS2_HTTP_REQUEST_LINE_TO_STRING(
- AXIS2_HTTP_SIMPLE_REQUEST_GET_REQUEST_LINE(request, env)
- , env);
+ AXIS2_HTTP_SIMPLE_REQUEST_GET_REQUEST_LINE(request, env)
+ , env);
}
else
{
@@ -352,71 +352,71 @@
host_port_str = NULL;
}
- wire_format = AXIS2_STRACAT(str_request_line, str_header, env);
- AXIS2_FREE(env->allocator, str_header);
- str_header = NULL;
- AXIS2_FREE(env->allocator, str_request_line);
- str_request_line = NULL;
- written = AXIS2_STREAM_WRITE(client_impl->data_stream, env, wire_format,
- AXIS2_STRLEN(wire_format));
- AXIS2_FREE(env->allocator, wire_format);
- wire_format = NULL;
- written = AXIS2_STREAM_WRITE(client_impl->data_stream, env, AXIS2_HTTP_CRLF,
- 2);
- body_size = AXIS2_HTTP_SIMPLE_REQUEST_GET_BODY_BYTES(request, env,
- &str_body);
- if(body_size > 0 && NULL != str_body)
- {
- if(AXIS2_FALSE == chunking_enabled)
- {
- status = AXIS2_SUCCESS;
- while(written < body_size)
- {
- written = AXIS2_STREAM_WRITE(client_impl->data_stream, env,
- str_body, body_size);
- if(-1 == written)
- {
- status = AXIS2_FAILURE;
- break;
- }
- }
- }
- else
- {
- axis2_http_chunked_stream_t *chunked_stream = NULL;
- chunked_stream = axis2_http_chunked_stream_create(env,
- client_impl->data_stream);
- status = AXIS2_SUCCESS;
- if(NULL == chunked_stream)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked"
- "stream failed");
- return AXIS2_FAILURE;
- }
- while(written < body_size)
- {
- written = AXIS2_HTTP_CHUNKED_STREAM_WRITE(chunked_stream, env,
- str_body, body_size);
- if(-1 == written)
- {
- status = AXIS2_FAILURE;
- break;
- }
- }
- if(AXIS2_SUCCESS == status)
- {
- AXIS2_HTTP_CHUNKED_STREAM_WRITE_LAST_CHUNK(chunked_stream, env);
- }
- AXIS2_HTTP_CHUNKED_STREAM_FREE(chunked_stream, env);
- }
- }
-
- client_impl->request_sent = AXIS2_TRUE;
- if(NULL != str_body)
- {
- AXIS2_FREE(env->allocator, str_body);
- str_body = NULL;
- }
+ wire_format = AXIS2_STRACAT(str_request_line, str_header, env);
+ AXIS2_FREE(env->allocator, str_header);
+ str_header = NULL;
+ AXIS2_FREE(env->allocator, str_request_line);
+ str_request_line = NULL;
+ written = AXIS2_STREAM_WRITE(client_impl->data_stream, env, wire_format,
+ AXIS2_STRLEN(wire_format));
+ AXIS2_FREE(env->allocator, wire_format);
+ wire_format = NULL;
+ written = AXIS2_STREAM_WRITE(client_impl->data_stream, env, AXIS2_HTTP_CRLF,
+ 2);
+ body_size = AXIS2_HTTP_SIMPLE_REQUEST_GET_BODY_BYTES(request, env,
+ &str_body);
+ if(body_size > 0 && NULL != str_body)
+ {
+ if(AXIS2_FALSE == chunking_enabled)
+ {
+ status = AXIS2_SUCCESS;
+ while(written < body_size)
+ {
+ written = AXIS2_STREAM_WRITE(client_impl->data_stream, env,
+ str_body, body_size);
+ if(-1 == written)
+ {
+ status = AXIS2_FAILURE;
+ break;
+ }
+ }
+ }
+ else
+ {
+ axis2_http_chunked_stream_t *chunked_stream = NULL;
+ chunked_stream = axis2_http_chunked_stream_create(env,
+ client_impl->data_stream);
+ status = AXIS2_SUCCESS;
+ if(NULL == chunked_stream)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked"
+ "stream failed");
+ return AXIS2_FAILURE;
+ }
+ while(written < body_size)
+ {
+ written = AXIS2_HTTP_CHUNKED_STREAM_WRITE(chunked_stream, env,
+ str_body, body_size);
+ if(-1 == written)
+ {
+ status = AXIS2_FAILURE;
+ break;
+ }
+ }
+ if(AXIS2_SUCCESS == status)
+ {
+ AXIS2_HTTP_CHUNKED_STREAM_WRITE_LAST_CHUNK(chunked_stream, env);
+ }
+ AXIS2_HTTP_CHUNKED_STREAM_FREE(chunked_stream, env);
+ }
+ }
+
+ client_impl->request_sent = AXIS2_TRUE;
+ if(NULL != str_body)
+ {
+ AXIS2_FREE(env->allocator, str_body);
+ str_body = NULL;
+ }
return status;
}
@@ -424,30 +424,30 @@
int AXIS2_CALL
axis2_http_client_recieve_header(axis2_http_client_t *client, const axis2_env_t *env)
{
- int status_code = -1;
- axis2_http_client_impl_t *client_impl = NULL;
- axis2_http_status_line_t *status_line = NULL;
- axis2_char_t str_status_line[512];
- axis2_char_t tmp_buf[3];
- axis2_char_t str_header[512];
- int read = 0;
- int http_status = 0;
- axis2_bool_t end_of_line = AXIS2_FALSE;
- axis2_bool_t end_of_headers = AXIS2_FALSE;
-
+ int status_code = -1;
+ axis2_http_client_impl_t *client_impl = NULL;
+ axis2_http_status_line_t *status_line = NULL;
+ axis2_char_t str_status_line[512];
+ axis2_char_t tmp_buf[3];
+ axis2_char_t str_header[512];
+ int read = 0;
+ int http_status = 0;
+ axis2_bool_t end_of_line = AXIS2_FALSE;
+ axis2_bool_t end_of_headers = AXIS2_FALSE;
+
AXIS2_ENV_CHECK(env, AXIS2_CRTICAL_FAILURE);
-
- client_impl = AXIS2_INTF_TO_IMPL(client);
- if(-1 == client_impl->sockfd || NULL == client_impl->data_stream ||
- AXIS2_FALSE == client_impl->request_sent)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_REQUEST_NOT_SENT,
- AXIS2_FAILURE);
- return -1;
- }
- /* read the status line */
+
+ client_impl = AXIS2_INTF_TO_IMPL(client);
+ if(-1 == client_impl->sockfd || NULL == client_impl->data_stream ||
+ AXIS2_FALSE == client_impl->request_sent)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_REQUEST_NOT_SENT,
+ AXIS2_FAILURE);
+ return -1;
+ }
+ /* read the status line */
do {
- memset(str_status_line, 0, 512);
+ memset(str_status_line, 0, 512);
while((read = AXIS2_STREAM_READ(client_impl->data_stream, env, tmp_buf,
1)) > 0)
{
@@ -481,52 +481,52 @@
http_status = AXIS2_HTTP_STATUS_LINE_GET_STATUS_CODE(status_line, env);
} while(AXIS2_HTTP_RESPONSE_OK_CODE_VAL > http_status);
- client_impl->response = axis2_http_simple_response_create_default(env);
- AXIS2_HTTP_SIMPLE_RESPONSE_SET_STATUS_LINE(client_impl->response, env,
- AXIS2_HTTP_STATUS_LINE_GET_HTTP_VERSION(status_line,
- env), AXIS2_HTTP_STATUS_LINE_GET_STATUS_CODE(
- status_line, env),
- AXIS2_HTTP_STATUS_LINE_GET_REASON_PHRASE(status_line,
- env));
-
- /* now read the headers */
- memset(str_header, 0, 512);
- end_of_line = AXIS2_FALSE;
- while(AXIS2_FALSE == end_of_headers)
- {
- while((read = AXIS2_STREAM_READ(client_impl->data_stream, env, tmp_buf,
- 1)) > 0)
- {
- tmp_buf[read] = '\0';
- strcat(str_header, tmp_buf);
- if(0 != strstr(str_header, AXIS2_HTTP_CRLF))
- {
- end_of_line = AXIS2_TRUE;
- break;
- }
- }
- if(AXIS2_TRUE == end_of_line)
- {
- if(0 == AXIS2_STRCMP(str_header, AXIS2_HTTP_CRLF))
- {
- end_of_headers = AXIS2_TRUE;
- }
- else
- {
- axis2_http_header_t *tmp_header =
- axis2_http_header_create_by_str(env, str_header);
- memset(str_header, 0, 512);
- if(NULL != tmp_header)
- {
- AXIS2_HTTP_SIMPLE_RESPONSE_SET_HEADER(client_impl->response,
- env, tmp_header);
- }
- }
- }
- end_of_line = AXIS2_FALSE;
- }
- AXIS2_HTTP_SIMPLE_RESPONSE_SET_BODY_STREAM(client_impl->response, env,
- client_impl->data_stream);
+ client_impl->response = axis2_http_simple_response_create_default(env);
+ AXIS2_HTTP_SIMPLE_RESPONSE_SET_STATUS_LINE(client_impl->response, env,
+ AXIS2_HTTP_STATUS_LINE_GET_HTTP_VERSION(status_line,
+ env), AXIS2_HTTP_STATUS_LINE_GET_STATUS_CODE(
+ status_line, env),
+ AXIS2_HTTP_STATUS_LINE_GET_REASON_PHRASE(status_line,
+ env));
+
+ /* now read the headers */
+ memset(str_header, 0, 512);
+ end_of_line = AXIS2_FALSE;
+ while(AXIS2_FALSE == end_of_headers)
+ {
+ while((read = AXIS2_STREAM_READ(client_impl->data_stream, env, tmp_buf,
+ 1)) > 0)
+ {
+ tmp_buf[read] = '\0';
+ strcat(str_header, tmp_buf);
+ if(0 != strstr(str_header, AXIS2_HTTP_CRLF))
+ {
+ end_of_line = AXIS2_TRUE;
+ break;
+ }
+ }
+ if(AXIS2_TRUE == end_of_line)
+ {
+ if(0 == AXIS2_STRCMP(str_header, AXIS2_HTTP_CRLF))
+ {
+ end_of_headers = AXIS2_TRUE;
+ }
+ else
+ {
+ axis2_http_header_t *tmp_header =
+ axis2_http_header_create_by_str(env, str_header);
+ memset(str_header, 0, 512);
+ if(NULL != tmp_header)
+ {
+ AXIS2_HTTP_SIMPLE_RESPONSE_SET_HEADER(client_impl->response,
+ env, tmp_header);
+ }
+ }
+ }
+ end_of_line = AXIS2_FALSE;
+ }
+ AXIS2_HTTP_SIMPLE_RESPONSE_SET_BODY_STREAM(client_impl->response, env,
+ client_impl->data_stream);
if(NULL != status_line)
{
status_code = AXIS2_HTTP_STATUS_LINE_GET_STATUS_CODE(status_line, env);
@@ -558,17 +558,17 @@
axis2_status_t AXIS2_CALL
axis2_http_client_set_url (axis2_http_client_t *client,
- const axis2_env_t *env, axis2_url_t *url)
+ const axis2_env_t *env, axis2_url_t *url)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, url, AXIS2_FAILURE);
- if(NULL != AXIS2_INTF_TO_IMPL(client)->url)
- {
- AXIS2_URL_FREE(AXIS2_INTF_TO_IMPL(client)->url, env);
- AXIS2_INTF_TO_IMPL(client)->url = NULL;
- }
+ AXIS2_PARAM_CHECK(env->error, url, AXIS2_FAILURE);
+ if(NULL != AXIS2_INTF_TO_IMPL(client)->url)
+ {
+ AXIS2_URL_FREE(AXIS2_INTF_TO_IMPL(client)->url, env);
+ AXIS2_INTF_TO_IMPL(client)->url = NULL;
+ }
AXIS2_INTF_TO_IMPL(client)->url = url;
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
axis2_url_t* AXIS2_CALL
@@ -580,11 +580,11 @@
axis2_status_t AXIS2_CALL
axis2_http_client_set_timeout (axis2_http_client_t *client, const axis2_env_t *env,
- int timeout_ms)
+ int timeout_ms)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_INTF_TO_IMPL(client)->timeout = timeout_ms;
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
int AXIS2_CALL
Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c?rev=411506&r1=411505&r2=411506&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/sender/http_transport_sender.c Sat Jun 3 20:09:08 2006
@@ -31,53 +31,53 @@
/**
* @brief HTTP Transport Sender struct impl
- * Axis2 HTTP Transport Sender impl
+ * Axis2 HTTP Transport Sender impl
*/
typedef struct axis2_http_transport_sender_impl
- axis2_http_transport_sender_impl_t;
+ axis2_http_transport_sender_impl_t;
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_transport_sender_t transport_sender;
+ axis2_char_t *http_version;
+ axis2_bool_t chunked;
+ int connection_timeout;
+ int so_timeout;
+
};
#define AXIS2_INTF_TO_IMPL(transport_sender) \
- ((axis2_http_transport_sender_impl_t *)\
- (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 axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_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 axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_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 axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
- axis2_transport_out_desc_t *out_desc);
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_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 axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_endpoint_ref_t *epr,
- axis2_soap_envelope_t *out,
- axis2_om_output_t *om_output);
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_endpoint_ref_t *epr,
+ axis2_soap_envelope_t *out,
+ axis2_om_output_t *om_output);
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_free
- (axis2_transport_sender_t *transport_sender,
- const axis2_env_t *env);
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env);
/***************************** End of function headers ************************/
axis2_transport_sender_t* AXIS2_CALL
@@ -89,48 +89,48 @@
transport_sender_impl = (axis2_http_transport_sender_impl_t *)AXIS2_MALLOC
(env->allocator, sizeof(
axis2_http_transport_sender_impl_t));
-
+
if(NULL == transport_sender_impl)
- {
- 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;
+ }
transport_sender_impl->http_version = AXIS2_STRDUP(
- AXIS2_HTTP_HEADER_PROTOCOL_11, env);
- 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;
+ AXIS2_HTTP_HEADER_PROTOCOL_11, env);
+ 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->transport_sender.ops = AXIS2_MALLOC(env->allocator
- ,sizeof(axis2_transport_sender_ops_t));
+ ,sizeof(axis2_transport_sender_ops_t));
if(NULL == transport_sender_impl->transport_sender.ops)
- {
- axis2_http_transport_sender_free((axis2_transport_sender_t*)
- transport_sender_impl, env);
+ {
+ axis2_http_transport_sender_free((axis2_transport_sender_t*)
+ transport_sender_impl, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
- return NULL;
- }
+ return NULL;
+ }
transport_sender_impl->transport_sender.ops->invoke =
axis2_http_transport_sender_invoke;
transport_sender_impl->transport_sender.ops->cleanup =
- axis2_http_transport_sender_clean_up;
+ axis2_http_transport_sender_clean_up;
transport_sender_impl->transport_sender.ops->init =
- axis2_http_transport_sender_init;
+ axis2_http_transport_sender_init;
transport_sender_impl->transport_sender.ops->free =
- axis2_http_transport_sender_free;
+ axis2_http_transport_sender_free;
- return &(transport_sender_impl->transport_sender);
+ return &(transport_sender_impl->transport_sender);
}
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_free
- (axis2_transport_sender_t *transport_sender,
- const axis2_env_t *env)
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env)
{
axis2_http_transport_sender_impl_t *transport_sender_impl = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
transport_sender_impl = AXIS2_INTF_TO_IMPL(transport_sender);
if(NULL != transport_sender_impl->http_version)
@@ -142,94 +142,94 @@
if(NULL != transport_sender->ops)
AXIS2_FREE(env->allocator, transport_sender->ops);
- AXIS2_FREE(env->allocator, transport_sender_impl);
- return AXIS2_SUCCESS;
+ AXIS2_FREE(env->allocator, transport_sender_impl);
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_invoke
- (axis2_transport_sender_t *transport_sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
{
axis2_char_t *char_set_enc = NULL;
- axis2_endpoint_ref_t *epr = NULL;
- axis2_char_t *transport_url = NULL;
- axis2_xml_writer_t *xml_writer = NULL;
- axis2_om_output_t *om_output = NULL;
- axis2_char_t *buffer = NULL;
- axis2_soap_envelope_t *soap_data_out = NULL;
- axis2_bool_t do_mtom;
+ axis2_endpoint_ref_t *epr = NULL;
+ axis2_char_t *transport_url = NULL;
+ axis2_xml_writer_t *xml_writer = NULL;
+ axis2_om_output_t *om_output = NULL;
+ axis2_char_t *buffer = NULL;
+ axis2_soap_envelope_t *soap_data_out = NULL;
+ axis2_bool_t do_mtom;
axis2_property_t *property = NULL;
axis2_om_node_t *data_out = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
-
- property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
if(property)
{
char_set_enc = AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
- if(NULL == char_set_enc)
- {
- axis2_op_ctx_t *op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
- if(NULL != op_ctx)
- {
+ if(NULL == char_set_enc)
+ {
+ axis2_op_ctx_t *op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
+ if(NULL != op_ctx)
+ {
axis2_ctx_t *ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env);
if (ctx)
{
- property = AXIS2_CTX_GET_PROPERTY(ctx, env,
- AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
+ property = AXIS2_CTX_GET_PROPERTY(ctx, env,
+ AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
if(property)
{
char_set_enc = AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
}
- }
- }
- /**
- * If we still can't find the char set enc we will
- * use default
- */
- if(NULL == char_set_enc)
- {
- char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
- }
-
- do_mtom = axis2_http_transport_utils_do_write_mtom(env,
- msg_ctx);
- AXIS2_MSG_CTX_SET_DOING_MTOM(msg_ctx, env, do_mtom);
- /*AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx,
- env, axis2_http_transport_utils_is_doing_rest(env,
- msg_ctx));*/
- property = (axis2_property_t*)AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- AXIS2_TRANSPORT_URL, AXIS2_FALSE);
+ }
+ }
+ /**
+ * If we still can't find the char set enc we will
+ * use default
+ */
+ if(NULL == char_set_enc)
+ {
+ char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
+ }
+
+ do_mtom = axis2_http_transport_utils_do_write_mtom(env,
+ msg_ctx);
+ AXIS2_MSG_CTX_SET_DOING_MTOM(msg_ctx, env, do_mtom);
+ /*AXIS2_MSG_CTX_SET_DOING_REST(msg_ctx,
+ env, axis2_http_transport_utils_is_doing_rest(env,
+ msg_ctx));*/
+ property = (axis2_property_t*)AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ AXIS2_TRANSPORT_URL, AXIS2_FALSE);
if(property)
{
transport_url = (axis2_char_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
- if(NULL != transport_url)
- {
- epr = axis2_endpoint_ref_create(env, transport_url);
- }
- else
- {
- axis2_endpoint_ref_t *ctx_epr = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
- if(NULL != ctx_epr && 0 != AXIS2_STRCMP(
- AXIS2_WSA_ANONYMOUS_URL_SUBMISSION,
- AXIS2_ENDPOINT_REF_GET_ADDRESS(ctx_epr, env)) &&
- 0 != AXIS2_STRCMP(AXIS2_WSA_ANONYMOUS_URL,
- AXIS2_ENDPOINT_REF_GET_ADDRESS(ctx_epr, env)))
- {
- epr = ctx_epr;
- }
- }
-
+ if(NULL != transport_url)
+ {
+ epr = axis2_endpoint_ref_create(env, transport_url);
+ }
+ else
+ {
+ axis2_endpoint_ref_t *ctx_epr = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
+ if(NULL != ctx_epr && 0 != AXIS2_STRCMP(
+ AXIS2_WSA_ANONYMOUS_URL_SUBMISSION,
+ AXIS2_ENDPOINT_REF_GET_ADDRESS(ctx_epr, env)) &&
+ 0 != AXIS2_STRCMP(AXIS2_WSA_ANONYMOUS_URL,
+ AXIS2_ENDPOINT_REF_GET_ADDRESS(ctx_epr, env)))
+ {
+ epr = ctx_epr;
+ }
+ }
+
soap_data_out = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env);
if(NULL == soap_data_out)
{
@@ -253,8 +253,8 @@
xml_writer = NULL;
return AXIS2_FAILURE;
}
- if(NULL != epr)
- {
+ if(NULL != epr)
+ {
if (AXIS2_STRCMP(AXIS2_WSA_NONE_URL_SUBMISSION, AXIS2_ENDPOINT_REF_GET_ADDRESS(epr, env)) == 0 ||
AXIS2_STRCMP(AXIS2_WSA_NONE_URL, AXIS2_ENDPOINT_REF_GET_ADDRESS(epr, env)) ==0 )
{
@@ -262,55 +262,55 @@
}
else
{
- axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx
- , epr, soap_data_out, om_output);
+ axis2_http_transport_sender_write_message(transport_sender, env, msg_ctx
+ , epr, soap_data_out, om_output);
}
- }
-
+ }
+
if (!epr)
- {
- axis2_stream_t *out_stream = NULL;
+ {
+ axis2_stream_t *out_stream = NULL;
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- AXIS2_TRANSPORT_OUT, AXIS2_FALSE);
+ AXIS2_TRANSPORT_OUT, AXIS2_FALSE);
if(property)
{
out_stream = AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
- if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_SERVER_SIDE(msg_ctx, env))
- {
+ if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_SERVER_SIDE(msg_ctx, env))
+ {
axis2_op_ctx_t *op_ctx = NULL;
axis2_ctx_t *ctx = NULL;
axis2_http_out_transport_info_t *out_info = NULL;
- axis2_bool_t is_soap11 = AXIS2_FALSE;
-
+ axis2_bool_t is_soap11 = AXIS2_FALSE;
+
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- AXIS2_HTTP_OUT_TRANSPORT_INFO, AXIS2_FALSE);
+ AXIS2_HTTP_OUT_TRANSPORT_INFO, AXIS2_FALSE);
if(property)
{
-
- out_info = (axis2_http_out_transport_info_t *)
+
+ out_info = (axis2_http_out_transport_info_t *)
AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
-
-
- if(NULL == out_info)
- {
- AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE);
+
+
+ if(NULL == out_info)
+ {
+ AXIS2_ERROR_SET(env->error,
+ AXIS2_ERROR_OUT_TRNSPORT_INFO_NULL, AXIS2_FAILURE);
AXIS2_OM_OUTPUT_FREE(om_output, env);
om_output = NULL;
xml_writer = NULL;
- return AXIS2_FAILURE;
- }
- is_soap11 = AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env);
- /* AXIS2_OM_OUTPUT_SET_SOAP11(om_output, env, is_soap_11);
- */
- AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_info, env,
- char_set_enc);
- if(AXIS2_TRUE == is_soap11)
+ return AXIS2_FAILURE;
+ }
+ is_soap11 = AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx, env);
+ /* AXIS2_OM_OUTPUT_SET_SOAP11(om_output, env, is_soap_11);
+ */
+ AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CHAR_ENCODING(out_info, env,
+ char_set_enc);
+ if(AXIS2_TRUE == is_soap11)
{
AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env,
AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML);
@@ -322,10 +322,10 @@
}
/*
AXIS2_HTTP_OUT_TRANSPORT_INFO_SET_CONTENT_TYPE(out_info, env,
- AXIS2_OM_OUTPUT_GET_CONTENT_TYPE(om_output, env));*/
- /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env,
- * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env);
- */
+ AXIS2_OM_OUTPUT_GET_CONTENT_TYPE(om_output, env));*/
+ /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env,
+ * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env);
+ */
if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env))
{
axis2_om_node_t *body_node = NULL;
@@ -370,9 +370,9 @@
AXIS2_FALSE);
buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer, env);
}
- AXIS2_STREAM_WRITE(out_stream, env, buffer, AXIS2_STRLEN(buffer));
- AXIS2_FREE(env->allocator, buffer);
-
+ AXIS2_STREAM_WRITE(out_stream, env, buffer, AXIS2_STRLEN(buffer));
+ AXIS2_FREE(env->allocator, buffer);
+
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
if (op_ctx)
{
@@ -390,11 +390,11 @@
}
}
- }
- }
- AXIS2_OM_OUTPUT_FREE(om_output, env);
- om_output = NULL;
- xml_writer = NULL;
+ }
+ }
+ AXIS2_OM_OUTPUT_FREE(om_output, env);
+ om_output = NULL;
+ xml_writer = NULL;
if(NULL != transport_url)
{
@@ -404,155 +404,155 @@
epr = NULL;
}
}
- /*
- * TODO handle errors
- */
+ /*
+ * TODO handle errors
+ */
return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_clean_up
- (axis2_transport_sender_t *transport_sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, msg_ctx, 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_PARAM_CHECK(env->error, msg_ctx, 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 axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
- axis2_transport_out_desc_t *out_desc)
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
+ axis2_transport_out_desc_t *out_desc)
{
- axis2_param_t *version_param = NULL;
+ axis2_param_t *version_param = NULL;
axis2_char_t *version = NULL;
- axis2_char_t *temp = NULL;
- axis2_param_t *temp_param = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ axis2_char_t *temp = NULL;
+ axis2_param_t *temp_param = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE);
-
- version_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
- out_desc->param_container, env,
- AXIS2_HTTP_PROTOCOL_VERSION);
- if(NULL != version_param)
- {
- version = AXIS2_PARAM_GET_VALUE(version_param, env);
- }
- if(NULL != version)
- {
- if(0 == AXIS2_STRCMP(version, AXIS2_HTTP_HEADER_PROTOCOL_11))
- {
- axis2_char_t *encoding = NULL;
- axis2_param_t *encoding_param = NULL;
- if(NULL != 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 = AXIS2_STRDUP(
- version, env);
- encoding_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
- out_desc->param_container, env,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING);
- if(NULL != encoding_param)
- {
- encoding = AXIS2_PARAM_GET_VALUE(encoding_param, env);
- }
- if(NULL != encoding && 0 == AXIS2_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 == AXIS2_STRCMP(version, AXIS2_HTTP_HEADER_PROTOCOL_10))
- {
- if(NULL != 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 = AXIS2_STRDUP(
- version, env);
- AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE;
- }
- }
- else
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION,
- AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
-
-
- temp_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
- out_desc->param_container, env,
- AXIS2_HTTP_SO_TIMEOUT);
- if(NULL != temp_param)
- {
- temp = AXIS2_PARAM_GET_VALUE(temp_param, env);
- }
- if(NULL != temp)
- {
- AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp);
- }
- temp = (axis2_char_t *)AXIS2_PARAM_CONTAINER_GET_PARAM(
- out_desc->param_container, env,
- AXIS2_HTTP_CONNECTION_TIMEOUT);
- if(NULL != temp_param)
- {
- temp = AXIS2_PARAM_GET_VALUE(temp_param, env);
- }
- if(NULL != temp)
- {
- AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout =
+ AXIS2_PARAM_CHECK(env->error, out_desc, AXIS2_FAILURE);
+
+ version_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
+ out_desc->param_container, env,
+ AXIS2_HTTP_PROTOCOL_VERSION);
+ if(NULL != version_param)
+ {
+ version = AXIS2_PARAM_GET_VALUE(version_param, env);
+ }
+ if(NULL != version)
+ {
+ if(0 == AXIS2_STRCMP(version, AXIS2_HTTP_HEADER_PROTOCOL_11))
+ {
+ axis2_char_t *encoding = NULL;
+ axis2_param_t *encoding_param = NULL;
+ if(NULL != 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 = AXIS2_STRDUP(
+ version, env);
+ encoding_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
+ out_desc->param_container, env,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING);
+ if(NULL != encoding_param)
+ {
+ encoding = AXIS2_PARAM_GET_VALUE(encoding_param, env);
+ }
+ if(NULL != encoding && 0 == AXIS2_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 == AXIS2_STRCMP(version, AXIS2_HTTP_HEADER_PROTOCOL_10))
+ {
+ if(NULL != 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 = AXIS2_STRDUP(
+ version, env);
+ AXIS2_INTF_TO_IMPL(transport_sender)->chunked = AXIS2_FALSE;
+ }
+ }
+ else
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_HTTP_VERSION,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+
+ temp_param = AXIS2_PARAM_CONTAINER_GET_PARAM(
+ out_desc->param_container, env,
+ AXIS2_HTTP_SO_TIMEOUT);
+ if(NULL != temp_param)
+ {
+ temp = AXIS2_PARAM_GET_VALUE(temp_param, env);
+ }
+ if(NULL != temp)
+ {
+ AXIS2_INTF_TO_IMPL(transport_sender)->so_timeout = AXIS2_ATOI(temp);
+ }
+ temp = (axis2_char_t *)AXIS2_PARAM_CONTAINER_GET_PARAM(
+ out_desc->param_container, env,
+ AXIS2_HTTP_CONNECTION_TIMEOUT);
+ if(NULL != temp_param)
+ {
+ temp = AXIS2_PARAM_GET_VALUE(temp_param, env);
+ }
+ if(NULL != temp)
+ {
+ AXIS2_INTF_TO_IMPL(transport_sender)->connection_timeout =
AXIS2_ATOI(temp);
- }
+ }
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_http_transport_sender_write_message
- (axis2_transport_sender_t *transport_sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_endpoint_ref_t *epr,
- axis2_soap_envelope_t *out,
- axis2_om_output_t *om_output)
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_endpoint_ref_t *epr,
+ axis2_soap_envelope_t *out,
+ axis2_om_output_t *om_output)
{
- axis2_char_t *soap_action = NULL;
- axis2_char_t *url = NULL;
- axis2_soap_over_http_sender_t *sender = NULL;
+ axis2_char_t *soap_action = NULL;
+ axis2_char_t *url = NULL;
+ axis2_soap_over_http_sender_t *sender = NULL;
axis2_status_t status = AXIS2_FAILURE;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- 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);
-
- url = AXIS2_ENDPOINT_REF_GET_ADDRESS(epr, env);
- soap_action = AXIS2_MSG_CTX_GET_SOAP_ACTION(msg_ctx, env);
- if(NULL == soap_action || 0 == AXIS2_STRLEN(soap_action))
- {
- soap_action = AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx, env);
- }
- if(NULL == soap_action)
- {
- soap_action = "";
- }
- if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env))
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ 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);
+
+ url = AXIS2_ENDPOINT_REF_GET_ADDRESS(epr, env);
+ soap_action = AXIS2_MSG_CTX_GET_SOAP_ACTION(msg_ctx, env);
+ if(NULL == soap_action || 0 == AXIS2_STRLEN(soap_action))
+ {
+ soap_action = AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx, env);
+ }
+ if(NULL == soap_action)
+ {
+ soap_action = "";
+ }
+ if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_DOING_REST(msg_ctx, env))
{
axis2_om_node_t *data_out = NULL;
axis2_om_node_t *body_node = NULL;
@@ -579,7 +579,7 @@
{
return AXIS2_FAILURE;
}
- sender = axis2_rest_sender_create(env);
+ sender = axis2_rest_sender_create(env);
AXIS2_REST_SENDER_SET_CHUNKED(sender, env,
AXIS2_INTF_TO_IMPL(transport_sender)->chunked);
AXIS2_REST_SENDER_SET_OM_OUTPUT(sender, env, om_output);
@@ -587,7 +587,7 @@
AXIS2_INTF_TO_IMPL(transport_sender)->http_version);
status = AXIS2_REST_SENDER_SEND(sender, env, msg_ctx, data_out, url);
}
- else
+ else
{
sender = axis2_soap_over_http_sender_create(env);
@@ -608,7 +608,7 @@
AXIS2_SOAP_OVER_HTTP_SENDER_FREE(sender, env);
sender = NULL;
}
- return status;
+ return status;
}
/**
Modified: webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c?rev=411506&r1=411505&r2=411506&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c (original)
+++ webservices/axis2/trunk/c/modules/core/transport/http/sender/rest_sender.c Sat Jun 3 20:09:08 2006
@@ -28,60 +28,60 @@
/**
* @brief REST sender struct impl
- * Axis2 REST sender impl
+ * Axis2 REST sender impl
*/
typedef struct axis2_rest_sender_impl
- axis2_rest_sender_impl_t;
+ axis2_rest_sender_impl_t;
struct axis2_rest_sender_impl
{
- axis2_rest_sender_t sender;
- axis2_char_t *http_version;
- axis2_bool_t chunked;
- int so_timeout;
- int connection_timeout;
- axis2_om_output_t *om_output;
- axis2_http_client_t *client;
+ axis2_rest_sender_t sender;
+ axis2_char_t *http_version;
+ axis2_bool_t chunked;
+ int so_timeout;
+ int connection_timeout;
+ axis2_om_output_t *om_output;
+ axis2_http_client_t *client;
};
#define AXIS2_INTF_TO_IMPL(sender) \
- ((axis2_rest_sender_impl_t *)(sender))
+ ((axis2_rest_sender_impl_t *)(sender))
/***************************** Function headers *******************************/
axis2_status_t AXIS2_CALL
axis2_rest_sender_get_header_info(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_http_simple_response_t *response);
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_http_simple_response_t *response);
axis2_status_t AXIS2_CALL
axis2_rest_sender_process_response(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_http_simple_response_t *response);
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_http_simple_response_t *response);
axis2_status_t AXIS2_CALL
axis2_rest_sender_get_timeout_values(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
axis2_status_t AXIS2_CALL
axis2_rest_sender_send(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_om_node_t *out, axis2_char_t *str_url);
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_om_node_t *out, axis2_char_t *str_url);
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_chunked(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_bool_t chunked);
+ const axis2_env_t *env, axis2_bool_t chunked);
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_om_output(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_om_output_t *om_output);
-
+ const axis2_env_t *env, axis2_om_output_t *om_output);
+
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_http_version(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_char_t *version);
+ const axis2_env_t *env, axis2_char_t *version);
axis2_status_t AXIS2_CALL
axis2_rest_sender_free(axis2_rest_sender_t *sender,
- const axis2_env_t *env);
+ const axis2_env_t *env);
/***************************** End of function headers ************************/
AXIS2_EXTERN axis2_rest_sender_t * AXIS2_CALL
@@ -93,29 +93,29 @@
sender_impl = (axis2_rest_sender_impl_t *)AXIS2_MALLOC
(env->allocator, sizeof(
axis2_rest_sender_impl_t));
-
+
if(NULL == sender_impl)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
- }
-
+ }
+
sender_impl->http_version = AXIS2_HTTP_HEADER_PROTOCOL_11;
sender_impl->so_timeout = AXIS2_HTTP_DEFAULT_SO_TIMEOUT;
sender_impl->connection_timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT;
- sender_impl->om_output = NULL;
- sender_impl->chunked = AXIS2_FALSE;
- sender_impl->client = NULL;
+ sender_impl->om_output = NULL;
+ sender_impl->chunked = AXIS2_FALSE;
+ sender_impl->client = NULL;
sender_impl->sender.ops = AXIS2_MALLOC(env->allocator,
sizeof(axis2_rest_sender_ops_t));
if(NULL == sender_impl->sender.ops)
- {
- axis2_rest_sender_free((axis2_rest_sender_t*)
- sender_impl, env);
+ {
+ axis2_rest_sender_free((axis2_rest_sender_t*)
+ sender_impl, env);
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
- }
+ }
sender_impl->sender.ops->send =
axis2_rest_sender_send;
@@ -123,11 +123,11 @@
axis2_rest_sender_set_chunked;
sender_impl->sender.ops->set_om_output =
axis2_rest_sender_set_om_output;
- sender_impl->sender.ops->set_http_version =
- axis2_rest_sender_set_http_version;
+ sender_impl->sender.ops->set_http_version =
+ axis2_rest_sender_set_http_version;
sender_impl->sender.ops->free =
axis2_rest_sender_free;
- return &(sender_impl->sender);
+ return &(sender_impl->sender);
}
axis2_status_t AXIS2_CALL
@@ -135,7 +135,7 @@
const axis2_env_t *env)
{
axis2_rest_sender_impl_t *sender_impl = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
sender_impl = AXIS2_INTF_TO_IMPL(sender);
if(NULL != sender_impl->http_version)
@@ -150,40 +150,40 @@
* of the response soap message
*/
sender_impl->client = NULL;
- AXIS2_FREE(env->allocator, sender_impl);
- return AXIS2_SUCCESS;
+ AXIS2_FREE(env->allocator, sender_impl);
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_rest_sender_send(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_om_node_t *out, axis2_char_t *str_url)
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_om_node_t *out, axis2_char_t *str_url)
{
- axis2_http_simple_request_t *request = NULL;
- axis2_http_request_line_t *request_line = NULL;
- axis2_url_t *url = NULL;
- axis2_rest_sender_impl_t *sender_impl = NULL;
- axis2_xml_writer_t *xml_writer = NULL;
- axis2_char_t *buffer = NULL;
- axis2_char_t *char_set_enc = NULL;
- int status_code = -1;
- axis2_http_header_t *http_header = NULL;
- axis2_http_simple_response_t *response = NULL;
- axis2_char_t *content_type = NULL;
+ axis2_http_simple_request_t *request = NULL;
+ axis2_http_request_line_t *request_line = NULL;
+ axis2_url_t *url = NULL;
+ axis2_rest_sender_impl_t *sender_impl = NULL;
+ axis2_xml_writer_t *xml_writer = NULL;
+ axis2_char_t *buffer = NULL;
+ axis2_char_t *char_set_enc = NULL;
+ int status_code = -1;
+ axis2_http_header_t *http_header = NULL;
+ axis2_http_simple_response_t *response = NULL;
+ axis2_char_t *content_type = NULL;
axis2_property_t *property = NULL;
-
+
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);
-
- url = axis2_url_parse_string(env, str_url);
- sender_impl = AXIS2_INTF_TO_IMPL(sender);
- if(NULL == url)
- {
- return 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);
+
+ url = axis2_url_parse_string(env, str_url);
+ sender_impl = AXIS2_INTF_TO_IMPL(sender);
+ if(NULL == url)
+ {
+ return AXIS2_FAILURE;
+ }
if (sender_impl->client)
{
@@ -191,11 +191,11 @@
sender_impl->client = NULL;
}
- sender_impl->client = axis2_http_client_create(env, url);
- if(NULL == sender_impl->client)
- {
- return AXIS2_FAILURE;
- }
+ sender_impl->client = axis2_http_client_create(env, url);
+ if(NULL == sender_impl->client)
+ {
+ return AXIS2_FAILURE;
+ }
/* We put the client into msg_ctx so that we can free it once the processing
* is done at client side
*/
@@ -207,30 +207,30 @@
AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_HTTP_CLIENT,
property, AXIS2_TRUE);
- if(NULL == sender_impl->om_output)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_OM_OUTPUT,
- AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
- xml_writer = AXIS2_OM_OUTPUT_GET_XML_WRITER(sender_impl->om_output, env);
-
- property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
+ if(NULL == sender_impl->om_output)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_OM_OUTPUT,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ xml_writer = AXIS2_OM_OUTPUT_GET_XML_WRITER(sender_impl->om_output, env);
+
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ AXIS2_CHARACTER_SET_ENCODING, AXIS2_FALSE);
if(property)
{
char_set_enc = AXIS2_PROPERTY_GET_VALUE(property, env);
property = NULL;
}
- if(NULL == char_set_enc)
- {
- char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
- }
- /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env,
- * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env);
- */
- AXIS2_OM_NODE_SERIALIZE (out, env, sender_impl->om_output);
- buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env);
+ if(NULL == char_set_enc)
+ {
+ char_set_enc = AXIS2_DEFAULT_CHAR_SET_ENCODING;
+ }
+ /* AXIS2_OM_OUTPUT_SET_DO_OPTIMIZE(om_output, env,
+ * AXIS2_MSG_CTX_GET_IS_DOING_MTOM(msg_ctx, env);
+ */
+ AXIS2_OM_NODE_SERIALIZE (out, env, sender_impl->om_output);
+ buffer = AXIS2_XML_WRITER_GET_XML(xml_writer, env);
if(NULL == buffer)
{
@@ -238,70 +238,70 @@
"from xml writer");
return AXIS2_FAILURE;
}
-
- request_line = axis2_http_request_line_create(env, "POST",
- AXIS2_URL_GET_PATH(url, env),
- sender_impl->http_version);
- request = axis2_http_simple_request_create(env, request_line, NULL, 0,
- NULL);
-
- http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_USER_AGENT,
- "Axis2/C");
- AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
- if(AXIS2_FALSE == sender_impl->chunked)
- {
- axis2_char_t tmp_buf[10];
- sprintf(tmp_buf, "%d", strlen(buffer));
- http_header = axis2_http_header_create(env,
- AXIS2_HTTP_HEADER_CONTENT_LENGTH, tmp_buf);
- AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
- }
- else
- {
- http_header = axis2_http_header_create(env,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
- AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
- }
- /* TODO we need to set the content type with soap action header for soap12*/
+
+ request_line = axis2_http_request_line_create(env, "POST",
+ AXIS2_URL_GET_PATH(url, env),
+ sender_impl->http_version);
+ request = axis2_http_simple_request_create(env, request_line, NULL, 0,
+ NULL);
+
+ http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_USER_AGENT,
+ "Axis2/C");
+ AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
+ if(AXIS2_FALSE == sender_impl->chunked)
+ {
+ axis2_char_t tmp_buf[10];
+ sprintf(tmp_buf, "%d", strlen(buffer));
+ http_header = axis2_http_header_create(env,
+ AXIS2_HTTP_HEADER_CONTENT_LENGTH, tmp_buf);
+ AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
+ }
+ else
+ {
+ http_header = axis2_http_header_create(env,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED);
+ AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
+ }
+ /* TODO we need to set the content type with soap action header for soap12*/
content_type = AXIS2_HTTP_HEADER_ACCEPT_TEXT_XML;
- http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE,
- content_type);
- AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
- if(0 == AXIS2_STRCMP(sender_impl->http_version,
- AXIS2_HTTP_HEADER_PROTOCOL_11))
- {
- axis2_char_t *header = NULL;
+ http_header = axis2_http_header_create(env, AXIS2_HTTP_HEADER_CONTENT_TYPE,
+ content_type);
+ AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
+ if(0 == AXIS2_STRCMP(sender_impl->http_version,
+ AXIS2_HTTP_HEADER_PROTOCOL_11))
+ {
+ axis2_char_t *header = NULL;
header = AXIS2_MALLOC(env->allocator, AXIS2_STRLEN(
AXIS2_URL_GET_SERVER(url, env)) + 10 * sizeof(
axis2_char_t));
sprintf(header, "%s:%d", AXIS2_URL_GET_SERVER(url, env),
AXIS2_URL_GET_PORT(url, env));
- http_header = axis2_http_header_create(env,
- AXIS2_HTTP_HEADER_HOST,
- header);
+ http_header = axis2_http_header_create(env,
+ AXIS2_HTTP_HEADER_HOST,
+ header);
AXIS2_FREE(env->allocator, header);
header = NULL;
- AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
- }
- AXIS2_HTTP_SIMPLE_REQUEST_SET_BODY_STRING(request, env, buffer);
- axis2_rest_sender_get_timeout_values(sender, env, msg_ctx);
- AXIS2_HTTP_CLIENT_SET_TIMEOUT(sender_impl->client, env,
- sender_impl->so_timeout);
-
- status_code = AXIS2_HTTP_CLIENT_SEND(sender_impl->client, env, request);
+ AXIS2_HTTP_SIMPLE_REQUEST_ADD_HEADER(request, env, http_header);
+ }
+ AXIS2_HTTP_SIMPLE_REQUEST_SET_BODY_STRING(request, env, buffer);
+ axis2_rest_sender_get_timeout_values(sender, env, msg_ctx);
+ AXIS2_HTTP_CLIENT_SET_TIMEOUT(sender_impl->client, env,
+ sender_impl->so_timeout);
+
+ status_code = AXIS2_HTTP_CLIENT_SEND(sender_impl->client, env, request);
AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
- AXIS2_HTTP_SIMPLE_REQUEST_FREE(request, env);
- request = NULL;
-
- status_code = AXIS2_HTTP_CLIENT_RECIEVE_HEADER(sender_impl->client, env);
+ AXIS2_HTTP_SIMPLE_REQUEST_FREE(request, env);
+ request = NULL;
+
+ status_code = AXIS2_HTTP_CLIENT_RECIEVE_HEADER(sender_impl->client, env);
if(status_code < 0)
- {
- return AXIS2_FAILURE;
- }
+ {
+ return AXIS2_FAILURE;
+ }
response = AXIS2_HTTP_CLIENT_GET_RESPONSE(sender_impl->client, env);
if(AXIS2_HTTP_RESPONSE_OK_CODE_VAL == status_code ||
AXIS2_HTTP_RESPONSE_ACK_CODE_VAL == status_code)
@@ -335,62 +335,62 @@
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_chunked(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_bool_t chunked)
+ const axis2_env_t *env, axis2_bool_t chunked)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_INTF_TO_IMPL(sender)->chunked = chunked;
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_om_output(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_om_output_t *om_output)
+ const axis2_env_t *env, axis2_om_output_t *om_output)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_INTF_TO_IMPL(sender)->om_output = om_output;
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_rest_sender_get_header_info(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_http_simple_response_t *response)
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
+ axis2_http_simple_response_t *response)
{
- axis2_array_list_t *headers = NULL;
- axis2_char_t *charset = NULL;
- axis2_rest_sender_impl_t *sender_impl = NULL;
- int i = 0;
- axis2_bool_t response_chunked = AXIS2_FALSE;
- int *content_length = NULL;
+ axis2_array_list_t *headers = NULL;
+ axis2_char_t *charset = NULL;
+ axis2_rest_sender_impl_t *sender_impl = NULL;
+ int i = 0;
+ axis2_bool_t response_chunked = AXIS2_FALSE;
+ int *content_length = NULL;
axis2_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);
-
- sender_impl = AXIS2_INTF_TO_IMPL(sender);
-
- /*
- * TODO MTOM support (MIME header)
- */
- headers = AXIS2_HTTP_SIMPLE_RESPONSE_GET_HEADERS(response, env);
- if(headers == NULL)
- {
- return AXIS2_SUCCESS;
- }
- for(i = 0; i < AXIS2_ARRAY_LIST_SIZE(headers, env); i++)
- {
- axis2_http_header_t *header = AXIS2_ARRAY_LIST_GET(headers, env, i);
- axis2_char_t *name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *)
- header, env);
- if(NULL != name)
- {
- if(0 == AXIS2_STRCMP(name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING) &&
- 0 == AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_VALUE(header
- , env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
- {
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE);
+
+ sender_impl = AXIS2_INTF_TO_IMPL(sender);
+
+ /*
+ * TODO MTOM support (MIME header)
+ */
+ headers = AXIS2_HTTP_SIMPLE_RESPONSE_GET_HEADERS(response, env);
+ if(headers == NULL)
+ {
+ return AXIS2_SUCCESS;
+ }
+ for(i = 0; i < AXIS2_ARRAY_LIST_SIZE(headers, env); i++)
+ {
+ axis2_http_header_t *header = AXIS2_ARRAY_LIST_GET(headers, env, i);
+ axis2_char_t *name = AXIS2_HTTP_HEADER_GET_NAME((axis2_http_header_t *)
+ header, env);
+ if(NULL != name)
+ {
+ if(0 == AXIS2_STRCMP(name, AXIS2_HTTP_HEADER_TRANSFER_ENCODING) &&
+ 0 == AXIS2_STRCMP(AXIS2_HTTP_HEADER_GET_VALUE(header
+ , env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
+ {
axis2_char_t *transfer_encoding = NULL;
transfer_encoding =
@@ -399,91 +399,91 @@
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, transfer_encoding);
- AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
- AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
- property,
- AXIS2_FALSE);
- response_chunked = AXIS2_TRUE;
- }
- if(0 != AXIS2_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(NULL != charset)
- {
- charset = AXIS2_STRDUP(tmp_charset, env);
- break;
- }
- }
- }
- }
- if(NULL != charset)
- {
- axis2_ctx_t *axis_ctx = AXIS2_OP_CTX_GET_BASE(AXIS2_MSG_CTX_GET_OP_CTX(
- msg_ctx, env), env);
- if(NULL != axis_ctx)
- {
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ AXIS2_HTTP_HEADER_TRANSFER_ENCODING,
+ property,
+ AXIS2_FALSE);
+ response_chunked = AXIS2_TRUE;
+ }
+ if(0 != AXIS2_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(NULL != charset)
+ {
+ charset = AXIS2_STRDUP(tmp_charset, env);
+ break;
+ }
+ }
+ }
+ }
+ if(NULL != charset)
+ {
+ axis2_ctx_t *axis_ctx = AXIS2_OP_CTX_GET_BASE(AXIS2_MSG_CTX_GET_OP_CTX(
+ msg_ctx, env), env);
+ if(NULL != axis_ctx)
+ {
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, charset);
- AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING,
- property, AXIS2_FALSE);
- }
- }
- if(AXIS2_FALSE == response_chunked)
- {
- int tmp_len = 0;
- content_length = AXIS2_MALLOC(env->allocator, sizeof(int));
- if(NULL == content_length)
- {
- return AXIS2_FAILURE;
- }
- tmp_len = AXIS2_HTTP_SIMPLE_RESPONSE_GET_CONTENT_LENGTH(response, env);
- memcpy(content_length, &tmp_len, sizeof(int));
+ AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_CHARACTER_SET_ENCODING,
+ property, AXIS2_FALSE);
+ }
+ }
+ if(AXIS2_FALSE == response_chunked)
+ {
+ int tmp_len = 0;
+ content_length = AXIS2_MALLOC(env->allocator, sizeof(int));
+ if(NULL == content_length)
+ {
+ return AXIS2_FAILURE;
+ }
+ tmp_len = AXIS2_HTTP_SIMPLE_RESPONSE_GET_CONTENT_LENGTH(response, env);
+ memcpy(content_length, &tmp_len, sizeof(int));
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, content_length);
- AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
- AXIS2_HTTP_HEADER_CONTENT_LENGTH, property,
- AXIS2_FALSE);
- }
- return AXIS2_SUCCESS;
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ AXIS2_HTTP_HEADER_CONTENT_LENGTH, property,
+ AXIS2_FALSE);
+ }
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_rest_sender_process_response(axis2_rest_sender_t *sender,
const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx,
- axis2_http_simple_response_t *response)
+ axis2_http_simple_response_t *response)
{
axis2_stream_t *in_stream = NULL;
axis2_property_t *property = NULL;
-
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ 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(NULL == in_stream)
- {
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY,
- AXIS2_FAILURE);
- return AXIS2_FAILURE;
- }
-
- axis2_rest_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);*/
+ AXIS2_PARAM_CHECK(env->error, response, AXIS2_FAILURE);
+
+ in_stream = AXIS2_HTTP_SIMPLE_RESPONSE_GET_BODY(response, env);
+ if(NULL == in_stream)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NULL_STREAM_IN_RESPONSE_BODY,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ axis2_rest_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 = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_FREE_FUNC(property, env, axis2_stream_free_void_arg);
AXIS2_PROPERTY_SET_VALUE(property, env, in_stream);
- /*AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_TRANSPORT_IN, property,
- AXIS2_FALSE);*/
- AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_IN, property,
- AXIS2_FALSE);
- return AXIS2_SUCCESS;
+ /*AXIS2_CTX_SET_PROPERTY(axis_ctx, env, AXIS2_TRANSPORT_IN, property,
+ AXIS2_FALSE);*/
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_IN, property,
+ AXIS2_FALSE);
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
@@ -491,15 +491,15 @@
const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
{
axis2_char_t *so_str = NULL;
- axis2_char_t *connection_str = NULL;
+ axis2_char_t *connection_str = NULL;
axis2_param_t *tmp_param = NULL;
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-
-
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+
tmp_param = AXIS2_MSG_CTX_GET_PARAMETER(msg_ctx,
- env, AXIS2_HTTP_SO_TIMEOUT);
-
+ env, AXIS2_HTTP_SO_TIMEOUT);
+
if(NULL != tmp_param)
{
so_str = (axis2_char_t*)AXIS2_PARAM_GET_VALUE(tmp_param, env);
@@ -519,18 +519,18 @@
AXIS2_ATOI(connection_str);
}
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_rest_sender_set_http_version(axis2_rest_sender_t *sender,
- const axis2_env_t *env, axis2_char_t *version)
+ const axis2_env_t *env, axis2_char_t *version)
{
- AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_INTF_TO_IMPL(sender)->http_version = AXIS2_STRDUP(version, env);
- if(NULL == AXIS2_INTF_TO_IMPL(sender)->http_version)
- {
- return AXIS2_FAILURE;
- }
- return AXIS2_SUCCESS;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_INTF_TO_IMPL(sender)->http_version = AXIS2_STRDUP(version, env);
+ if(NULL == AXIS2_INTF_TO_IMPL(sender)->http_version)
+ {
+ return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org