You are viewing a plain text version of this content. The canonical link for it is here.
Posted to axis-cvs@ws.apache.org by sa...@apache.org on 2007/09/28 11:53:04 UTC

svn commit: r580276 [18/26] - in /webservices/axis2/trunk/c/src: core/addr/ core/clientapi/ core/context/ core/deployment/ core/description/ core/engine/ core/phaseresolver/ core/receivers/ core/transport/ core/transport/http/common/ core/transport/htt...

Modified: webservices/axis2/trunk/c/src/core/transport/http/sender/http_client.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/src/core/transport/http/sender/http_client.c?rev=580276&r1=580275&r2=580276&view=diff
==============================================================================
--- webservices/axis2/trunk/c/src/core/transport/http/sender/http_client.c (original)
+++ webservices/axis2/trunk/c/src/core/transport/http/sender/http_client.c Fri Sep 28 02:52:58 2007
@@ -44,22 +44,22 @@
     int proxy_port;
     axis2_char_t *proxy_host_port;
     axis2_bool_t dump_input_msg;
-	axis2_char_t *server_cert;
+    axis2_char_t *server_cert;
     axis2_char_t *key_file;
     axis2_char_t *req_body;
-    int req_body_size;  
+    int req_body_size;
 };
 
 AXIS2_EXTERN axis2_http_client_t *AXIS2_CALL
 axis2_http_client_create(
-    const axutil_env_t *env,
-    axutil_url_t *url)
+    const axutil_env_t * env,
+    axutil_url_t * url)
 {
     axis2_http_client_t *http_client = NULL;
     AXIS2_ENV_CHECK(env, NULL);
 
-    http_client = (axis2_http_client_t *)AXIS2_MALLOC
-            (env->allocator, sizeof(axis2_http_client_t));
+    http_client = (axis2_http_client_t *) AXIS2_MALLOC
+        (env->allocator, sizeof(axis2_http_client_t));
 
     if (!http_client)
     {
@@ -86,11 +86,10 @@
     return http_client;
 }
 
-
 AXIS2_EXTERN void AXIS2_CALL
 axis2_http_client_free(
-    axis2_http_client_t *http_client,
-    const axutil_env_t *env)
+    axis2_http_client_t * http_client,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, void);
 
@@ -107,7 +106,7 @@
         axutil_network_handler_close_socket(env, http_client->sockfd);
         http_client->sockfd = -1;
     }
-    
+
     if (http_client->req_body)
     {
         AXIS2_FREE(env->allocator, http_client->req_body);
@@ -120,47 +119,45 @@
 AXIS2_EXTERN void AXIS2_CALL
 axis2_http_client_free_void_arg(
     void *client,
-    const axutil_env_t *env)
+    const axutil_env_t * env)
 {
     axis2_http_client_t *client_l = NULL;
     AXIS2_ENV_CHECK(env, void);
-    
-    client_l = (axis2_http_client_t *)client;
+
+    client_l = (axis2_http_client_t *) client;
     axis2_http_client_free(client_l, env);
     return;
 }
 
-
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_send(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axis2_http_simple_request_t *request,
-    axis2_char_t *ssl_pp
-    )
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axis2_http_simple_request_t * request,
+    axis2_char_t * ssl_pp)
 {
     char *wire_format = NULL;
     axutil_array_list_t *headers = NULL;
     char *str_header = NULL;
-    /*char *str_body = NULL;*/
+    /*char *str_body = NULL; */
     char *str_request_line = NULL;
-    /*int body_size = 0;*/
+    /*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);
 
     /*body_size = axis2_http_simple_request_get_body_bytes(request, env,
-            &str_body);*/
+       &str_body); */
     if (!client->req_body)
     {
-        client->req_body_size = axis2_http_simple_request_get_body_bytes(
-                request, env, &client->req_body);
+        client->req_body_size =
+            axis2_http_simple_request_get_body_bytes(request, env,
+                                                     &client->req_body);
     }
 
-    if(client->dump_input_msg == AXIS2_TRUE)
+    if (client->dump_input_msg == AXIS2_TRUE)
     {
         return AXIS2_SUCCESS;
     }
