| |
| /* |
| * 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 <stdio.h> |
| #include <axutil_utils.h> |
| #include <axutil_error.h> |
| #include <axutil_string.h> |
| #include <axutil_network_handler.h> |
| #include <axutil_stream.h> |
| #include <time.h> |
| |
| #include "tcpmon_entry_local.h" |
| #include "tcpmon_session_local.h" |
| #include "tcpmon_util.h" |
| |
| #define AXIS2_TCPMON |
| |
| /** |
| * @brief |
| */ |
| typedef struct tcpmon_entry_impl |
| { |
| tcpmon_entry_t entry; |
| |
| axis2_char_t *arrived_time; |
| axis2_char_t *sent_time; |
| axis2_char_t *sent_data; |
| axis2_char_t *arrived_data; |
| axis2_char_t *sent_headers; |
| axis2_char_t *arrived_headers; |
| axis2_bool_t is_success; |
| axis2_char_t *time_diff; |
| axis2_char_t *test_file_name; |
| int format_bit; |
| int sent_data_length; |
| int arrived_data_length; |
| } |
| tcpmon_entry_impl_t; |
| |
| #define AXIS2_INTF_TO_IMPL(entry) \ |
| ((tcpmon_entry_impl_t *) entry) |
| |
| /************************* Function prototypes ********************************/ |
| |
| |
| axis2_status_t AXIS2_CALL tcpmon_entry_free( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_time( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_sent_time( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_time_diff( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_sent_data( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_sent_headers( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_data( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *AXIS2_CALL tcpmon_entry_arrived_headers( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_bool_t AXIS2_CALL tcpmon_entry_is_success( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_char_t *get_current_stream_to_buffer( |
| const axutil_env_t * env, |
| axutil_stream_t * stream, |
| int *stream_size); |
| |
| |
| int AXIS2_CALL tcpmon_entry_get_format_bit( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| int AXIS2_CALL tcpmon_entry_get_sent_data_length( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| int AXIS2_CALL tcpmon_entry_get_arrived_data_length( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env); |
| |
| axis2_status_t AXIS2_CALL tcpmon_entry_set_format_bit( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env, |
| int format_bit); |
| |
| /************************** End of function prototypes ************************/ |
| |
| tcpmon_entry_t *AXIS2_CALL |
| tcpmon_entry_create( |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = (tcpmon_entry_impl_t *) AXIS2_MALLOC(env-> |
| allocator, |
| sizeof |
| (tcpmon_entry_impl_t)); |
| |
| if (!entry_impl) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| entry_impl->arrived_time = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl->sent_time = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl->time_diff = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl->arrived_data = NULL; |
| entry_impl->sent_data = NULL; |
| entry_impl->arrived_headers = NULL; |
| entry_impl->sent_headers = NULL; |
| entry_impl->is_success = AXIS2_FALSE; |
| entry_impl->format_bit = 0; |
| entry_impl->sent_data_length = 0; |
| entry_impl->arrived_data_length = 0; |
| |
| entry_impl->entry.ops = |
| AXIS2_MALLOC(env->allocator, sizeof(tcpmon_entry_ops_t)); |
| if (!entry_impl->entry.ops) |
| { |
| tcpmon_entry_free(&(entry_impl->entry), env); |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| entry_impl->entry.ops->free = tcpmon_entry_free; |
| entry_impl->entry.ops->arrived_time = tcpmon_entry_arrived_time; |
| entry_impl->entry.ops->sent_time = tcpmon_entry_sent_time; |
| entry_impl->entry.ops->time_diff = tcpmon_entry_time_diff; |
| entry_impl->entry.ops->sent_data = tcpmon_entry_sent_data; |
| entry_impl->entry.ops->sent_headers = tcpmon_entry_sent_headers; |
| entry_impl->entry.ops->arrived_data = tcpmon_entry_arrived_data; |
| entry_impl->entry.ops->arrived_headers = tcpmon_entry_arrived_headers; |
| entry_impl->entry.ops->is_success = tcpmon_entry_is_success; |
| entry_impl->entry.ops->set_format_bit = tcpmon_entry_set_format_bit; |
| entry_impl->entry.ops->get_format_bit = tcpmon_entry_get_format_bit; |
| entry_impl->entry.ops->get_sent_data_length = tcpmon_entry_get_sent_data_length; |
| entry_impl->entry.ops->get_arrived_data_length = tcpmon_entry_get_arrived_data_length; |
| |
| return &(entry_impl->entry); |
| } |
| |
| /***************************Function implementation****************************/ |
| |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_free( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| if (entry->ops) |
| { |
| AXIS2_FREE(env->allocator, entry->ops); |
| entry->ops = NULL; |
| } |
| |
| if (entry_impl->arrived_time) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->arrived_time); |
| entry_impl->arrived_time = NULL; |
| } |
| if (entry_impl->sent_time) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->sent_time); |
| entry_impl->sent_time = NULL; |
| } |
| if (entry_impl->time_diff) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->time_diff); |
| entry_impl->time_diff = NULL; |
| } |
| if (entry_impl->arrived_data) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->arrived_data); |
| entry_impl->arrived_data = NULL; |
| } |
| if (entry_impl->sent_data) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->sent_data); |
| entry_impl->sent_data = NULL; |
| } |
| if (entry_impl->arrived_headers) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->arrived_headers); |
| entry_impl->arrived_headers = NULL; |
| } |
| if (entry_impl->sent_headers) |
| { |
| AXIS2_FREE(env->allocator, entry_impl->sent_headers); |
| entry_impl->sent_headers = NULL; |
| } |
| |
| if (entry_impl) |
| { |
| AXIS2_FREE(env->allocator, entry_impl); |
| entry_impl = NULL; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_arrived_time( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->arrived_time; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_sent_time( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->sent_time; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_time_diff( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->time_diff; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_sent_data( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->sent_data; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_sent_headers( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->sent_headers; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_arrived_data( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->arrived_data; |
| } |
| |
| axis2_char_t *AXIS2_CALL |
| tcpmon_entry_arrived_headers( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->arrived_headers; |
| } |
| |
| axis2_bool_t AXIS2_CALL |
| tcpmon_entry_is_success( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->is_success; |
| } |
| |
| int AXIS2_CALL |
| tcpmon_entry_get_format_bit( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->format_bit; |
| } |
| |
| int AXIS2_CALL |
| tcpmon_entry_get_sent_data_length( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->sent_data_length; |
| } |
| |
| int AXIS2_CALL |
| tcpmon_entry_get_arrived_data_length( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->arrived_data_length; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_set_format_bit( |
| tcpmon_entry_t * entry, |
| const axutil_env_t * env, |
| int format_bit) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| entry_impl->format_bit = format_bit; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| /** implimentations for protected methods */ |
| |
| /** executes as new entry arises */ |
| void *AXIS2_CALL |
| tcpmon_entry_new_entry_funct( |
| axutil_thread_t * thd, |
| void *data) |
| { |
| tcpmon_entry_request_data_t *req_data = (tcpmon_entry_request_data_t *) data; |
| const axutil_env_t *env = NULL; |
| int client_socket = -1; |
| int host_socket = -1; |
| tcpmon_session_t *session; |
| TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct; |
| TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry; |
| |
| axutil_stream_t *client_stream = NULL; |
| axutil_stream_t *host_stream = NULL; |
| int buffer_size = 0; |
| axis2_char_t *headers = NULL; |
| axis2_char_t *content = NULL; |
| axis2_char_t *buffer = NULL; |
| time_t now; |
| struct tm *localTime = NULL; |
| int arrived_secs = 0; |
| int sent_secs = 0; |
| int time_diff_i = 0; |
| int target_port = 0; |
| axis2_char_t *target_host = NULL; |
| int test_bit = 0; |
| int format_bit = 0; |
| tcpmon_entry_t *entry = NULL; |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| env = req_data->env; |
| client_socket = req_data->socket; |
| session = req_data->session; |
| on_trans_fault_funct = tcpmon_session_get_on_trans_fault(session, env); |
| on_new_entry = tcpmon_session_get_on_new_entry(session, env); |
| |
| entry = tcpmon_entry_create(env); |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| target_port = TCPMON_SESSION_GET_TARGET_PORT(session, env); |
| target_host = TCPMON_SESSION_GET_TARGET_HOST(session, env); |
| if (target_port == -1 || target_host == NULL) |
| { |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Missing target port and host" |
| "input missing"); |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct) (env, "Missing target port and host"); |
| } |
| if (thd) |
| { |
| AXIS2_FREE(env->allocator, thd); |
| } |
| if (data) |
| { |
| AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data); |
| } |
| return NULL; |
| } |
| client_stream = axutil_stream_create_socket(env, client_socket); |
| if (!client_stream) |
| { |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, |
| "Error in creating client stream" "handling response"); |
| |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct) (env, "error in creating the client stream"); |
| } |
| if (thd) |
| { |
| AXIS2_FREE(env->allocator, thd); |
| } |
| if (data) |
| { |
| AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data); |
| } |
| return NULL; |
| } |
| |
| buffer = tcpmon_util_read_current_stream(env, client_stream, &buffer_size, |
| &headers, &content); |
| |
| headers =(char *) tcpmon_util_str_replace(env, headers,"localhost", target_host); |
| test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env); |
| |
| if (test_bit) |
| { |
| tcpmon_util_write_to_file("reqest", buffer); |
| } |
| |
| format_bit = TCPMON_SESSION_GET_FORMAT_BIT(session, env); |
| TCPMON_ENTRY_SET_FORMAT_BIT(entry, env, format_bit); |
| |
| now = time(NULL); |
| localTime = localtime(&now); |
| |
| sprintf(entry_impl->sent_time, "%d:%d:%d", localTime->tm_hour, |
| localTime->tm_min, localTime->tm_sec); |
| sent_secs = |
| localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 + |
| localTime->tm_sec; |
| |
| /*free ( localTime); */ |
| |
| entry_impl->sent_headers = headers; |
| entry_impl->sent_data = content; |
| entry_impl->sent_data_length = buffer_size; |
| |
| if (on_new_entry) |
| { |
| (on_new_entry) (env, entry, 0); |
| } |
| |
| host_socket = |
| (int)axutil_network_handler_open_socket(env, target_host, target_port); |
| if (-1 == host_socket) |
| { |
| axutil_stream_write(client_stream, env, NULL, 0); |
| axutil_stream_free(client_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host_socket" |
| "creating socket"); |
| |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct) (env, "error in creating the host socket"); |
| } |
| if (thd) |
| { |
| AXIS2_FREE(env->allocator, thd); |
| } |
| if (data) |
| { |
| AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data); |
| } |
| return NULL; |
| } |
| |
| host_stream = axutil_stream_create_socket(env, host_socket); |
| if (!host_stream) |
| { |
| axutil_stream_write(client_stream, env, NULL, 0); |
| axutil_stream_free(client_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| axutil_network_handler_close_socket(env, host_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host stream" |
| "handling response"); |
| |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct) (env, "error in creating the host stream"); |
| } |
| if (thd) |
| { |
| AXIS2_FREE(env->allocator, thd); |
| } |
| if (data) |
| { |
| AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data); |
| } |
| return NULL; |
| } |
| |
| axutil_stream_write(host_stream, env, buffer, buffer_size); |
| AXIS2_FREE(env->allocator, buffer); |
| |
| buffer = tcpmon_util_read_current_stream(env, host_stream, &buffer_size, |
| &headers, &content); |
| |
| test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env); |
| if (test_bit) |
| { |
| tcpmon_util_write_to_file("response", buffer); |
| } |
| |
| now = time(NULL); |
| localTime = localtime(&now); |
| |
| sprintf(entry_impl->arrived_time, "%d:%d:%d", localTime->tm_hour, |
| localTime->tm_min, localTime->tm_sec); |
| arrived_secs = |
| localTime->tm_hour * 60 * 60 + localTime->tm_min * 60 + |
| localTime->tm_sec; |
| /*free ( localTime); */ |
| |
| time_diff_i = arrived_secs - sent_secs; |
| if (time_diff_i < 0) |
| { |
| time_diff_i += 24 * 60 * 60; |
| } |
| sprintf(entry_impl->time_diff, "%d sec(s)", time_diff_i); |
| |
| entry_impl->arrived_headers = headers; |
| entry_impl->arrived_data = content; |
| entry_impl->arrived_data_length = buffer_size; |
| if (buffer == NULL || buffer_size == 0) |
| { |
| entry_impl->is_success = 0; |
| } |
| else |
| { |
| entry_impl->is_success = 1; |
| } |
| |
| if (on_new_entry) |
| { |
| (on_new_entry) (env, entry, 1); |
| } |
| |
| axutil_stream_write(client_stream, env, buffer, buffer_size); |
| AXIS2_FREE(env->allocator, buffer); |
| |
| axutil_stream_free(client_stream, env); |
| axutil_stream_free(host_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| axutil_network_handler_close_socket(env, host_socket); |
| |
| if (entry_impl) |
| { |
| tcpmon_entry_free(&(entry_impl->entry), env); |
| } |
| if (thd) |
| { |
| AXIS2_FREE(env->allocator, thd); |
| } |
| if (data) |
| { |
| AXIS2_FREE(env->allocator, (tcpmon_entry_request_data_t *)data); |
| } |
| return NULL; |
| } |
| |
| |