diff options
Diffstat (limited to 'src/core/transport/http/sender/http_client.c')
| -rw-r--r-- | src/core/transport/http/sender/http_client.c | 965 |
1 files changed, 965 insertions, 0 deletions
diff --git a/src/core/transport/http/sender/http_client.c b/src/core/transport/http/sender/http_client.c new file mode 100644 index 0000000..80e7ee3 --- /dev/null +++ b/src/core/transport/http/sender/http_client.c @@ -0,0 +1,965 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <axis2_http_client.h> +#include <axis2_http_transport.h> +#include <axutil_stream.h> +#include <axutil_string.h> +#include <axutil_network_handler.h> +#include <axis2_http_request_line.h> +#include <axis2_http_header.h> +#include <axis2_http_status_line.h> +#include <axutil_http_chunked_stream.h> +#include <platforms/axutil_platform_auto_sense.h> +#include <axiom_mime_part.h> +#include <axis2_http_transport_utils.h> + +#ifdef AXIS2_SSL_ENABLED +#include "ssl/ssl_stream.h" +#endif + +struct axis2_http_client +{ + int sockfd; + axutil_stream_t *data_stream; + axutil_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; + axis2_char_t *proxy_host_port; + axis2_bool_t dump_input_msg; + axis2_char_t *server_cert; + axis2_char_t *key_file; + axis2_char_t *req_body; + int req_body_size; + + /* These are for mtom case */ + axutil_array_list_t *mime_parts; + axis2_bool_t doing_mtom; + axis2_char_t *mtom_sending_callback_name; +}; + +AXIS2_EXTERN axis2_http_client_t *AXIS2_CALL +axis2_http_client_create( + const axutil_env_t * env, + axutil_url_t * url) +{ + axis2_http_client_t *http_client = NULL; + + http_client = (axis2_http_client_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_http_client_t)); + + if(!http_client) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset(http_client, 0, sizeof(axis2_http_client_t)); + + http_client->url = url; + http_client->data_stream = NULL; + http_client->sockfd = -1; + http_client->response = NULL; + http_client->request_sent = AXIS2_FALSE; + + /* default timeout is 60000 milliseconds */ + http_client->timeout = AXIS2_HTTP_DEFAULT_CONNECTION_TIMEOUT; + http_client->proxy_enabled = AXIS2_FALSE; + http_client->proxy_port = 0; + http_client->proxy_host = NULL; + http_client->proxy_host_port = NULL; + http_client->dump_input_msg = AXIS2_FALSE; + http_client->server_cert = NULL; + http_client->key_file = NULL; + http_client->req_body = NULL; + http_client->req_body_size = 0; + http_client->mime_parts = NULL; + http_client->doing_mtom = AXIS2_FALSE; + http_client->mtom_sending_callback_name = NULL; + + return http_client; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_client_free( + axis2_http_client_t * http_client, + const axutil_env_t * env) +{ + if(http_client->proxy_host) + { + AXIS2_FREE(env->allocator, http_client->proxy_host); + } + if(http_client->proxy_host_port) + { + AXIS2_FREE(env->allocator, http_client->proxy_host_port); + } + if(http_client->url) + { + axutil_url_free(http_client->url, env); + } + if(http_client->response) + { + axis2_http_simple_response_free(http_client->response, env); + } + if(-1 != http_client->sockfd) + { + 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); + } + + /* There is no other appropriate place to free the mime_part list when a + * particular client send requests. */ + + if(http_client->mime_parts) + { + int i = 0; + for(i = 0; i < axutil_array_list_size(http_client->mime_parts, env); i++) + { + axiom_mime_part_t *mime_part = NULL; + mime_part = (axiom_mime_part_t *)axutil_array_list_get(http_client->mime_parts, env, i); + if(mime_part) + { + axiom_mime_part_free(mime_part, env); + } + } + axutil_array_list_free(http_client->mime_parts, env); + } + + AXIS2_FREE(env->allocator, http_client); + return; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_http_client_free_void_arg( + void *client, + const axutil_env_t * env) +{ + axis2_http_client_t *client_l = NULL; + + client_l = (axis2_http_client_t *)client; + axis2_http_client_free(client_l, env); + return; +} + +/* This is the main method which writes to the socket in the case of a client + * sends an http_request. Previously this method does not distinguish between a + * mtom request and non mtom request. Because what finally it had was the + * complete buffer with the request. But now MTOM invocations are done + * differently in order to support large attachments so this method should + * distinguish those invocations */ + +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) +{ + char *wire_format = NULL; + axutil_array_list_t *headers = NULL; + char *str_header = NULL; + char *str_request_line = NULL; + int written = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t chunking_enabled = AXIS2_FALSE; + axis2_char_t *host = NULL; + unsigned int port = 0; + + /* In the MTOM case request body is not set. Instead mime_parts + array_list is there */ + + if(client->req_body) + { + AXIS2_FREE(env->allocator, client->req_body); + client->req_body = NULL; + } + if(!client->req_body && !(client->doing_mtom)) + { + client->req_body_size = axis2_http_simple_request_get_body_bytes(request, env, + &client->req_body); + } + + if(client->dump_input_msg == AXIS2_TRUE) + { + return AXIS2_SUCCESS; + } + + if(!client->url) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NULL_URL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Request url not set"); + return AXIS2_FAILURE; + } + + host = axutil_url_get_host(client->url, env); + port = axutil_url_get_port(client->url, env); + + if(client->proxy_enabled) + { + if(!client->proxy_host || client->proxy_port <= 0) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Proxy port or Host not set"); + return AXIS2_FAILURE; + } + + if(client->sockfd < 0) + { + client->sockfd = (int)axutil_network_handler_open_socket(env, client->proxy_host, + client->proxy_port); + } + } + else + { + /*Proxy is not enabled*/ + + if(client->sockfd < 0) + { + client->sockfd = (int)axutil_network_handler_open_socket(env, host, port); + } + } + + if(client->sockfd < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Socket Creation failed."); + return AXIS2_FAILURE; + } + + if(client->timeout > 0) + { + /*Set the receiving time out*/ + axutil_network_handler_set_sock_option(env, client->sockfd, SO_RCVTIMEO, client->timeout); + /*Set the sending time out*/ + + axutil_network_handler_set_sock_option(env, client->sockfd, SO_SNDTIMEO, client->timeout); + } + + if(0 == axutil_strcasecmp(axutil_url_get_protocol(client->url, env), AXIS2_TRANSPORT_URL_HTTPS)) + { +#ifdef AXIS2_SSL_ENABLED + if (client->proxy_enabled) + { + if (AXIS2_SUCCESS != axis2_http_client_connect_ssl_host(client, env, host, port)) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "HTTPS connection creation failed"); + 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); +#else + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_TRANSPORT_PROTOCOL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Invalid Transport Protocol, HTTPS transport not enabled."); + + return AXIS2_FAILURE; +#endif + } + else + { + client->data_stream = axutil_stream_create_socket(env, client->sockfd); + } + + if(!client->data_stream) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Data stream creation failed for Host %s and %d port", host, port); + + return AXIS2_FAILURE; + } + + /*Accessing HTTP headers*/ + + headers = axis2_http_simple_request_get_headers(request, env); + if(headers) + { + int header_count = axutil_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 *)axutil_array_list_get(headers, + env, i); + + if(!tmp_header) + { + /* This continue is added as a safey mechanism, + * However I see a problem with this logic, AFAIC + * see there can't be null headers in the headers + * array list, because number of headers in "headers" + * array list count with axutil_array_list_size, + * therefore this check and continue might not have a + * real effect.*/ + + continue; + } + + /* check whether we have transfer encoding and then see whether the + * value is "chunked" */ + if(!axutil_strcmp(axis2_http_header_get_name(tmp_header, env), + AXIS2_HTTP_HEADER_TRANSFER_ENCODING) && !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); + + /* str_header2 is to hold intermediate value of str_header */ + str_header2 = axutil_stracat(env, str_header, header_ext_form); + if(str_header) + { + AXIS2_FREE(env->allocator, str_header); + str_header = NULL; + } + if(header_ext_form) + { + AXIS2_FREE(env->allocator, header_ext_form); + header_ext_form = NULL; + } + + /* str_header has all HTTP headers to send. */ + str_header = str_header2; + } + } + + 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); + } + else + { + /* proxy enabled case */ + + /* we need the request line in the format + * POST http://host:port/path HTTP/1.x if we have enabled proxies + */ + axis2_char_t *host_port_str = NULL; + axis2_char_t *host = axutil_url_get_host(client->url, env); + axis2_http_request_line_t *request_line = axis2_http_simple_request_get_request_line( + request, env); + axis2_char_t *path = axis2_http_request_line_get_uri(request_line, env); + + host_port_str = AXIS2_MALLOC(env->allocator, axutil_strlen(host) + axutil_strlen(path) + 20 + * sizeof(axis2_char_t)); + + if(!host_port_str) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Memory allocation failed for host %s and %s path", host, path); + + return AXIS2_FAILURE; + } + + sprintf(host_port_str, "http://%s:%d%s", host, 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)); + + if(!str_request_line) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_FREE(env->allocator, host_port_str); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "memory allocation failed for host %s and %s path", host, path); + + return AXIS2_FAILURE; + } + + 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)); + + AXIS2_FREE(env->allocator, host_port_str); + host_port_str = NULL; + + } + + /* Here first we send the http header part */ + + wire_format = axutil_stracat(env, str_request_line, str_header); + AXIS2_FREE(env->allocator, str_header); + str_header = NULL; + 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)); + AXIS2_FREE(env->allocator, wire_format); + wire_format = NULL; + + /* Then we write the two new line charaters before the http body*/ + + written = axutil_stream_write(client->data_stream, env, AXIS2_HTTP_CRLF, 2); + + /* When sending MTOM it is bit different. We keep the attachment + other + mime headers in an array_list and send them one by one */ + + if(client->doing_mtom) + { + axis2_status_t status = AXIS2_SUCCESS; + axutil_http_chunked_stream_t *chunked_stream = NULL; + + /* If the callback name is not there, then we will check whether there + * is any mime_parts which has type callback. If we found then no point + * of continuing we should return a failure */ + + if(!(client->mtom_sending_callback_name)) + { + if(axis2_http_transport_utils_is_callback_required(env, client->mime_parts)) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sender callback not specified"); + return AXIS2_FAILURE; + } + } + + /* For MTOM we automatically enabled chunking */ + chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); + + /* This method will write the Attachment + data to the wire */ + + status = axis2_http_transport_utils_send_mtom_message(chunked_stream, env, + client->mime_parts, client->mtom_sending_callback_name); + + axutil_http_chunked_stream_free(chunked_stream, env); + chunked_stream = NULL; + + } + /* Non MTOM case */ + else if(client->req_body_size > 0 && client->req_body) + { + int len = 0; + written = 0; + + /* Keep on writing data in a loop until we finised + with all the data in the buffer */ + + if(!chunking_enabled) + { + status = AXIS2_SUCCESS; + while(written < client->req_body_size) + { + len = 0; + len = axutil_stream_write(client->data_stream, env, client->req_body + written, + client->req_body_size - written); + if(-1 == len) + { + status = AXIS2_FAILURE; + break; + } + else + { + written += len; + } + } + } + else + { + /* Not MTOM but chunking is enabled */ + axutil_http_chunked_stream_t *chunked_stream = NULL; + chunked_stream = axutil_http_chunked_stream_create(env, client->data_stream); + status = AXIS2_SUCCESS; + if(!chunked_stream) + { + axutil_network_handler_close_socket(env, client->sockfd); + client->sockfd = -1; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creatoin of chunked stream failed"); + return AXIS2_FAILURE; + } + + while(written < client->req_body_size) + { + written = axutil_http_chunked_stream_write(chunked_stream, env, client->req_body, + client->req_body_size); + + if(-1 == written) + { + status = AXIS2_FAILURE; + break; + } + } + + if(AXIS2_SUCCESS == status) + { + /* Writing the trailing null charactor */ + axutil_http_chunked_stream_write_last_chunk(chunked_stream, env); + } + + axutil_http_chunked_stream_free(chunked_stream, env); + } + } + + client->request_sent = AXIS2_TRUE; + return status; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_client_recieve_header( + axis2_http_client_t * client, + const axutil_env_t * env) +{ + int status_code = -1; + 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; + + if(-1 == client->sockfd || !client->data_stream || AXIS2_FALSE == client->request_sent) + { + axis2_char_t *host; + unsigned int port; + host = axutil_url_get_host(client->url, env); + port = axutil_url_get_port(client->url, env); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "client data stream null or socket error for host \ +%s and %d port", host, port); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_HTTP_REQUEST_NOT_SENT, AXIS2_FAILURE); + return -1; + } + + /* read the status line */ + do + { + memset(str_status_line, 0, 512); + while((read = axutil_stream_read(client->data_stream, env, tmp_buf, 1)) > 0) + { + /* "read" variable is number of characters read by stream */ + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + + if(read < 0) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "http client , response timed out"); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE); + return -1; + } + else if(read == 0) + { + AXIS2_HANDLE_ERROR(env, 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_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2_http_status_line_create failed for \ +str_status_line %s", str_status_line); + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + http_status = 0; + continue; + + } + http_status = axis2_http_status_line_get_status_code(status_line, env); + + } + while(AXIS2_HTTP_RESPONSE_OK_CODE_VAL > http_status); + + if(client->response) + axis2_http_simple_response_free(client->response, env); + 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)); + + /* now read the headers */ + memset(str_header, 0, 512); + end_of_line = AXIS2_FALSE; + while(AXIS2_FALSE == end_of_headers) + { + while((read = axutil_stream_read(client->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 == axutil_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(tmp_header) + { + axis2_http_simple_response_set_header(client->response, env, tmp_header); + } + } + } + end_of_line = AXIS2_FALSE; + } + axis2_http_simple_response_set_body_stream(client->response, env, 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_HANDLE_ERROR(env, 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) +{ + return client->response; +} + +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_PARAM_CHECK(env->error, url, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + + if(client->url) + { + axutil_url_free(client->url, env); + client->url = NULL; + } + client->url = url; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_url_t *AXIS2_CALL +axis2_http_client_get_url( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, NULL); + return client->url; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_client_set_timeout( + axis2_http_client_t * client, + const axutil_env_t * env, + int timeout_ms) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + client->timeout = timeout_ms; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_http_client_get_timeout( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + return client->timeout; +} + +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, + int proxy_port) +{ + AXIS2_PARAM_CHECK(env->error, proxy_host, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + + if(proxy_port <= 0) + { + return AXIS2_FAILURE; + } + + client->proxy_port = proxy_port; + if(client->proxy_host) + { + AXIS2_FREE(env->allocator, client->proxy_host); + client->proxy_host = NULL; + } + + if(client->proxy_host_port) + { + AXIS2_FREE(env->allocator, client->proxy_host_port); + client->proxy_host_port = NULL; + } + + client->proxy_host = axutil_strdup(env, proxy_host); + if(!client->proxy_host) + { + return AXIS2_FAILURE; + } + + 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; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_http_client_get_proxy( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, client, NULL); + return client->proxy_host_port; +} + +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, + int port) +{ + axutil_stream_t *tmp_stream = NULL; + axis2_char_t *connect_string = NULL; + axis2_char_t str_status_line[512]; + axis2_char_t tmp_buf[3]; + int read = 0; + axis2_bool_t end_of_line = AXIS2_FALSE; + axis2_bool_t end_of_response = AXIS2_FALSE; + axis2_http_status_line_t *status_line = NULL; + + AXIS2_PARAM_CHECK(env->error, host, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, client->url, AXIS2_FAILURE); + /* This host and port will use for give undersandable log messages + * */ + + if(port <= 0) + { + return AXIS2_FAILURE; + } + + tmp_stream = axutil_stream_create_socket(env, client->sockfd); + if(!tmp_stream) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "unable to create open socket for ssl host %s and %d \ +port", host, port); + return AXIS2_FAILURE; + } + + connect_string = AXIS2_MALLOC(env->allocator, 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)); + + memset(str_status_line, 0, 512); + while((read = axutil_stream_read(tmp_stream, env, tmp_buf, 1)) > 0) + { + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + if(read < 0) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_RESPONSE_TIMED_OUT, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + status_line = axis2_http_status_line_create(env, str_status_line); + if(!status_line) + { + AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + if(200 != axis2_http_status_line_get_status_code(status_line, env)) + { + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_FAILURE; + } + /* We need to empty the stream before we return + */ + memset(str_status_line, 0, 512); + while(AXIS2_FALSE == end_of_response) + { + while((read = axutil_stream_read(tmp_stream, env, tmp_buf, 1)) > 0) + { + tmp_buf[read] = '\0'; + strcat(str_status_line, tmp_buf); + if(0 != strstr(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_line = AXIS2_TRUE; + break; + } + } + if(AXIS2_TRUE == end_of_line) + { + if(0 == axutil_strcmp(str_status_line, AXIS2_HTTP_CRLF)) + { + end_of_response = AXIS2_TRUE; + } + } + } + AXIS2_FREE(env->allocator, connect_string); + axutil_stream_free(tmp_stream, env); + return AXIS2_SUCCESS; +} + +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_bool_t dump_input_msg) +{ + client->dump_input_msg = dump_input_msg; + return AXIS2_SUCCESS; +} + +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_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, server_cert, AXIS2_FAILURE); + client->server_cert = server_cert; + 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) +{ + 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_PARAM_CHECK(env->error, client, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, key_file, AXIS2_FAILURE); + client->key_file = key_file; + 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) +{ + return client->key_file; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_client_set_mime_parts( + axis2_http_client_t * client, + const axutil_env_t * env, + axutil_array_list_t *mime_parts) +{ + client->mime_parts = mime_parts; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_http_client_get_mime_parts( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + return client->mime_parts; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_client_set_doing_mtom( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_bool_t doing_mtom) +{ + client->doing_mtom = doing_mtom; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_http_client_get_doing_mtom( + const axis2_http_client_t * client, + const axutil_env_t * env) +{ + return client->doing_mtom; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_http_client_set_mtom_sending_callback_name( + axis2_http_client_t * client, + const axutil_env_t * env, + axis2_char_t *callback_name) +{ + client->mtom_sending_callback_name = callback_name; + return AXIS2_SUCCESS; +} |