@@ -177,21 +174,24 @@
             return AXIS2_FAILURE;
         }
         client->sockfd = axutil_network_handler_open_socket(env,
-                client->proxy_host, client->proxy_port);
+                                                            client->proxy_host,
+                                                            client->proxy_port);
     }
     else
     {
         client->sockfd = axutil_network_handler_open_socket(env,
-                axutil_url_get_server(client->url, env),
-                axutil_url_get_port(client->url, env));
+                                                            axutil_url_get_server
+                                                            (client->url, env),
+                                                            axutil_url_get_port
+                                                            (client->url, env));
     }
     if (client->sockfd < 0)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
         /*if (str_body)
-        {
-            AXIS2_FREE(env->allocator, str_body);
-        }*/
+           {
+           AXIS2_FREE(env->allocator, str_body);
+           } */
         return AXIS2_FAILURE;
     }
     /* ONLY FOR TESTING
@@ -201,38 +201,42 @@
     if (client->timeout > 0)
     {
         axutil_network_handler_set_sock_option(env, client->sockfd,
-                SO_RCVTIMEO, client->timeout);
+                                               SO_RCVTIMEO, client->timeout);
         axutil_network_handler_set_sock_option(env, client->sockfd,
-                SO_SNDTIMEO, client->timeout);
+                                               SO_SNDTIMEO, client->timeout);
     }
     if (0 == axutil_strcasecmp(axutil_url_get_protocol(client->url, env),
-            "HTTPS"))
+                               "HTTPS"))
     {
 #ifdef AXIS2_SSL_ENABLED
         if (AXIS2_TRUE == client->proxy_enabled)
         {
             if (AXIS2_SUCCESS != axis2_http_client_connect_ssl_host(client, env,
-                    axutil_url_get_server(client->url, env),
-                    axutil_url_get_port(client->url, env)))
+                                                                    axutil_url_get_server
+                                                                    (client->
+                                                                     url, env),
+                                                                    axutil_url_get_port
+                                                                    (client->
+                                                                     url, env)))
             {
                 return AXIS2_FAILURE;
             }
         }
         client->data_stream = axutil_stream_create_ssl(env,
-                client->sockfd, 
-                axis2_http_client_get_server_cert(client, env),
-                axis2_http_client_get_key_file(client, env),
-                ssl_pp);
+                                                       client->sockfd,
+                                                       axis2_http_client_get_server_cert
+                                                       (client, env),
+                                                       axis2_http_client_get_key_file
+                                                       (client, env), ssl_pp);
 #else
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_TRANSPORT_PROTOCOL,
-                AXIS2_FAILURE);
+                        AXIS2_FAILURE);
         return AXIS2_FAILURE;
 #endif
     }
     else
     {
-        client->data_stream = axutil_stream_create_socket(env,
-                client->sockfd);
+        client->data_stream = axutil_stream_create_socket(env, client->sockfd);
     }
 
     if (!client->data_stream)
@@ -251,7 +255,7 @@
         {
             axis2_char_t *header_ext_form = NULL;
             axis2_http_header_t *tmp_header = (axis2_http_header_t *)
-                    axutil_array_list_get(headers, env, i);
+                axutil_array_list_get(headers, env, i);
             if (!tmp_header)
             {
                 continue;
@@ -259,14 +263,15 @@
             /* check whether we have transfer encoding and then see whether the
              * value is "chunked" */
             if (0 == axutil_strcmp(axis2_http_header_get_name(tmp_header, env),
-                    AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && 0 ==
-                    axutil_strcmp(axis2_http_header_get_value(tmp_header,
-                            env), AXIS2_HTTP_HEADER_TRANSFER_ENCODING_CHUNKED))
+                                   AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && 0 ==
+                axutil_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);
+            header_ext_form =
+                axis2_http_header_to_external_form(tmp_header, env);
             str_header2 = axutil_stracat(env, str_header, header_ext_form);
             AXIS2_FREE(env->allocator, str_header);
             str_header = NULL;
@@ -277,9 +282,9 @@
     }
     if (AXIS2_FALSE == client->proxy_enabled)
     {
-        str_request_line = axis2_http_request_line_to_string(
-                    axis2_http_simple_request_get_request_line(request, env)
-                    , env);
+        str_request_line =
+            axis2_http_request_line_to_string
+            (axis2_http_simple_request_get_request_line(request, env), env);
     }
     else
     {
@@ -292,23 +297,25 @@
             axis2_http_simple_request_get_request_line(request, env);
         axis2_char_t *path = axis2_http_request_line_get_uri(request_line, env);
 
-
-        /* length = len(server) + len(:port) + len("http://") + len(path) + 1*/
+        /* length = len(server) + len(:port) + len("http://") + len(path) + 1 */
         host_port_str = AXIS2_MALLOC(env->allocator, axutil_strlen(server) +
-                + axutil_strlen(path) +  20 * sizeof(axis2_char_t));
+                                     +axutil_strlen(path) +
+                                     20 * sizeof(axis2_char_t));
         if (!host_port_str)
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
             return AXIS2_FAILURE;
         }
