tools/tcpmon/src/entry.c - axis-axis2-c-core - Git at Google


 /*
  * 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;
 }

	/*
	* 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;
	}