tools/tcpmon/src/util.c

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