-        sprintf(host_port_str, "http://%s:%d%s", server, axutil_url_get_port(
-                    client->url, env), path);
-        str_request_line = AXIS2_MALLOC(env->allocator,
-                axutil_strlen(host_port_str) + 20 * sizeof(axis2_char_t));
+        sprintf(host_port_str, "http://%s:%d%s", server,
+                axutil_url_get_port(client->url, env), path);
+        str_request_line =
+            AXIS2_MALLOC(env->allocator,
+                         axutil_strlen(host_port_str) +
+                         20 * sizeof(axis2_char_t));
         sprintf(str_request_line, "%s %s %s\r\n",
                 axis2_http_request_line_get_method(request_line, env),
-                host_port_str, axis2_http_request_line_get_http_version(
-                    request_line, env));
+                host_port_str,
+                axis2_http_request_line_get_http_version(request_line, env));
         AXIS2_FREE(env->allocator, host_port_str);
         host_port_str = NULL;
 
@@ -319,13 +326,12 @@
     AXIS2_FREE(env->allocator, str_request_line);
     str_request_line = NULL;
     written = axutil_stream_write(client->data_stream, env, wire_format,
-            axutil_strlen(wire_format));
+                                  axutil_strlen(wire_format));
     AXIS2_FREE(env->allocator, wire_format);
     wire_format = NULL;
-    written = axutil_stream_write(client->data_stream, env, AXIS2_HTTP_CRLF,
-            2);
-    /*if (body_size > 0 &&  str_body)*/
-    if (client->req_body_size > 0 &&  client->req_body)
+    written = axutil_stream_write(client->data_stream, env, AXIS2_HTTP_CRLF, 2);
+    /*if (body_size > 0 &&  str_body) */
+    if (client->req_body_size > 0 && client->req_body)
     {
         if (AXIS2_FALSE == chunking_enabled)
         {
@@ -333,9 +339,10 @@
             while (written < client->req_body_size)
             {
                 /*written = axutil_stream_write(client->data_stream, env,
-                        str_body, body_size);*/
+                   str_body, body_size); */
                 written = axutil_stream_write(client->data_stream, env,
-                        client->req_body, client->req_body_size);
+                                              client->req_body,
+                                              client->req_body_size);
                 if (-1 == written)
                 {
                     status = AXIS2_FAILURE;
@@ -347,20 +354,23 @@
         {
             axis2_http_chunked_stream_t *chunked_stream = NULL;
             chunked_stream = axis2_http_chunked_stream_create(env,
-                    client->data_stream);
+                                                              client->
+                                                              data_stream);
             status = AXIS2_SUCCESS;
             if (!chunked_stream)
             {
                 AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked"
-                        "stream failed");
+                                "stream failed");
                 return AXIS2_FAILURE;
             }
             while (written < client->req_body_size)
             {
                 /*written = axis2_http_chunked_stream_write(chunked_stream, env,
-                        str_body, body_size);*/
+                   str_body, body_size); */
                 written = axis2_http_chunked_stream_write(chunked_stream, env,
-                        client->req_body, client->req_body_size);
+                                                          client->req_body,
+                                                          client->
+                                                          req_body_size);
                 if (-1 == written)
                 {
                     status = AXIS2_FAILURE;
@@ -377,18 +387,17 @@
 
     client->request_sent = AXIS2_TRUE;
     /*if (str_body)
-    {
-        AXIS2_FREE(env->allocator, str_body);
-        str_body = NULL;
-    }*/
+       {
+       AXIS2_FREE(env->allocator, str_body);
+       str_body = NULL;
+       } */
     return status;
 }
 
-
 AXIS2_EXTERN int AXIS2_CALL
 axis2_http_client_recieve_header(
-    axis2_http_client_t *client,
-    const axutil_env_t *env)
+    axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
     int status_code = -1;
     axis2_http_status_line_t *status_line = NULL;
