tools/tcpmon/src/util.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 <tcpmon_util.h>
 #include <axiom.h>

 #define START_ELEMENT 1
 #define CHAR_VALUE 2
 #define END_ELEMENT 3
 #define EMPTY_ELEMENT 4

 typedef struct tcpmon_util_allocator
 {
   int allocated;
   int index;
   axis2_char_t* buffer;
 }
 tcpmon_util_allocator_t;

 axis2_char_t* tcpmon_strcat(char *dest, char *source, int *cur_buf_s, const axutil_env_t *env);

 /*static void add_string(const axutil_env_t* env,
 		       tcpmon_util_allocator_t* allocator,
 		       axis2_char_t* string);
 */

 /*static void add_axis2_char_t(const axutil_env_t* env,
 			     tcpmon_util_allocator_t* allocator,
 			     axis2_char_t c,
 			     int turns);
 */
 axis2_char_t*
 tcpmon_util_format_as_xml(const axutil_env_t *env, axis2_char_t *data, int format)
 {
     if(format)
     {
         int c;
         int tab_pos = 0;
         int has_value = 0;
         int has_space = 0;
         int start_ele = 0;
         int prev_case = 0;
         int buffer_size = 0;

         axis2_char_t *out;

         axiom_xml_reader_t *xml_reader = NULL;

         buffer_size = 2*strlen(data);
         out = AXIS2_MALLOC(env->allocator, buffer_size*sizeof(axis2_char_t));

         if (data)
         {
             int size = 0;
             size = strlen (data);
             xml_reader =
     	    axiom_xml_reader_create_for_memory (env, data, size, "utf-8", AXIS2_XML_PARSER_TYPE_BUFFER);
             if (!xml_reader)
     	        return AXIS2_FAILURE;
         }

         axiom_xml_reader_init ();

         while ((c = axiom_xml_reader_next (xml_reader, env)) != -1)
         {
             switch (c)
 	        {
 	            case AXIOM_XML_READER_START_DOCUMENT:
     	        {
 	                int ix;

     	            tcpmon_strcat(out, "<?xml ", &buffer_size, env);


 	                ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
 	                for (; ix > 0; ix--)
 	                {
 		                axis2_char_t *attr_prefix;
 		                axis2_char_t *attr_name;
     		            axis2_char_t *attr_value;

 	    	            attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
 		                if (attr_prefix)
 		                {
 		                    tcpmon_strcat(out, attr_prefix, &buffer_size, env);
 		                    tcpmon_strcat(out, ":", &buffer_size, env);
 		                }

     		            attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
 	    	            if (attr_name)
 		                {
 		                    tcpmon_strcat(out, attr_name, &buffer_size, env);
 		                    tcpmon_strcat(out, "=\"", &buffer_size, env);
 		                }

 		                attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
 		                if (attr_value)
     		            {
 	    	                tcpmon_strcat(out, attr_value, &buffer_size, env);
 		                    tcpmon_strcat(out, "\"", &buffer_size, env);
 		                }
 	                }

     	            printf ("?>");
 	            }
 	            break;
 	            case AXIOM_XML_READER_START_ELEMENT:
 	            {
 	                int i, ix, has_prefix = 0;

                     axis2_char_t *ele_name;
 	                axis2_char_t *ele_prefix;

 	                prev_case = START_ELEMENT;

     	            has_value = 0;
 	                has_space = 0;

 	                if (start_ele != 0)
 	                tcpmon_strcat(out, "\n", &buffer_size, env);

     	            for (i = 0; i < tab_pos; i++)
 	                    tcpmon_strcat(out, "\t", &buffer_size, env);

 	                tcpmon_strcat(out, "<", &buffer_size, env);

 	                ele_prefix =(axis2_char_t *)axiom_xml_reader_get_prefix (xml_reader, env);
 	                if (ele_prefix)
     	            {
 	    	            tcpmon_strcat(out, ele_prefix, &buffer_size, env);
 		                tcpmon_strcat(out, ":", &buffer_size, env);
     	            }

 	                ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
 	                if (ele_name)
 	                {
 		                tcpmon_strcat(out, ele_name, &buffer_size, env);
     	            }

 	                ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
 	                for (; ix > 0; ix--)
 	                {
 		                axis2_char_t *attr_prefix;
     		            axis2_char_t *attr_name;
     		            axis2_char_t *attr_value;

                		    attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
     		            if (attr_prefix)
 	    	            {
 		                    has_prefix = 1;
 		                    tcpmon_strcat(out, " ", &buffer_size, env);
 		                    tcpmon_strcat(out, attr_prefix, &buffer_size, env);
 		                    tcpmon_strcat(out, ":", &buffer_size, env);
 		                }

     		            attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
     		            if (attr_name)
     		            {
     		                if(has_prefix)
     		                {
     			                tcpmon_strcat(out, attr_name, &buffer_size, env);
     			                tcpmon_strcat(out, "=\"", &buffer_size, env);
 	    	                }
 		                    else
     		                {
 	    		                tcpmon_strcat(out, " ", &buffer_size, env);
 		    	                tcpmon_strcat(out, attr_name, &buffer_size, env);
 			                    tcpmon_strcat(out, "=\"", &buffer_size, env);
 		                    }

                             has_prefix = 0;
 		                }

     		            attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
 	    	            if (attr_value)
 		                {
 		                    tcpmon_strcat(out, attr_value, &buffer_size, env);
 		                    tcpmon_strcat(out, "\"", &buffer_size, env);
 		                }
     	            }

 	                tcpmon_strcat(out, ">", &buffer_size, env);

                     tab_pos++;
 	                start_ele = 1;
     	        }
 	            break;
 	            case AXIOM_XML_READER_CHARACTER:
 	            {
     	            axis2_char_t *ele_value;

 	                prev_case = CHAR_VALUE;

 	                ele_value = axiom_xml_reader_get_value (xml_reader, env);
 	                if (ele_value)
     	                tcpmon_strcat(out, ele_value, &buffer_size, env);

 	                has_value = 1;

 	            }
 	            break;
 	            case AXIOM_XML_READER_EMPTY_ELEMENT:
 	            {
 	                int i, ix, has_prefix = 0;

                     axis2_char_t *ele_name;
 	                axis2_char_t *ele_prefix;

 	                prev_case = EMPTY_ELEMENT;

 	                has_value = 0;
 	                has_space = 0;

 	                if (start_ele != 0)
 	                    tcpmon_strcat(out, "\n", &buffer_size, env);

     	            for (i = 0; i < tab_pos; i++)
 	                    tcpmon_strcat(out, "\t", &buffer_size, env);

 	                tcpmon_strcat(out, "<", &buffer_size, env);

 	                ele_prefix = (axis2_char_t *) axiom_xml_reader_get_prefix (xml_reader, env);
     	            if (ele_prefix)
 	                {
 		                tcpmon_strcat(out, ele_prefix, &buffer_size, env);
 		                tcpmon_strcat(out, ":", &buffer_size, env);
 	                }

     	            ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
 	                if (ele_name)
 	                    tcpmon_strcat(out, ele_name, &buffer_size, env);

 	                ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
     	            for (; ix > 0; ix--)
 	                {
     		            axis2_char_t *attr_prefix;
 	    	            axis2_char_t *attr_name;
 		                axis2_char_t *attr_value;

 		                attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
 		                if (attr_prefix)
 		                {
     		                has_prefix = 1;
 	    	                tcpmon_strcat(out, " ", &buffer_size, env);
 		                    tcpmon_strcat(out, attr_prefix, &buffer_size, env);
 		                    tcpmon_strcat(out, ":", &buffer_size, env);
 		                }

 		                attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
     		            if (attr_name)
 	    	            {
 		                    if(has_prefix)
 		                    {
 			                    tcpmon_strcat(out, attr_name, &buffer_size, env);
 			                    tcpmon_strcat(out, "=\"", &buffer_size, env);
 		                    }
     		                else
 	    	                {
 		    	                tcpmon_strcat(out, " ", &buffer_size, env);
 			                    tcpmon_strcat(out, attr_name, &buffer_size, env);
 			                    tcpmon_strcat(out, "=\"", &buffer_size, env);
 		                    }
 		                    has_prefix = 0;
     		            }

 	    	            attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
 		                if (attr_value)
 		                {
 		                    tcpmon_strcat(out, attr_value, &buffer_size, env);
 		                    tcpmon_strcat(out, "\"", &buffer_size, env);
     		            }
 	                }

                     tcpmon_strcat(out, "/>", &buffer_size, env);
     	            start_ele = 1;
                 }
 	            break;
     	        case AXIOM_XML_READER_END_ELEMENT:
 	            {
 	                int i;

                     axis2_char_t *ele_prefix;
     	            axis2_char_t *ele_name;

 	                tab_pos--;

 	                if (has_value == 0 && prev_case != START_ELEMENT)
 	                {
 		                tcpmon_strcat(out, "\n", &buffer_size, env);
     		            for (i = 0; i < tab_pos; i++)
 	        	            tcpmon_strcat(out, "\t", &buffer_size, env);
 	                }

 	                has_value = 0;

     	            tcpmon_strcat(out, "</", &buffer_size, env);

 	                ele_prefix = (axis2_char_t *) axiom_xml_reader_get_prefix (xml_reader, env);
 	                if (ele_prefix)
 	                {
 		                tcpmon_strcat(out, ele_prefix, &buffer_size, env);
 		                tcpmon_strcat(out, ":", &buffer_size, env);
 	                }

     	            ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
 	                if (ele_name)
 	                {
 		                tcpmon_strcat(out, ele_name, &buffer_size, env);
 		                tcpmon_strcat(out, ">", &buffer_size, env);
     	            }
 	                prev_case = END_ELEMENT;

 	            }
 	            break;
     	    }
         }
         return out;
     }
     return data;
 }

 /*void add_string(const axutil_env_t* env,
 		tcpmon_util_allocator_t* allocator,
 		axis2_char_t* string)
 {
   int additional_len = 0;
   void* dest = NULL;
   void* src = NULL;
   int count = 0;

   additional_len = axutil_strlen(string) + 1;
   if (allocator-> index + additional_len  >= allocator-> allocated)
     {
       if (allocator-> allocated == 0)
         {
 	  allocator-> buffer =
 	    AXIS2_MALLOC(env-> allocator, additional_len);
         }
       else
         {
 	  allocator-> buffer =
 	    AXIS2_REALLOC(env-> allocator, allocator-> buffer,
 			  allocator-> allocated + additional_len);
         }
       allocator-> allocated += additional_len;
     }

   dest = allocator-> buffer + allocator-> index;
   src = string;
   count = additional_len;
   memcpy(dest, src, count);

   allocator-> index += count - 1;
 }
 */
 /*void add_axis2_char_t(const axutil_env_t* env,
 		      tcpmon_util_allocator_t* allocator,
 		      axis2_char_t c,
 		      int turns)
 {
   int additional_len = 0;

   additional_len = turns + 1;
   if (allocator-> index + additional_len  >= allocator-> allocated)
     {
       if (allocator-> allocated == 0)
         {
 	  allocator-> buffer =
 	    AXIS2_MALLOC(env-> allocator, additional_len);
         }
       else
         {
 	  allocator-> buffer =
 	    AXIS2_REALLOC(env-> allocator, allocator-> buffer,
 			  allocator-> allocated + additional_len);
         }
       allocator-> allocated += additional_len;
     }

   memset(allocator-> buffer + allocator-> index, c, turns);

   allocator-> index += turns;

 } */

 axis2_char_t* tcpmon_strcat(axis2_char_t *dest, axis2_char_t *source, int *buff_size, const axutil_env_t* env)
 {
     int cur_len = 0;
     int source_len = 0;

     axis2_char_t *tmp;
     cur_len = strlen(dest);
     source_len = strlen(source);

     if ((*buff_size-cur_len) < source_len)
     {
         *buff_size = *buff_size + (*buff_size*2);
         tmp = (axis2_char_t*)AXIS2_REALLOC(env->allocator, dest, *buff_size*sizeof(axis2_char_t));
         dest = tmp;
         strcat((char*)dest, (char*)source);
     }
     else
     {
         strcat((char*)dest, (char*)source);
     }

     return dest;
 }
	/*
	* 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 <tcpmon_util.h>
	#include <axiom.h>

	#define START_ELEMENT 1
	#define CHAR_VALUE 2
	#define END_ELEMENT 3
	#define EMPTY_ELEMENT 4

	typedef struct tcpmon_util_allocator
	{
	int allocated;
	int index;
	axis2_char_t* buffer;
	}
	tcpmon_util_allocator_t;

	axis2_char_t* tcpmon_strcat(char dest, char source, int cur_buf_s, const axutil_env_t env);

	/static void add_string(const axutil_env_t env,
	tcpmon_util_allocator_t* allocator,
	axis2_char_t* string);
	*/

	/static void add_axis2_char_t(const axutil_env_t env,
	tcpmon_util_allocator_t* allocator,
	axis2_char_t c,
	int turns);
	*/
	axis2_char_t*
	tcpmon_util_format_as_xml(const axutil_env_t env, axis2_char_t data, int format)
	{
	if(format)
	{
	int c;
	int tab_pos = 0;
	int has_value = 0;
	int has_space = 0;
	int start_ele = 0;
	int prev_case = 0;
	int buffer_size = 0;

	axis2_char_t *out;

	axiom_xml_reader_t *xml_reader = NULL;

	buffer_size = 2*strlen(data);
	out = AXIS2_MALLOC(env->allocator, buffer_size*sizeof(axis2_char_t));

	if (data)
	{
	int size = 0;
	size = strlen (data);
	xml_reader =
	axiom_xml_reader_create_for_memory (env, data, size, "utf-8", AXIS2_XML_PARSER_TYPE_BUFFER);
	if (!xml_reader)
	return AXIS2_FAILURE;
	}

	axiom_xml_reader_init ();

	while ((c = axiom_xml_reader_next (xml_reader, env)) != -1)
	{
	switch (c)
	{
	case AXIOM_XML_READER_START_DOCUMENT:
	{
	int ix;

	tcpmon_strcat(out, "<?xml ", &buffer_size, env);


	ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
	for (; ix > 0; ix--)
	{
	axis2_char_t *attr_prefix;
	axis2_char_t *attr_name;
	axis2_char_t *attr_value;

	attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
	if (attr_prefix)
	{
	tcpmon_strcat(out, attr_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
	if (attr_name)
	{
	tcpmon_strcat(out, attr_name, &buffer_size, env);
	tcpmon_strcat(out, "=\"", &buffer_size, env);
	}

	attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
	if (attr_value)
	{
	tcpmon_strcat(out, attr_value, &buffer_size, env);
	tcpmon_strcat(out, "\"", &buffer_size, env);
	}
	}

	printf ("?>");
	}
	break;
	case AXIOM_XML_READER_START_ELEMENT:
	{
	int i, ix, has_prefix = 0;

	axis2_char_t *ele_name;
	axis2_char_t *ele_prefix;

	prev_case = START_ELEMENT;

	has_value = 0;
	has_space = 0;

	if (start_ele != 0)
	tcpmon_strcat(out, "\n", &buffer_size, env);

	for (i = 0; i < tab_pos; i++)
	tcpmon_strcat(out, "\t", &buffer_size, env);

	tcpmon_strcat(out, "<", &buffer_size, env);

	ele_prefix =(axis2_char_t *)axiom_xml_reader_get_prefix (xml_reader, env);
	if (ele_prefix)
	{
	tcpmon_strcat(out, ele_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
	if (ele_name)
	{
	tcpmon_strcat(out, ele_name, &buffer_size, env);
	}

	ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
	for (; ix > 0; ix--)
	{
	axis2_char_t *attr_prefix;
	axis2_char_t *attr_name;
	axis2_char_t *attr_value;

	attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
	if (attr_prefix)
	{
	has_prefix = 1;
	tcpmon_strcat(out, " ", &buffer_size, env);
	tcpmon_strcat(out, attr_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
	if (attr_name)
	{
	if(has_prefix)
	{
	tcpmon_strcat(out, attr_name, &buffer_size, env);
	tcpmon_strcat(out, "=\"", &buffer_size, env);
	}
	else
	{
	tcpmon_strcat(out, " ", &buffer_size, env);
	tcpmon_strcat(out, attr_name, &buffer_size, env);
	tcpmon_strcat(out, "=\"", &buffer_size, env);
	}

	has_prefix = 0;
	}

	attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
	if (attr_value)
	{
	tcpmon_strcat(out, attr_value, &buffer_size, env);
	tcpmon_strcat(out, "\"", &buffer_size, env);
	}
	}

	tcpmon_strcat(out, ">", &buffer_size, env);

	tab_pos++;
	start_ele = 1;
	}
	break;
	case AXIOM_XML_READER_CHARACTER:
	{
	axis2_char_t *ele_value;

	prev_case = CHAR_VALUE;

	ele_value = axiom_xml_reader_get_value (xml_reader, env);
	if (ele_value)
	tcpmon_strcat(out, ele_value, &buffer_size, env);

	has_value = 1;

	}
	break;
	case AXIOM_XML_READER_EMPTY_ELEMENT:
	{
	int i, ix, has_prefix = 0;

	axis2_char_t *ele_name;
	axis2_char_t *ele_prefix;

	prev_case = EMPTY_ELEMENT;

	has_value = 0;
	has_space = 0;

	if (start_ele != 0)
	tcpmon_strcat(out, "\n", &buffer_size, env);

	for (i = 0; i < tab_pos; i++)
	tcpmon_strcat(out, "\t", &buffer_size, env);

	tcpmon_strcat(out, "<", &buffer_size, env);

	ele_prefix = (axis2_char_t *) axiom_xml_reader_get_prefix (xml_reader, env);
	if (ele_prefix)
	{
	tcpmon_strcat(out, ele_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
	if (ele_name)
	tcpmon_strcat(out, ele_name, &buffer_size, env);

	ix = axiom_xml_reader_get_attribute_count (xml_reader, env);
	for (; ix > 0; ix--)
	{
	axis2_char_t *attr_prefix;
	axis2_char_t *attr_name;
	axis2_char_t *attr_value;

	attr_prefix = (axis2_char_t *)axiom_xml_reader_get_attribute_prefix_by_number (xml_reader, env, ix);
	if (attr_prefix)
	{
	has_prefix = 1;
	tcpmon_strcat(out, " ", &buffer_size, env);
	tcpmon_strcat(out, attr_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	attr_name = (axis2_char_t *)axiom_xml_reader_get_attribute_name_by_number (xml_reader, env, ix);
	if (attr_name)
	{
	if(has_prefix)
	{
	tcpmon_strcat(out, attr_name, &buffer_size, env);
	tcpmon_strcat(out, "=\"", &buffer_size, env);
	}
	else
	{
	tcpmon_strcat(out, " ", &buffer_size, env);
	tcpmon_strcat(out, attr_name, &buffer_size, env);
	tcpmon_strcat(out, "=\"", &buffer_size, env);
	}
	has_prefix = 0;
	}

	attr_value = (axis2_char_t *)axiom_xml_reader_get_attribute_value_by_number (xml_reader, env, ix);
	if (attr_value)
	{
	tcpmon_strcat(out, attr_value, &buffer_size, env);
	tcpmon_strcat(out, "\"", &buffer_size, env);
	}
	}

	tcpmon_strcat(out, "/>", &buffer_size, env);
	start_ele = 1;
	}
	break;
	case AXIOM_XML_READER_END_ELEMENT:
	{
	int i;

	axis2_char_t *ele_prefix;
	axis2_char_t *ele_name;

	tab_pos--;

	if (has_value == 0 && prev_case != START_ELEMENT)
	{
	tcpmon_strcat(out, "\n", &buffer_size, env);
	for (i = 0; i < tab_pos; i++)
	tcpmon_strcat(out, "\t", &buffer_size, env);
	}

	has_value = 0;

	tcpmon_strcat(out, "</", &buffer_size, env);

	ele_prefix = (axis2_char_t *) axiom_xml_reader_get_prefix (xml_reader, env);
	if (ele_prefix)
	{
	tcpmon_strcat(out, ele_prefix, &buffer_size, env);
	tcpmon_strcat(out, ":", &buffer_size, env);
	}

	ele_name = (axis2_char_t *) axiom_xml_reader_get_name (xml_reader, env);
	if (ele_name)
	{
	tcpmon_strcat(out, ele_name, &buffer_size, env);
	tcpmon_strcat(out, ">", &buffer_size, env);
	}
	prev_case = END_ELEMENT;

	}
	break;
	}
	}
	return out;
	}
	return data;
	}

	/void add_string(const axutil_env_t env,
	tcpmon_util_allocator_t* allocator,
	axis2_char_t* string)
	{
	int additional_len = 0;
	void* dest = NULL;
	void* src = NULL;
	int count = 0;

	additional_len = axutil_strlen(string) + 1;
	if (allocator-> index + additional_len >= allocator-> allocated)
	{
	if (allocator-> allocated == 0)
	{
	allocator-> buffer =
	AXIS2_MALLOC(env-> allocator, additional_len);
	}
	else
	{
	allocator-> buffer =
	AXIS2_REALLOC(env-> allocator, allocator-> buffer,
	allocator-> allocated + additional_len);
	}
	allocator-> allocated += additional_len;
	}

	dest = allocator-> buffer + allocator-> index;
	src = string;
	count = additional_len;
	memcpy(dest, src, count);

	allocator-> index += count - 1;
	}
	*/
	/void add_axis2_char_t(const axutil_env_t env,
	tcpmon_util_allocator_t* allocator,
	axis2_char_t c,
	int turns)
	{
	int additional_len = 0;

	additional_len = turns + 1;
	if (allocator-> index + additional_len >= allocator-> allocated)
	{
	if (allocator-> allocated == 0)
	{
	allocator-> buffer =
	AXIS2_MALLOC(env-> allocator, additional_len);
	}
	else
	{
	allocator-> buffer =
	AXIS2_REALLOC(env-> allocator, allocator-> buffer,
	allocator-> allocated + additional_len);
	}
	allocator-> allocated += additional_len;
	}

	memset(allocator-> buffer + allocator-> index, c, turns);

	allocator-> index += turns;

	} */

	axis2_char_t* tcpmon_strcat(axis2_char_t dest, axis2_char_t source, int buff_size, const axutil_env_t env)
	{
	int cur_len = 0;
	int source_len = 0;

	axis2_char_t *tmp;
	cur_len = strlen(dest);
	source_len = strlen(source);

	if ((*buff_size-cur_len) < source_len)
	{
	buff_size = buff_size + (buff_size2);
	tmp = (axis2_char_t)AXIS2_REALLOC(env->allocator, dest, buff_size*sizeof(axis2_char_t));
	dest = tmp;
	strcat((char)dest, (char)source);
	}
	else
	{
	strcat((char)dest, (char)source);
	}

	return dest;
	}