axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject 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/...
Date Sun, 04 Jun 2006 03:09:41 GMT
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


Mime
View raw message