@@ -403,11 +412,12 @@
     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
 
     if (-1 == client->sockfd || !client->data_stream ||
-            AXIS2_FALSE == client->request_sent)
+        AXIS2_FALSE == client->request_sent)
     {
-		AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[axis2c] client data stream  null or socket error");
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                        "[axis2c] client data stream  null or socket error");
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_HTTP_REQUEST_NOT_SENT,
-                AXIS2_FAILURE);
+                        AXIS2_FAILURE);
         return -1;
     }
     /* read the status line */
@@ -415,7 +425,7 @@
     {
         memset(str_status_line, 0, 512);
         while ((read = axutil_stream_read(client->data_stream, env, tmp_buf,
-                1)) > 0)
+                                          1)) > 0)
         {
             tmp_buf[read] = '\0';
             strcat(str_status_line, tmp_buf);
@@ -428,27 +438,28 @@
 
         if (read < 0)
         {
-			AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[axis2c] http client , response timed out");
-            AXIS2_ERROR_SET(env->error,
-                    AXIS2_ERROR_RESPONSE_TIMED_OUT,
-                    AXIS2_FAILURE);
+            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI,
+                            "[axis2c] http client , response timed out");
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RESPONSE_TIMED_OUT,
+                            AXIS2_FAILURE);
             return -1;
         }
-		else if (read == 0)
-		{
-			AXIS2_ERROR_SET(env->error,
-							AXIS2_ERROR_RESPONSE_SERVER_SHUTDOWN,
-							AXIS2_FAILURE);
-			AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response error, Server Shutdown");
-			return 0;
-		}
+        else if (read == 0)
+        {
+            AXIS2_ERROR_SET(env->error,
+                            AXIS2_ERROR_RESPONSE_SERVER_SHUTDOWN,
+                            AXIS2_FAILURE);
+            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                            "Response error, Server Shutdown");
+            return 0;
+        }
         status_line = axis2_http_status_line_create(env, str_status_line);
         if (!status_line)
         {
             AXIS2_ERROR_SET(env->error,
-                    AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE,
-                    AXIS2_FAILURE);
-            /*return -1;*/
+                            AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE,
+                            AXIS2_FAILURE);
+            /*return -1; */
             http_status = 0;
             continue;
 
@@ -459,11 +470,12 @@
 
     client->response = axis2_http_simple_response_create_default(env);
     axis2_http_simple_response_set_status_line(client->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));
+                                               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);
@@ -471,7 +483,7 @@
     while (AXIS2_FALSE == end_of_headers)
     {
         while ((read = axutil_stream_read(client->data_stream, env, tmp_buf,
-                1)) > 0)
+                                          1)) > 0)
         {
             tmp_buf[read] = '\0';
             strcat(str_header, tmp_buf);
@@ -495,40 +507,40 @@
                 if (tmp_header)
                 {
                     axis2_http_simple_response_set_header(client->response,
-                            env, tmp_header);
+                                                          env, tmp_header);
                 }
             }
         }
         end_of_line = AXIS2_FALSE;
     }
     axis2_http_simple_response_set_body_stream(client->response, env,
-            client->data_stream);
+                                               client->data_stream);
     if (status_line)
     {
         status_code = axis2_http_status_line_get_status_code(status_line, env);
         axis2_http_status_line_free(status_line, env);
         status_line = NULL;
     }
-    if (AXIS2_FALSE == axis2_http_simple_response_contains_header(
-                client->response, env,
-                AXIS2_HTTP_HEADER_CONTENT_TYPE) && 202 != status_code
-            && axis2_http_simple_response_get_content_length(
-                client->response, env) > 0)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RESPONSE_CONTENT_TYPE_MISSING
-                , AXIS2_FAILURE);
-        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Response does not contain"
-                " Content-Type");
+    if (AXIS2_FALSE ==
+        axis2_http_simple_response_contains_header(client->response, env,
+                                                   AXIS2_HTTP_HEADER_CONTENT_TYPE)
+        && 202 != status_code &&
+        axis2_http_simple_response_get_content_length(client->response,
+                                                      env) > 0)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_RESPONSE_CONTENT_TYPE_MISSING,
+                        AXIS2_FAILURE);
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
+                        "Response does not contain" " Content-Type");
         return -1;
     }
     return status_code;
 }
 
