
/*
 * 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 <axiom.h>
#include <stdlib.h>

#include <tcpmon_util.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;

/*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 * ((int)strlen(data));
        /* We are sure that the difference lies within the int range */
        out = AXIS2_MALLOC(env->allocator, buffer_size * sizeof(axis2_char_t));

        if (data)
        {
            int size = 0;
            size = (int)strlen(data);
            /* We are sure that the difference lies within the int range */
            xml_reader =
                axiom_xml_reader_create_for_memory(env, data, size, "utf-8",
                                                   AXIS2_XML_PARSER_TYPE_BUFFER);
            if (!xml_reader)
                return NULL;
        }

        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_util_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_util_strcat(out, attr_prefix, &buffer_size, env);
                            tcpmon_util_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_util_strcat(out, attr_name, &buffer_size, env);
                            tcpmon_util_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_util_strcat(out, attr_value, &buffer_size, env);
                            tcpmon_util_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_util_strcat(out, "\n", &buffer_size, env);

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

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

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

                    ele_name =
                        (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
                                                                   env);
                    if (ele_name)
                    {
                        tcpmon_util_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_util_strcat(out, " ", &buffer_size, env);
                            tcpmon_util_strcat(out, attr_prefix, &buffer_size, env);
                            tcpmon_util_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_util_strcat(out, attr_name, &buffer_size,
                                              env);
                                tcpmon_util_strcat(out, "=\"", &buffer_size, env);
                            }
                            else
                            {
                                tcpmon_util_strcat(out, " ", &buffer_size, env);
                                tcpmon_util_strcat(out, attr_name, &buffer_size,
                                              env);
                                tcpmon_util_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_util_strcat(out, attr_value, &buffer_size, env);
                            tcpmon_util_strcat(out, "\"", &buffer_size, env);
                        }
                    }

                    tcpmon_util_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_util_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_util_strcat(out, "\n", &buffer_size, env);

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

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

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

                    ele_name =
                        (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
                                                                   env);
                    if (ele_name)
                        tcpmon_util_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_util_strcat(out, " ", &buffer_size, env);
                            tcpmon_util_strcat(out, attr_prefix, &buffer_size, env);
                            tcpmon_util_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_util_strcat(out, attr_name, &buffer_size,
                                              env);
                                tcpmon_util_strcat(out, "=\"", &buffer_size, env);
                            }
                            else
                            {
                                tcpmon_util_strcat(out, " ", &buffer_size, env);
                                tcpmon_util_strcat(out, attr_name, &buffer_size,
                                              env);
                                tcpmon_util_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_util_strcat(out, attr_value, &buffer_size, env);
                            tcpmon_util_strcat(out, "\"", &buffer_size, env);
                        }
                    }

                    tcpmon_util_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_util_strcat(out, "\n", &buffer_size, env);
                        for (i = 0; i < tab_pos; i++)
                            tcpmon_util_strcat(out, "\t", &buffer_size, env);
                    }

                    has_value = 0;

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

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

                    ele_name =
                        (axis2_char_t *) axiom_xml_reader_get_name(xml_reader,
                                                                   env);
                    if (ele_name)
                    {
                        tcpmon_util_strcat(out, ele_name, &buffer_size, env);
                        tcpmon_util_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_util_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 = (int)strlen(dest);
    /* We are sure that the difference lies within the int range */
    source_len = (int)strlen(source);
    /* We are sure that the difference lies within the int range */

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

char *
tcpmon_util_str_replace(
    const axutil_env_t *env,    
    char *str,
    const char *search,
    const char *replace)
{
    char *str_return = NULL;
    char *str_tmp = NULL;
    char *str_relic = NULL;
    int size = ((int)strlen(str)) * 2;
    /* We are sure that the difference lies within the int range */
    int addmem = size;
    int diff = (int)(strlen(replace) - strlen(search));
    /* We are sure that the difference lies within the int range */

    str_return = (char *) AXIS2_MALLOC(env->allocator, ((size + 1) * sizeof(char)));
    str_tmp = (char *) AXIS2_MALLOC(env->allocator, (size * sizeof(char)));
    

    if (str_return == NULL || str_tmp == NULL)
    {
        AXIS2_FREE(env->allocator, str_return);
        str_return = NULL;
        AXIS2_FREE(env->allocator, str_tmp);
        str_tmp = NULL;
        return "function tcpmon_util_str_replace : give me more memory";
    }
    if (!strcmp(search, replace))
    {
        AXIS2_FREE(env->allocator, str_return);
        str_return = NULL;
        AXIS2_FREE(env->allocator, str_tmp);
        str_tmp = NULL;
        return str;
    }

    strcpy(str_return, str);

    while ((str_relic = strstr(str_return, search)) != NULL)
    {
        if ((int)strlen(str_return) + diff >= addmem)
            /* We are sure that the difference lies within the int range */
        {
            str_return = (char *) realloc(str_return, addmem += size);
            str_tmp = (char *) realloc(str_tmp, addmem);

            if (str_return == NULL || str_tmp == NULL)
            {
                AXIS2_FREE(env->allocator, str_return);
                str_return = NULL;
                AXIS2_FREE(env->allocator, str_tmp);
                str_tmp = NULL;
                return "function tcpmon_str_replace : gimme more memory";
            }
        }

        strcpy(str_tmp, replace);
        strcat(str_tmp, (str_relic + strlen(search)));
        *str_relic = '\0';

        strcat(str_return, str_tmp);
    }

    AXIS2_FREE(env->allocator, str_tmp);
    str_tmp = NULL;
    /* free(str); */ /* we are not allocating memory using str */
    str_return[addmem] = '\0';
    return (str_return);
}


axis2_char_t *
tcpmon_util_read_current_stream(
    const axutil_env_t * env,
    axutil_stream_t * stream,
    int *stream_size,
    axis2_char_t ** header,
    axis2_char_t ** data)
{
    int read_size = 0;
    axis2_char_t *buffer = NULL;
    axis2_char_t *header_ptr = NULL;
    axis2_char_t *body_ptr = NULL;
    int header_found = 0;
    int header_just_finished = 0;
    int read = 0;
    int header_width = 0;
    int current_line_offset = 0;
    int mtom_optimized = 0;
    axis2_char_t *current_line = NULL;
    int line_just_ended = 1;
    axis2_char_t *length_char = 0;
    int length = -1;
    int chunked_encoded = 0;
    int is_get = 0;
    int zero_content_length = 0;

    buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t));
    *data = NULL;
    *header = NULL;
    do
    {
        buffer = AXIS2_REALLOC(env->allocator, buffer,
                               sizeof(axis2_char_t) * (read_size + 1));
        *(buffer + read_size) = '\0';
        read = axutil_stream_read(stream, env, buffer + read_size, 1);

        if (header_just_finished)
        {
            header_just_finished = 0;
            header_width = read_size;
        }

                          /** identify the content lenth*/
        if (!header_found && *(buffer + read_size) == '\r')
        {
            *(buffer + read_size) = '\0';
            current_line = buffer + current_line_offset;
            if (!mtom_optimized && strstr(current_line, "multipart/related"))
                mtom_optimized = 1;
            if (strstr(current_line, "Content-Length"))
            {
                length_char = strstr(current_line, ":");
                if (length_char)
                {
                    length_char++;
                    length = atoi(length_char);
                    if (length == 0)
                    {
                        zero_content_length = 1;
                    }
                }
            }
            if (strstr(current_line, "GET") || strstr(current_line, "HEAD")
                || strstr(current_line, "DELETE"))
            {
                is_get = 1;
                    /** Captures GET style requests */
            }
            *(buffer + read_size) = '\r';
        }
        if (!header_found && line_just_ended)
        {
            line_just_ended = 0;
            current_line_offset = read_size;
        }
        if (!header_found && *(buffer + read_size) == '\n')
        {
            line_just_ended = 1;    /* set for the next loop to read */
        }
        if (header_found)
        {
            length--;
        }
        if (header_found &&
            read_size >= 4 &&
            chunked_encoded == 1 &&
            *(buffer + read_size) == '\n' &&
            *(buffer + read_size - 1) == '\r' &&
            *(buffer + read_size - 2) == '\n' &&
            *(buffer + read_size - 3) == '\r' &&
            *(buffer + read_size - 4) == '0')
        {

            length = 0;          /** this occurs in chunked transfer encoding */
        }

                          /** identify the end of the header */
        if (!header_found &&
            read_size >= 3 &&
            *(buffer + read_size) == '\n' &&
            *(buffer + read_size - 1) == '\r' &&
            *(buffer + read_size - 2) == '\n' &&
            *(buffer + read_size - 3) == '\r')
        {
            header_found = 1;
            *(buffer + read_size - 3) = '\0';
            if (header_ptr)
            {
                AXIS2_FREE(env->allocator, header_ptr);
            }
            header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
            header_just_finished = 1;
            *(buffer + read_size - 3) = '\r';
            if (is_get && length == -1)
            {
                break;
            }
        }
        read_size++;
        if (!chunked_encoded && length < -1)
        {
            header_width = 0;
            /* break; */

                                  /** this is considered as transfer-encoding = chunked */
            chunked_encoded = 1;
            header_found = 1;
            *(buffer + read_size - 3) = '\0';
            if (header_ptr)
            {
                AXIS2_FREE(env->allocator, header_ptr); 
            }
            header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
            header_just_finished = 1;
            *(buffer + read_size - 3) = '\r';
        }
        if (!(*(buffer + read_size - 1)))
        {
            if (!mtom_optimized)
            {
                read_size--;
                length = 0;
            }
            else
            {
                /**(buffer + read_size - 1) = ' ';*/
            }
        }
    }
    while (length != 0);
    
    if (is_get)
    {
        read_size++;
    }
    else if (zero_content_length)
    {
        read_size += 3;
    }

    buffer = AXIS2_REALLOC(env->allocator, buffer,
                           sizeof(axis2_char_t) * (read_size + 1));
    *(buffer + read_size) = '\0';
    
    if (header_width != 0)
    {
        body_ptr = buffer + header_width;
        if (body_ptr && *body_ptr)
        {
            if (mtom_optimized)
            {
                int count = read_size - (int)strlen(header_ptr) - 4;
                int copied = 0;
                int plen = 0;
                axis2_char_t *temp = NULL;
                temp = AXIS2_MALLOC(env->allocator,
                              sizeof(axis2_char_t) * count + 1);
                while(count > copied)
                {
                    plen = 0;
                    plen = ((int)strlen(body_ptr) + 1);
                    if (plen != 1)
                    {
                        sprintf(temp, "%s", body_ptr);
                    }
                    copied += plen;
                    if (count > copied)
                    {
                        temp += plen;
                        body_ptr += plen;
                    }
                }
                copied -= plen;
                temp -= copied;
                temp[count] = '\0';
                *data = temp;
            }
            else
            {
                *data = (axis2_char_t *) axutil_strdup(env, body_ptr);
            }
        }
        body_ptr = NULL;    
    }
    else
    {
        /** soap body part is unavailable */
        if (is_get)
        {
            *data = (axis2_char_t *) axutil_strdup(env, "\n");
            *(buffer + read_size - 1) = '\n';
        }
        else if (zero_content_length)
        {
            *data = (axis2_char_t *) axutil_strdup(env, "\n");
            *(buffer + read_size - 3) = '\n';
            *(buffer + read_size - 2) = '\r';
            *(buffer + read_size - 1) = '\n';
        }
        if (header_ptr)
        {
            AXIS2_FREE(env->allocator, header_ptr);
        }
        header_ptr = (axis2_char_t *) axutil_strdup(env, buffer);
    }

    *header = header_ptr;
    *stream_size = read_size;
    return buffer;
}


int
tcpmon_util_write_to_file(
    char *filename,
    char *buffer)
{
    int size = 0;
    if (filename)
    {
        FILE *fp = fopen(filename, "ab");
        size = (int)fwrite(buffer, 1, strlen(buffer), fp);
        /* We are sure that the difference lies within the int range */
        fclose(fp);
    }
    return size;
}