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