-
 AXIS2_EXTERN axis2_http_simple_response_t *AXIS2_CALL
 axis2_http_client_get_response(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return client->response;
@@ -536,9 +548,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_url(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axutil_url_t *url)
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axutil_url_t * url)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, url, AXIS2_FAILURE);
@@ -553,8 +565,8 @@
 
 AXIS2_EXTERN axutil_url_t *AXIS2_CALL
 axis2_http_client_get_url(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return client->url;
@@ -562,8 +574,8 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_timeout(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
     int timeout_ms)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -573,8 +585,8 @@
 
 AXIS2_EXTERN int AXIS2_CALL
 axis2_http_client_get_timeout(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
     return client->timeout;
@@ -582,9 +594,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_proxy(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axis2_char_t *proxy_host,
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axis2_char_t * proxy_host,
     int proxy_port)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -609,8 +621,9 @@
     {
         return AXIS2_FAILURE;
     }
-    client->proxy_host_port = AXIS2_MALLOC(env->allocator, axutil_strlen(
-                proxy_host) + 10 * sizeof(axis2_char_t));
+    client->proxy_host_port =
+        AXIS2_MALLOC(env->allocator,
+                     axutil_strlen(proxy_host) + 10 * sizeof(axis2_char_t));
     sprintf(client->proxy_host_port, "%s:%d", proxy_host, proxy_port);
     client->proxy_enabled = AXIS2_TRUE;
     return AXIS2_SUCCESS;
@@ -618,8 +631,8 @@
 
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 axis2_http_client_get_proxy(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
     AXIS2_ENV_CHECK(env, NULL);
     return client->proxy_host_port;
@@ -627,9 +640,9 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_connect_ssl_host(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axis2_char_t *host,
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axis2_char_t * host,
     int port)
 {
     axutil_stream_t *tmp_stream = NULL;
@@ -655,11 +668,11 @@
         return AXIS2_FAILURE;
     }
     connect_string = AXIS2_MALLOC(env->allocator,
-            axutil_strlen(host) * sizeof(axis2_char_t) +
-            30 * sizeof(axis2_char_t));
+                                  axutil_strlen(host) * sizeof(axis2_char_t) +
+                                  30 * sizeof(axis2_char_t));
     sprintf(connect_string, "CONNECT %s:%d HTTP/1.0\r\n\r\n", host, port);
     axutil_stream_write(tmp_stream, env, connect_string,
-            axutil_strlen(connect_string) * sizeof(axis2_char_t));
+                        axutil_strlen(connect_string) * sizeof(axis2_char_t));
 
     memset(str_status_line, 0, 512);
     while ((read = axutil_stream_read(tmp_stream, env, tmp_buf, 1)) > 0)
@@ -675,16 +688,15 @@
     if (read < 0)
     {
         AXIS2_ERROR_SET(env->error,
-                AXIS2_ERROR_RESPONSE_TIMED_OUT,
-                AXIS2_FAILURE);
+                        AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     status_line = axis2_http_status_line_create(env, str_status_line);
     if (!status_line)
     {
         AXIS2_ERROR_SET(env->error,
-                AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE,
-                AXIS2_FAILURE);
+                        AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE,
+                        AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     if (200 != axis2_http_status_line_get_status_code(status_line, env))
@@ -720,8 +732,8 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_dump_input_msg(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
     axis2_bool_t dump_input_msg)
 {
     client->dump_input_msg = dump_input_msg;
@@ -731,41 +743,40 @@
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_server_cert(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axis2_char_t *server_cert)
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axis2_char_t * server_cert)
 {
-   client->server_cert = server_cert;
+    client->server_cert = server_cert;
 
-   return AXIS2_SUCCESS;
+    return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 axis2_http_client_get_server_cert(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
-   AXIS2_ENV_CHECK(env, NULL);
-   return client->server_cert;
+    AXIS2_ENV_CHECK(env, NULL);
+    return client->server_cert;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_http_client_set_key_file(
-    axis2_http_client_t *client,
-    const axutil_env_t *env,
-    axis2_char_t *key_file)
+    axis2_http_client_t * client,
+    const axutil_env_t * env,
+    axis2_char_t * key_file)
 {
-   client->key_file = key_file;
+    client->key_file = key_file;
 
-   return AXIS2_SUCCESS;
+    return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 axis2_http_client_get_key_file(
-    const axis2_http_client_t *client,
-    const axutil_env_t *env)
+    const axis2_http_client_t * client,
+    const axutil_env_t * env)
 {
-   AXIS2_ENV_CHECK(env, NULL);
-   return client->key_file;
+    AXIS2_ENV_CHECK(env, NULL);
+    return client->key_file;
 }
-



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org