path: root/axiom/src/attachments/mime_parser.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 <axiom_mime_parser.h>
#include <axutil_string.h>
#include <axiom_data_handler.h>
#include <stdio.h>
#include <ctype.h>    
#include <axutil_http_chunked_stream.h>
#include <axiom_mtom_caching_callback.h>
#include <axutil_class_loader.h>
#include <axutil_url.h>

struct axiom_mime_parser
{
    /* This will keep the attachment and its info*/
    axutil_hash_t *mime_parts_map;

    /* This is the actual SOAP part len */
    size_t soap_body_len;

    /* The SOAP part of the message */
    axis2_char_t *soap_body_str;

    /* The size of the buffer we give to the callback to
     * read data */
    size_t buffer_size;

    /* The number of buffers */
    int max_buffers;

    /* The attachment dir name, in the case of caching */
    axis2_char_t *attachment_dir;

    /*A pointer to the caching callback */
    axiom_mtom_caching_callback_t *mtom_caching_callback;

    /* The caching callback name specified */
    axis2_char_t *callback_name;

    axis2_char_t **buf_array;

    size_t *len_array;

    int current_buf_num;

    axis2_bool_t end_of_mime;

    axis2_char_t *mime_boundary;

};

struct axiom_search_info
{
    /*String need to be searched*/
    const axis2_char_t *search_str;

    /*The buffers and the lengths need to be searched*/
    axis2_char_t *buffer1;
    size_t len1;
    axis2_char_t *buffer2;
    size_t len2;

    /*Flag to keep what type of search is this buffer has done*/
    axis2_bool_t primary_search;

    /*The offset where we found the pattern entirely in one buffer*/
    size_t match_len1;

    /*when pattern contains in two buffers the length of partial pattern
     in buffer2 */
    size_t match_len2;

    /*Whether we need caching or not*/
    axis2_bool_t cached;

    /*A pointer to a user provided storage to which we cache the attachment*/
    void *handler;

    /* Size of the binary when writing to the buffer*/
    size_t binary_size;
};

typedef struct axiom_search_info axiom_search_info_t;

#define AXIOM_MIME_PARSER_CONTENT_ID "content-id"
#define AXIOM_MIME_PARSER_CONTENT_TYPE "content-type"

#define AXIOM_MIME_PARSER_END_OF_MIME_MAX_COUNT 1000

static axis2_char_t *
axiom_mime_parser_search_for_soap(
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axis2_char_t *mime_boundary,
    axiom_mime_parser_t *mime_parser);

static axis2_char_t *
axiom_mime_parser_search_for_crlf(
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axiom_mime_parser_t *mime_parser);

static size_t
axiom_mime_parser_calculate_part_len(
    const axutil_env_t *env,
    int buf_num,
    size_t *len_list,
    int maker,
    axis2_char_t *pos,
    axis2_char_t *buf);

static axis2_char_t *
axiom_mime_parser_create_part(
    const axutil_env_t *env,
    size_t part_len,
    int buf_num,
    size_t *len_list,
    int marker,
    axis2_char_t *pos,
    axis2_char_t **buf_list,
    axiom_mime_parser_t *mime_parser);

static axis2_char_t *
axiom_mime_parser_search_string(
    axiom_search_info_t *search_info,
    const axutil_env_t *env);

static axis2_char_t *
axiom_mime_parser_search_for_attachment(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axis2_char_t *mime_boundary,
    axis2_char_t *mime_id,
    void *user_param);

static axis2_status_t
axiom_mime_parser_store_attachment(
    const axutil_env_t *env,
    axiom_mime_parser_t *mime_parser,
    axis2_char_t *mime_id,
    axis2_char_t *mime_type,
    axis2_char_t *mime_binary,
    size_t mime_binary_len,
    axis2_bool_t cached);

static void
axiom_mime_parser_clear_buffers(
    const axutil_env_t *env,
    axis2_char_t **buf_list,
    int free_from,
    int free_to);

static axis2_status_t
axiom_mime_parser_cache_to_buffer(
    const axutil_env_t *env,
    axis2_char_t *buf,
    size_t buf_len,
    axiom_search_info_t *search_info,
    axiom_mime_parser_t *mime_parser);

static axis2_bool_t
axiom_mime_parser_is_more_data(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_callback_info_t *callback_info);

static axis2_char_t *
axiom_mime_parser_process_mime_headers(
    const axutil_env_t *env,
    axiom_mime_parser_t *mime_parser,
    axis2_char_t **mime_id,
    axis2_char_t *mime_headers);

static axis2_status_t
axiom_mime_parser_cache_to_file(
    const axutil_env_t* env,
    axis2_char_t *buf,
    size_t buf_len,
    void *handler);

static void*
axiom_mime_parser_initiate_callback(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_char_t *mime_id,
    void *user_param);

AXIS2_EXTERN axiom_mime_parser_t *AXIS2_CALL
axiom_mime_parser_create(
    const axutil_env_t * env)
{
    axiom_mime_parser_t *mime_parser = NULL;

    AXIS2_ENV_CHECK(env, NULL);
    mime_parser = (axiom_mime_parser_t *)AXIS2_MALLOC(env->allocator, sizeof(axiom_mime_parser_t));

    if(!mime_parser)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    mime_parser->mime_parts_map = NULL;
    mime_parser->soap_body_len = 0;
    mime_parser->soap_body_str = NULL; /* shallow copy */
    mime_parser->buffer_size = 1;
    mime_parser->max_buffers = AXIOM_MIME_PARSER_MAX_BUFFERS;
    mime_parser->attachment_dir = NULL;
    mime_parser->mtom_caching_callback = NULL;
    mime_parser->callback_name = NULL;
    mime_parser->buf_array = NULL;
    mime_parser->len_array = NULL;
    mime_parser->current_buf_num = 0;
    mime_parser->end_of_mime = AXIS2_FALSE;
    mime_parser->mime_boundary = NULL;

    mime_parser->mime_parts_map = axutil_hash_make(env);
    if(!(mime_parser->mime_parts_map))
    {
        axiom_mime_parser_free(mime_parser, env);
        return NULL;
    }

    return mime_parser;
}

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_free(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env)
{
    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

    /* The map is passed on to SOAP builder, and SOAP builder take over the
     ownership of the map */

    /* We will unload the callback at the end */

    if(mime_parser->mtom_caching_callback)
    {
        axutil_param_t *param = NULL;
        param = mime_parser->mtom_caching_callback->param;

        AXIOM_MTOM_CACHING_CALLBACK_FREE(mime_parser->mtom_caching_callback, env);
        mime_parser->mtom_caching_callback = NULL;

        if(param)
        {
            axutil_param_free(param, env);
            param = NULL;
        }
    }

    if(mime_parser->buf_array)
    {
        AXIS2_FREE(env->allocator, mime_parser->buf_array);
        mime_parser->buf_array = NULL;
    }

    if(mime_parser->len_array)
    {
        AXIS2_FREE(env->allocator, mime_parser->len_array);
        mime_parser->len_array = NULL;
    }

	if(mime_parser->mime_boundary)
	{
		AXIS2_FREE(env->allocator, mime_parser->mime_boundary);
	}

    if(mime_parser)
    {
        AXIS2_FREE(env->allocator, mime_parser);
    }

    return;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axiom_mime_parser_parse_for_soap(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    axis2_char_t * mime_boundary)
{
    size_t size = 0;
    axis2_char_t *soap_str = NULL;
    size_t soap_len = 0;
    size_t temp_mime_boundary_size = 0;
    axis2_char_t *temp_mime_boundary = NULL;
    axis2_char_t **buf_array = NULL;
    size_t *len_array = NULL;
    int buf_num = 0;
    axis2_char_t *pos = NULL;
    axiom_search_info_t *search_info = NULL;
    int part_start = 0;
    axis2_bool_t end_of_mime = AXIS2_FALSE;
    size_t len = 0;
    axis2_char_t *buffer = NULL;
    size_t malloc_len = 0;
    axis2_callback_info_t *callback_info = NULL;

    callback_info = (axis2_callback_info_t *)callback_ctx;

    /* The user will specify the mime_parser->buffer_size */

    size = AXIOM_MIME_PARSER_BUFFER_SIZE * (mime_parser->buffer_size);

    /*An array to keep the set of buffers*/

    buf_array = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t *) * (mime_parser->max_buffers));

    if(!buf_array)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Failed in creating buffer array");
        return AXIS2_FAILURE;
    }

    /*Keeps the corresponding lengths of buffers in buf_array*/

    len_array = AXIS2_MALLOC(env->allocator, sizeof(size_t) * (mime_parser->max_buffers));

    if(!len_array)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Failed in creating length array");
        return AXIS2_FAILURE;
    }

    mime_parser->buf_array = buf_array;
    mime_parser->len_array = len_array;

    temp_mime_boundary = axutil_stracat(env, "--", mime_boundary);
    temp_mime_boundary_size = strlen(mime_boundary) + 2;

    /*This struct keeps the pre-post search informations*/
    search_info = AXIS2_MALLOC(env->allocator, sizeof(axiom_search_info_t));

    /* The first buffer is created */
    buf_array[buf_num] = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

    /* The buffer is filled from the callback */

    if(buf_array[buf_num])
    {
        len = callback(buf_array[buf_num], (int)size, (void *)callback_ctx);
    }
    if(len > 0)
    {
        len_array[buf_num] = len;
    }
    else
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error reading from the stream");
        return AXIS2_FAILURE;
    }

    /*starting buffer for the current search*/
    part_start = buf_num;

    /*We are passing the address of the buf_num , beacause that value 
     is changing inside the method.*/

    /* Following call to the method will search first \r\n\r\n */

    pos = axiom_mime_parser_search_for_crlf(env, callback, callback_ctx, &buf_num, len_array,
        buf_array, search_info, size, mime_parser);

    if(!pos)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in the message.");
        return AXIS2_FAILURE;
    }

    /* The patteren contains in one buffer */

    if((search_info->match_len2 == 0))
    {
        /*Readjusting the buffers for the next search and discarding the prevoius 
         buffers*/

        /* We need the remaining part in the buffer after the \r\n\r\n*/

        malloc_len = buf_array[buf_num] + len_array[buf_num] - pos - 4;
        if(malloc_len < 0)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing.");
            return AXIS2_FAILURE;
        }
        else
        {
            /* Here we will create a new buffer of predefined size fill the 
             * first portion from the remaining part after previous search
             * and then fill the remaining from the callback */

            buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

            if(malloc_len > 0)
            {
                memcpy(buffer, pos + 4, malloc_len);
            }

            /* Here we need to check for more data, because if the message is too small
             * comapred to the reading size there may be no data in the stream , instead
             * all the remaining data may be in the buffer.And if there are no more data
             * we will set the len to be 0. Otherwise len_array will contain wrong lenghts.
             */

            if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
            {
                /* There is more data so fill the remaining from the  stream*/

                len = callback(buffer + malloc_len, (int)(size - malloc_len), (void *)callback_ctx);
            }
            else
            {
                len = 0;
            }

            /* We do not need the data in the previous buffers once we found a particular
             * string and after worked with those buffers */

            axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);

            /* Adding the new buffer to the buffer list */

            if(len >= 0)
            {
                buf_array[buf_num] = buffer;
                len_array[buf_num] = malloc_len + len;
            }
        }
    }

    /*The pattern divides among two buffers*/

    else if(search_info->match_len2 > 0)
    {
        malloc_len = len_array[buf_num] - search_info->match_len2;
        if(malloc_len < 0)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing.");
            return AXIS2_FAILURE;
        }
        else
        {
            buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

            /* Here the buf_num is the second buffer. We will copy the remaining data
             * after the partial string in the second buffer */

            if(malloc_len > 0)
            {
                memcpy(buffer, buf_array[buf_num] + search_info->match_len2, malloc_len);
            }
            if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
            {
                len = callback(buffer + malloc_len, (int)(size - malloc_len), (void *)callback_ctx);
            }
            else
            {
                len = 0;
            }
            axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
            if(len >= 0)
            {
                buf_array[buf_num] = buffer;
                len_array[buf_num] = malloc_len + len;
            }
        }
    }
    else
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing.");
        return AXIS2_FAILURE;
    }

    /*Resetting the previous search data and getting ready 
     for the next search */

    part_start = buf_num;
    pos = NULL;
    malloc_len = 0;

    search_info->match_len1 = 0;
    search_info->match_len2 = 0;

    /*In order to extract the soap envelope we need to search for the first
     --MIMEBOUNDARY  */

    pos = axiom_mime_parser_search_for_soap(env, callback, callback_ctx, &buf_num, len_array,
        buf_array, search_info, size, temp_mime_boundary, mime_parser);

    if(!pos)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error while searching for the SOAP part ");
        return AXIS2_FAILURE;
    }

    if(search_info->match_len2 == 0)
    {
        /*Calculating the length of the SOAP str*/

        soap_len = axiom_mime_parser_calculate_part_len(env, buf_num, len_array, part_start, pos,
            buf_array[buf_num]);
        if(soap_len > 0)
        {
            /* Get the SOAP string from the starting and end buffers containing 
             * the SOAP  part */

            soap_str = axiom_mime_parser_create_part(env, soap_len, buf_num, len_array, part_start,
                pos, buf_array, mime_parser);
            if(!soap_str)
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                    "Error while creating the SOAP part from the message ");
                return AXIS2_FAILURE;
            }

            malloc_len = len_array[buf_num] - search_info->match_len1 - temp_mime_boundary_size;
            if(malloc_len < 0)
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing for mime.");
                return AXIS2_FAILURE;
            }
            else
            {
                /* This will fill the new buffer with remaining data after the
                 * SOAP */

                buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                memset(buffer, 0, size + 1);
                if(malloc_len > 0)
                {
                    memcpy(buffer, pos + temp_mime_boundary_size, malloc_len);
                }
                if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                {
                    len = callback(buffer + malloc_len,(int)(size - malloc_len),(void *)callback_ctx);
                }
                else
                {
                    len = 0;
                }
                axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                if(len >= 0)
                {
                    buf_array[buf_num] = buffer;
                    len_array[buf_num] = malloc_len + len;
                }
            }
        }
        else
        {
            return AXIS2_FAILURE;
        }
    }

    /* This is the condition where the --MIMEBOUNDARY is divided among two
     * buffers */

    else if(search_info->match_len2 > 0)
    {
        soap_len = axiom_mime_parser_calculate_part_len(env, buf_num - 1, len_array, part_start,
            pos, buf_array[buf_num - 1]);

        if(soap_len > 0)
        {
            /* Here we pass buf_num-1 because buf_num does not have any thing we want to
             * for this particular part. It begins with the latter part of the search string */

            soap_str = axiom_mime_parser_create_part(env, soap_len, buf_num - 1, len_array,
                part_start, pos, buf_array, mime_parser);
            if(!soap_str)
            {
                return AXIS2_FAILURE;
            }

            malloc_len = len_array[buf_num] - search_info->match_len2;
            if(malloc_len < 0)
            {
                return AXIS2_FAILURE;
            }
            else
            {
                buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                if(malloc_len > 0)
                {
                    memcpy(buffer, buf_array[buf_num] + search_info->match_len2, malloc_len);
                }

                if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                {
                    len = callback(buffer + malloc_len,(int)(size - malloc_len),(void *)callback_ctx);
                }
                else
                {
                    len = 0;
                }
                axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                if(len >= 0)
                {
                    buf_array[buf_num] = buffer;
                    len_array[buf_num] = malloc_len + len;
                }
            }
        }
        else
        {
            return AXIS2_FAILURE;
        }
    }

    mime_parser->soap_body_str = soap_str;
    mime_parser->soap_body_len = soap_len;
    mime_parser->current_buf_num = buf_num;

    /* There are multipart/related messages which does not contain attachments 
     * The only mime_part is the soap envelope. So for those messages the mime
     * boundary after the soap will end up with --
     * So we will check that here and if we found then the logic inside the 
     * while loop will not be executed */

    end_of_mime = (AXIOM_MIME_BOUNDARY_BYTE == *(buf_array[buf_num])) && (AXIOM_MIME_BOUNDARY_BYTE
        == *(buf_array[buf_num] + 1));
    if(end_of_mime)
    {
        AXIS2_FREE(env->allocator, buf_array[buf_num]);
        buf_array[buf_num] = NULL;
    }

    if(temp_mime_boundary)
    {
        AXIS2_FREE(env->allocator, temp_mime_boundary);
        temp_mime_boundary = NULL;
    }

    if(search_info)
    {
        AXIS2_FREE(env->allocator, search_info);
        search_info = NULL;
    }

    mime_parser->end_of_mime = end_of_mime;

    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
axiom_mime_parser_parse_for_attachments(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    axis2_char_t * mime_boundary,
    void *user_param)
{
    int count = 0;
    axiom_search_info_t *search_info = NULL;
    axis2_char_t *pos = NULL;
    int part_start = 0;
    axis2_char_t **buf_array = NULL;
    size_t *len_array = NULL;
    int buf_num = 0;
    size_t size = 0;
    size_t malloc_len = 0;
    axis2_callback_info_t *callback_info = NULL;
    axis2_char_t *temp_mime_boundary = NULL;
    size_t temp_mime_boundary_size = 0;
    axis2_bool_t end_of_mime = AXIS2_FALSE;

    callback_info = (axis2_callback_info_t *)callback_ctx;

    search_info = AXIS2_MALLOC(env->allocator, sizeof(axiom_search_info_t));

    size = AXIOM_MIME_PARSER_BUFFER_SIZE * (mime_parser->buffer_size);

    buf_array = mime_parser->buf_array;
    len_array = mime_parser->len_array;
    buf_num = mime_parser->current_buf_num;

    /*<SOAP></SOAP>--MIMEBOUNDARY
     mime_headr1:.......
     mime_headr2:....

     Binarstart.................
     ...............--MIMEBOUNDARY
     */

    /* This loop will extract all the attachments in the message. The condition
     * with the count is needed because if the sender not marked the end of the 
     * attachment with -- then this loop may run infinitely. To prevent that
     * this additional condition has been put */

    temp_mime_boundary = axutil_stracat(env, "--", mime_boundary);
    temp_mime_boundary_size = strlen(mime_boundary) + 2;

    while((!(mime_parser->end_of_mime)) && count < AXIOM_MIME_PARSER_END_OF_MIME_MAX_COUNT)
    {
        /*First we will search for \r\n\r\n*/
        axis2_char_t *mime_id = NULL;
        axis2_char_t *mime_type = NULL;
        size_t mime_headers_len = 0;
        size_t mime_binary_len = 0;
        axis2_char_t *mime_binary = NULL;
        axis2_char_t *mime_headers = NULL;
        axis2_char_t *buffer = NULL;
        int len = 0;
        axis2_status_t status = AXIS2_FAILURE;

        search_info->match_len1 = 0;
        search_info->match_len2 = 0;
        pos = NULL;
        part_start = buf_num;

        malloc_len = 0;

        count++;

        pos = axiom_mime_parser_search_for_crlf(env, callback, callback_ctx, &buf_num, len_array,
            buf_array, search_info, size, mime_parser);

        if(!pos)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing for mime.");
            return NULL;
        }

        /*The pattern contains in one buffer*/
        if(search_info->match_len2 == 0)
        {
            /*We found it . so lets seperates the details of this binary into 
             mime headers.*/

            mime_headers_len = axiom_mime_parser_calculate_part_len(env, buf_num, len_array,
                part_start, pos, buf_array[buf_num]);
            if(mime_headers_len > 0)
            {
                mime_headers = axiom_mime_parser_create_part(env, mime_headers_len, buf_num,
                    len_array, part_start, pos, buf_array, mime_parser);

                if(!mime_headers)
                {
                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing for mime headers.");
                    return NULL;
                }
                malloc_len = buf_array[buf_num] + len_array[buf_num] - pos - 4;

                /*This should be > 0 , > 0 means there is some part to copy = 0 means
                 there is nothing to copy*/
                if(malloc_len < 0)
                {
                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing for mime headers");
                    return NULL;
                }

                else
                {
                    buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                    if(malloc_len > 0)
                    {
                        memcpy(buffer, pos + 4, malloc_len);
                    }

                    if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                    {
                        len = callback(buffer + malloc_len,(int)(size - malloc_len),(void *)callback_ctx);
                    }
                    else
                    {
                        len = 0;
                    }
                    axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                    if(len >= 0)
                    {
                        buf_array[buf_num] = buffer;
                        len_array[buf_num] = malloc_len + len;
                    }
                }
            }
            else
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in parsing for mime headers.");
                return NULL;
            }
        }

        else if(search_info->match_len2 > 0)
        {
            /*Now we extract the mime headers */

            mime_headers_len = axiom_mime_parser_calculate_part_len(env, buf_num - 1, len_array,
                part_start, pos, buf_array[buf_num - 1]);

            if(mime_headers_len > 0)
            {
                mime_headers = axiom_mime_parser_create_part(env, mime_headers_len, buf_num - 1,
                    len_array, part_start, pos, buf_array, mime_parser);
                if(!mime_headers)
                {
                    return NULL;
                }

                malloc_len = len_array[buf_num] - search_info->match_len2;
                if(malloc_len < 0)
                {
                    return NULL;
                }
                else
                {
                    buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                    if(malloc_len > 0)
                    {
                        memcpy(buffer, buf_array[buf_num] + search_info->match_len2, malloc_len);
                    }
                    if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                    {
                        len = callback(buffer + malloc_len,(int)(size - malloc_len),(void*)callback_ctx);
                    }
                    else
                    {
                        len = 0;
                    }
                    axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                    if(len >= 0)
                    {
                        buf_array[buf_num] = buffer;
                        len_array[buf_num] = malloc_len + len;
                    }
                }
            }
            else
            {
                return NULL;
            }
        }
        else
        {
            return NULL;
        }

        pos = NULL;

        search_info->match_len1 = 0;
        search_info->match_len2 = 0;

        part_start = buf_num;
        malloc_len = 0;

        mime_type
            = axiom_mime_parser_process_mime_headers(env, mime_parser, &mime_id, mime_headers);

        if(!mime_id)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                "Error in parsing for mime headers.Mime id did not find");
            return NULL;
        }

        if(!mime_type)
        {
            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Mime type did not find");
        }

        /*We extract the mime headers. So lets search for the attachment.*/

        pos = axiom_mime_parser_search_for_attachment(mime_parser, env, callback, callback_ctx,
            &buf_num, len_array, buf_array, search_info, size, temp_mime_boundary, mime_id,
            user_param);

        if(pos)
        {
            /*If it is small we are not caching. Hence the attachment 
             is in memory. So store it in a buffer. */

            if(!search_info->cached)
            {
                if(search_info->match_len2 == 0)
                {
                    /* mime_binary contains the attachment when it does not 
                     * cached */

                    mime_binary_len = axiom_mime_parser_calculate_part_len(env, buf_num, len_array,
                        part_start, pos, buf_array[buf_num]);
                    if(mime_binary_len > 0)
                    {
                        mime_binary = axiom_mime_parser_create_part(env, mime_binary_len, buf_num,
                            len_array, part_start, pos, buf_array, mime_parser);
                        if(!mime_binary)
                        {
                            return NULL;
                        }
                    }
                    else
                    {
                        return NULL;
                    }
                }

                else if(search_info->match_len2 > 0)
                {
                    mime_binary_len = axiom_mime_parser_calculate_part_len(env, buf_num - 1,
                        len_array, part_start, pos, buf_array[buf_num - 1]);

                    if(mime_binary_len > 0)
                    {
                        mime_binary = axiom_mime_parser_create_part(env, mime_binary_len, buf_num
                            - 1, len_array, part_start, pos, buf_array, mime_parser);
                        if(!mime_binary)
                        {
                            return NULL;
                        }
                    }
                    else
                    {
                        return NULL;
                    }
                }
            }

            /* The functionality below is common when it is cached or not. It deals with remaining
             * after a particualr attachment, Those may be related to a end of mime_boundary or 
             * another attachment */

            if(search_info->match_len2 == 0)
            {
                malloc_len = len_array[buf_num] - search_info->match_len1 - temp_mime_boundary_size;
                if(malloc_len < 0)
                {
                    return NULL;
                }
                else
                {
                    buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                    if(malloc_len > 0)
                    {
                        memcpy(buffer, pos + temp_mime_boundary_size, malloc_len);
                    }

                    /*When the last buffer only containing -- we know this is the end 
                     of the attachments. Hence we don't need to read again*/

                    if(malloc_len != 2)
                    {
                        if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                        {
                            len = callback(buffer + malloc_len,(int)(size - malloc_len),(void*)callback_ctx);
                        }
                        else
                        {
                            len = 0;
                        }
                        if(len >= 0)
                        {
                            len_array[buf_num] = malloc_len + len;
                        }
                    }

                    /* This means there is another attachment */
                    else
                    {
                        len_array[buf_num] = malloc_len;
                    }
                    axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                    buf_array[buf_num] = buffer;
                }
            }
            else if(search_info->match_len2 > 0)
            {
                malloc_len = len_array[buf_num] - search_info->match_len2;

                if(malloc_len < 0)
                {
                    return NULL;
                }
                else
                {
                    buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

                    if(malloc_len > 0)
                    {
                        memcpy(buffer, buf_array[buf_num] + search_info->match_len2, malloc_len);
                    }
                    if(malloc_len != 2)
                    {
                        if(axiom_mime_parser_is_more_data(mime_parser, env, callback_info))
                        {
                            len = callback(buffer + malloc_len,(int)(size - malloc_len),(void *)callback_ctx);
                        }
                        else
                        {
                            len = 0;
                        }
                        if(len >= 0)
                        {
                            len_array[buf_num] = malloc_len + len;
                        }
                    }
                    else
                    {
                        len_array[buf_num] = malloc_len;
                    }
                    axiom_mime_parser_clear_buffers(env, buf_array, part_start, buf_num);
                    buf_array[buf_num] = buffer;
                }
            }
        }
        else
        {
            return NULL;
        }

        /*We have the attachment now either cached or not. So lets put it in the mime_parts 
         * hash map with the mime_id. Remember at this moment we have already processed the 
         * mime_headers and mime_id is already there */

        /* In the case user has not specified the callback or the attachment dir . So we cached it to a memory
         * buffer. Hence the data_handler type we need to create is different */

        if((search_info->cached) && (!mime_parser->attachment_dir) && (!mime_parser->callback_name))
        {
            mime_binary = (axis2_char_t *)search_info->handler;
            mime_binary_len = search_info->binary_size;
        }

        /* Storing the attachment in the hash map with the id*/

        status = axiom_mime_parser_store_attachment(env, mime_parser, mime_id, mime_type,
            mime_binary, mime_binary_len, search_info->cached);

        /*Check wether we encounter --MIMEBOUNDARY-- to find the end of mime*/

        if(buf_array[buf_num])
        {
            /* Here we check for the end of mime */

            end_of_mime = (AXIOM_MIME_BOUNDARY_BYTE == *(buf_array[buf_num]))
                && (AXIOM_MIME_BOUNDARY_BYTE == *(buf_array[buf_num] + 1));
            if(end_of_mime)
            {
                AXIS2_FREE(env->allocator, buf_array[buf_num]);
                buf_array[buf_num] = NULL;
            }
            mime_parser->end_of_mime = end_of_mime;
        }

        if(mime_headers)
        {
            AXIS2_FREE(env->allocator, mime_headers);
            mime_headers = NULL;
        }

        if(status != AXIS2_SUCCESS)
        {
            return NULL;
        }
    }

    /*Do the necessary cleaning */

    /*if (buf_array)
     {
     AXIS2_FREE(env->allocator, buf_array);
     buf_array = NULL;
     }

     if (len_array)
     {
     AXIS2_FREE(env->allocator, len_array);
     len_array = NULL;
     }*/

    if(temp_mime_boundary)
    {
        AXIS2_FREE(env->allocator, temp_mime_boundary);
        temp_mime_boundary = NULL;
    }

    if(search_info)
    {
        AXIS2_FREE(env->allocator, search_info);
        search_info = NULL;
    }

    return mime_parser->mime_parts_map;

}

/*This method will search for \r\n\r\n */

static axis2_char_t *
axiom_mime_parser_search_for_crlf(
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axiom_mime_parser_t *mime_parser)
{
    axis2_char_t *found = NULL;
    int len = 0;

    search_info->search_str = "\r\n\r\n";
    search_info->buffer1 = NULL;
    search_info->buffer2 = NULL;
    search_info->len1 = 0;
    search_info->len2 = 0;
    search_info->match_len1 = 0;
    search_info->match_len2 = 0;
    search_info->primary_search = AXIS2_FALSE;
    search_info->cached = AXIS2_FALSE;
    search_info->handler = NULL;
    search_info->binary_size = 0;

    /*First do a search in the first buffer*/

    if(buf_array[*buf_num])
    {
        search_info->buffer1 = buf_array[*buf_num];
        search_info->len1 = len_array[*buf_num];
        found = axiom_mime_parser_search_string(search_info, env);
    }

    while(!found)
    {
        /*Let's read another buffer and do a boundary search in both*/

        *buf_num = *buf_num + 1;
        buf_array[*buf_num] = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

        if(buf_array[*buf_num])
        {
            len = callback(buf_array[*buf_num], (int)size, (void *)callback_ctx);
        }
        if(len > 0)
        {
            len_array[*buf_num] = len;
            search_info->buffer2 = buf_array[*buf_num];
            search_info->len2 = len;
            found = axiom_mime_parser_search_string(search_info, env);
        }
        else
        {
            break;
        }
        if(!found)
        {
            /*Let's do a full search in the second buffer*/

            search_info->buffer1 = buf_array[*buf_num];
            search_info->len1 = len_array[*buf_num];
            search_info->primary_search = AXIS2_FALSE;
            search_info->buffer2 = NULL;
            search_info->len2 = 0;
            found = axiom_mime_parser_search_string(search_info, env);
        }
    }

    return found;
}

/* This method will search for the mime_boundary after the SOAP part 
 * of the message */

static axis2_char_t *
axiom_mime_parser_search_for_soap(
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axis2_char_t *mime_boundary,
    axiom_mime_parser_t *mime_parser)
{
    axis2_char_t *found = NULL;
    int len = 0;

    /* What we need to search is the mime_boundary */

    search_info->search_str = mime_boundary;
    search_info->buffer1 = NULL;
    search_info->buffer2 = NULL;
    search_info->len1 = 0;
    search_info->len2 = 0;
    search_info->match_len1 = 0;
    search_info->match_len2 = 0;
    search_info->primary_search = AXIS2_FALSE;

    if(buf_array[*buf_num])
    {
        search_info->buffer1 = buf_array[*buf_num];
        search_info->len1 = len_array[*buf_num];
        found = axiom_mime_parser_search_string(search_info, env);

        /* Inside this search primary_search flag will be set to TRUE */
    }

    while(!found)
    {
        /* We need to create the second buffer and do the search for the 
         * mime_boundary in the both the buffers */

        *buf_num = *buf_num + 1;
        buf_array[*buf_num] = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

        if(buf_array[*buf_num])
        {
            len = callback(buf_array[*buf_num], (int)size, (void *)callback_ctx);
        }
        if(len > 0)
        {
            /* In this search we are matching end part of the first
             * buffer and starting part of the previous buffer */
            len_array[*buf_num] = len;
            search_info->buffer2 = buf_array[*buf_num];
            search_info->len2 = len;
            found = axiom_mime_parser_search_string(search_info, env);
        }
        else
        {
            break;
        }
        if(!found)
        {
            search_info->buffer1 = buf_array[*buf_num];
            search_info->len1 = len_array[*buf_num];
            search_info->primary_search = AXIS2_FALSE;
            search_info->buffer2 = NULL;
            search_info->len2 = 0;
            found = axiom_mime_parser_search_string(search_info, env);
        }
    }

    return found;
}

/*The caching is done in this function. Caching happens when we did not 
 find the mime_boundary in initial two buffers. So the maximum size
 that we are keeping in memory is 2 * size. This size can be configurable from
 the aixs.xml. The caching may starts when the search failed with the
 second buffer.
 In this logic first we will search for a callback to cache. If it is not
 there then we will search for a directory to save the file. If it is also
 not there then the attachment will be in memory.
 */

static axis2_char_t *
axiom_mime_parser_search_for_attachment(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t * env,
    AXIS2_READ_INPUT_CALLBACK callback,
    void *callback_ctx,
    int *buf_num,
    size_t *len_array,
    axis2_char_t **buf_array,
    axiom_search_info_t *search_info,
    size_t size,
    axis2_char_t *mime_boundary,
    axis2_char_t *mime_id,
    void *user_param)
{
    axis2_char_t *found = NULL;
    int len = 0;
    axis2_status_t status = AXIS2_FAILURE;
    axis2_char_t *temp = NULL;
    size_t temp_length = 0;
    axis2_char_t *file_name = NULL;

    search_info->search_str = mime_boundary;
    search_info->buffer1 = NULL;
    search_info->buffer2 = NULL;
    search_info->len1 = 0;
    search_info->len2 = 0;
    search_info->match_len1 = 0;
    search_info->match_len2 = 0;
    search_info->primary_search = AXIS2_FALSE;
    search_info->cached = AXIS2_FALSE;
    search_info->handler = NULL;

    /*First search in the incoming buffer*/

    if(buf_array[*buf_num])
    {
        search_info->buffer1 = buf_array[*buf_num];
        search_info->len1 = len_array[*buf_num];
        found = axiom_mime_parser_search_string(search_info, env);
    }

    while(!found)
    {
        if(search_info->cached)
        {
            if(mime_parser->callback_name)
            {
                if(!(search_info->handler))
                {
                    /* If the callback is not loaded yet then we load it*/
                    if(!mime_parser->mtom_caching_callback)
                    {
                        search_info->handler = axiom_mime_parser_initiate_callback(mime_parser,
                            env, mime_id, user_param);
                        if(!(search_info->handler))
                        {
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                                "Caching Callback is not loaded");
                            return NULL;
                        }
                    }
                }
                /*So lets cache the previous buffer which has undergone the
                 full search and the partial search.  */

                if(mime_parser->mtom_caching_callback)
                {
                    /* Caching callback is loaded. So we can cache the previous buffer */
                    status
                        = AXIOM_MTOM_CACHING_CALLBACK_CACHE(mime_parser->mtom_caching_callback,
                            env, buf_array[*buf_num - 1], (int)len_array[*buf_num - 1],
                            search_info->handler);
                }
            }

            else if(mime_parser->attachment_dir)
            {
                if(!(search_info->handler))
                {
                    /* If the File is not opened yet we will open it*/

                    axis2_char_t *encoded_mime_id = NULL;

                    /* Some times content-ids urls, hence we need to encode them 
                     * becasue we can't create files with / */

                    encoded_mime_id = AXIS2_MALLOC(env->allocator, (sizeof(axis2_char_t))
                        * (strlen(mime_id)));
                    memset(encoded_mime_id, 0, strlen(mime_id));
                    encoded_mime_id = axutil_url_encode(env, encoded_mime_id, mime_id, (int)strlen(
                        mime_id));
                    if(!encoded_mime_id)
                    {
                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Mime Id encoding failed");
                        return NULL;
                    }

                    file_name = axutil_stracat(env, mime_parser->attachment_dir, encoded_mime_id);
                    AXIS2_FREE(env->allocator, encoded_mime_id);
                    encoded_mime_id = NULL;

                    if(!file_name)
                    {
                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Caching file name creation error");
                        return NULL;
                    }
                    search_info->handler = (void *)fopen(file_name, "ab+");
                    if(!(search_info->handler))
                    {
                        return NULL;
                    }
                }

                /*So lets cache the previous buffer which has undergone the
                 full search and the partial search.  */

                status = axiom_mime_parser_cache_to_file(env, buf_array[*buf_num - 1],
                    len_array[*buf_num - 1], search_info->handler);
            }

            else
            {
                /* Here the user has not specified the caching File location. So we are 
                 * not going to cache. Instead we store the attachment in the buffer */
                status = axiom_mime_parser_cache_to_buffer(env, buf_array[*buf_num - 1],
                    len_array[*buf_num - 1], search_info, mime_parser);
            }

            if(status == AXIS2_FAILURE)
            {
                return NULL;
            }
            /*Here we interchange the buffers.*/

            temp = buf_array[*buf_num - 1];
            buf_array[*buf_num - 1] = buf_array[*buf_num];
            buf_array[*buf_num] = temp;
            temp_length = len_array[*buf_num - 1];
            len_array[*buf_num - 1] = len_array[*buf_num];
            len_array[*buf_num] = temp_length;
            if(buf_array[*buf_num])
            {
                /*The cached buffer is the one which get filled.*/
                len = callback(buf_array[*buf_num], (int)size, (void *)callback_ctx);
            }
        }

        /*Size of the data in memory not yet risen to the caching threasold
         *So we can create the second buffer */
        else
        {
            *buf_num = *buf_num + 1;
            buf_array[*buf_num] = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (size + 1));

            if(buf_array[*buf_num])
            {
                len = callback(buf_array[*buf_num], (int)size, (void *)callback_ctx);
            }
        }

        /*Doing  a complete search in newly cretaed buffer*/

        if(len > 0)
        {
            len_array[*buf_num] = len;
            search_info->buffer2 = buf_array[*buf_num];
            search_info->len2 = len;
            found = axiom_mime_parser_search_string(search_info, env);
        }
        else
        {
            break;
        }

        /* Now there are two buffers. If the searching string is not 
         * here then we must cache the first buffer */

        if(!found)
        {
            /*So now we must start caching*/
            search_info->buffer1 = buf_array[*buf_num];
            search_info->len1 = len_array[*buf_num];
            search_info->primary_search = AXIS2_FALSE;
            search_info->buffer2 = NULL;
            search_info->len2 = 0;
            found = axiom_mime_parser_search_string(search_info, env);
            if(!found)
            {
                /* So at the begining of the next search we start
                 * that only after caching this data */
                search_info->cached = AXIS2_TRUE;
            }
        }
    }

    /* Here we are out of the loop. If there is no error then this means 
     * the searching string is found */
    if(search_info->cached && found)
    {
        /* If the attachment is cached then we need to cache the 
         * final buffer */

        if(search_info->match_len2 == 0)
        {
            /* This is the case where we found the whole string in one buffer 
             * So we need to cache previous buffer and the data up to the starting
             * point of the search string in the current buffer */

            /* deduct last 2 CRLF character.
             * For buffering case, it will be done when creating datahandler.*/

            if(mime_parser->mtom_caching_callback)
            {
                status = AXIOM_MTOM_CACHING_CALLBACK_CACHE(mime_parser->mtom_caching_callback, env,
                    buf_array[*buf_num - 1], (int)len_array[*buf_num - 1], search_info->handler);
                if(status == AXIS2_SUCCESS)
                {
                    status
                        = AXIOM_MTOM_CACHING_CALLBACK_CACHE(mime_parser->mtom_caching_callback,
                            env, buf_array[*buf_num], (int)(found - buf_array[*buf_num] - 2),
                            search_info->handler);
                }
            }

            else if(mime_parser->attachment_dir)
            {
                status = axiom_mime_parser_cache_to_file(env, buf_array[*buf_num - 1],
                    len_array[*buf_num - 1], search_info->handler);
                if(status == AXIS2_SUCCESS)
                {
                    status = axiom_mime_parser_cache_to_file(env, buf_array[*buf_num], found
                        - buf_array[*buf_num] - 2, search_info->handler);
                }
            }

            /* If the callback or a file is not there then the data is appended to the buffer */

            else
            {
                status = axiom_mime_parser_cache_to_buffer(env, buf_array[*buf_num - 1],
                    len_array[*buf_num - 1], search_info, mime_parser);
                if(status == AXIS2_SUCCESS)
                {
                    status = axiom_mime_parser_cache_to_buffer(env, buf_array[*buf_num], found
                        - buf_array[*buf_num], search_info, mime_parser);
                }
            }
        }
        else if(search_info->match_len2 > 0)
        {
            /*Here the curent buffer has partial mime boundary. So we need 
             to cache only the previous buffer. */

            if(mime_parser->mtom_caching_callback)
            {
                status = AXIOM_MTOM_CACHING_CALLBACK_CACHE(mime_parser->mtom_caching_callback, env,
                    buf_array[*buf_num - 1], (int)(search_info->match_len1 - 2), search_info->handler);
            }

            else if(mime_parser->attachment_dir)
            {
                status = axiom_mime_parser_cache_to_file(env, buf_array[*buf_num - 1],
                    search_info->match_len1 - 2, search_info->handler);
            }
            else
            {
                status = axiom_mime_parser_cache_to_buffer(env, buf_array[*buf_num - 1],
                    search_info->match_len1, search_info, mime_parser);
            }
        }
        else
        {
            return NULL;
        }

        if(status == AXIS2_FAILURE)
        {
            return NULL;
        }
    }

    /* Parsing is done so lets close the relative handlers */

    if(search_info->handler)
    {
        if(mime_parser->mtom_caching_callback)
        {
            status = AXIOM_MTOM_CACHING_CALLBACK_CLOSE_HANDLER(mime_parser->mtom_caching_callback,
                env, search_info->handler);
            if(status == AXIS2_FAILURE)
            {
                return NULL;
            }
        }

        else if(mime_parser->attachment_dir)
        {
            if(fclose((FILE *)(search_info->handler)) == 0)
            {
                status = AXIS2_SUCCESS;
            }
            else
            {
                status = AXIS2_FAILURE;
            }

            AXIS2_FREE(env->allocator, file_name);
            file_name = NULL;

            if(status == AXIS2_FAILURE)
            {
                return NULL;
            }
        }
    }
    return found;
}

/*following two functions are used to extract important information 
 from the buffer list. eg: SOAP, MIME_HEADERS*/

/*marker is the starting buffer of the required 
 part and pos is the end point of that part  */

static size_t
axiom_mime_parser_calculate_part_len(
    const axutil_env_t *env,
    int buf_num,
    size_t *len_list,
    int marker,
    axis2_char_t *pos,
    axis2_char_t *buf)
{
    size_t part_len = 0;
    int i = 0;

    for(i = marker; i < buf_num; i++)
    {
        part_len += len_list[i];
    }

    part_len = part_len + (pos - buf);

    return part_len;
}

static axis2_char_t *
axiom_mime_parser_create_part(
    const axutil_env_t *env,
    size_t part_len,
    int buf_num,
    size_t *len_list,
    int marker,
    axis2_char_t *pos,
    axis2_char_t **buf_list,
    axiom_mime_parser_t *mime_parser)
{
    /*We will copy the set of buffers which contains the required part.
     This part can be the SOAP message , mime headers or the mime 
     binary in the case of none cahced.*/

    axis2_char_t *part_str = NULL;
    int i = 0;
    size_t temp = 0;

    part_str = AXIS2_MALLOC(env->allocator, sizeof(char) * (part_len + 1));

    if(!part_str)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Failed in creating buffer");
        return NULL;
    }

    /* Copy from the part starting buffer to the 
     * curent buffer */

    for(i = marker; i < buf_num; i++)
    {
        if(buf_list[i])
        {
            memcpy(part_str + temp, buf_list[i], len_list[i]);
            temp += len_list[i];
        }
    }
    /* Finally we are copying from the final portion */

    memcpy(part_str + temp, buf_list[i], pos - buf_list[i]);

    part_str[part_len] = '\0';

    return part_str;
}

AXIS2_EXTERN axutil_hash_t *AXIS2_CALL
axiom_mime_parser_get_mime_parts_map(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env)
{
    return mime_parser->mime_parts_map;
}

AXIS2_EXTERN size_t AXIS2_CALL
axiom_mime_parser_get_soap_body_len(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env)
{
    return mime_parser->soap_body_len;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_mime_parser_get_soap_body_str(
    axiom_mime_parser_t * mime_parser,
    const axutil_env_t * env)
{
    return mime_parser->soap_body_str;
}

/*This is the new search function. This will first do a
 search for the entire search string.Then will do a search
 for the partial string which can be divided among two buffers.*/

static axis2_char_t *
axiom_mime_parser_search_string(
    axiom_search_info_t *search_info,
    const axutil_env_t *env)
{
    axis2_char_t *pos = NULL;
    axis2_char_t *old_pos = NULL;
    axis2_char_t *found = NULL;
    size_t str_length = 0;
    size_t search_length = 0;

    str_length = strlen(search_info->search_str);

    /*First lets search the entire buffer*/
    if(!search_info->primary_search)
    {
        old_pos = search_info->buffer1;

        do
        {
            /*find the first byte. We need to adhere to this
             approach rather than straightaway using strstr
             because the buffer1 can be containg binary data*/

            pos = NULL;

            search_length = search_info->buffer1 + search_info->len1 - old_pos - str_length + 1;

            if(search_length < 0)
            {
                break;
            }

            if(old_pos)
            {
                pos = memchr(old_pos, *(search_info->search_str), search_length);
            }

            /* found it so lets check the remaining */

            if(pos)
            {
                found = axutil_strstr(pos, search_info->search_str);
                if(found)
                {
                    search_info->match_len1 = found - search_info->buffer1;
                    break;
                }
                else
                {
                    old_pos = pos + 1;
                }
            }
        }
        while(pos);
    }

    search_info->primary_search = AXIS2_TRUE;

    if(found)
    {
        return found;
    }

    /*So we didn't find the string in the buffer
     lets check whether it is divided in two buffers*/

    else
    {
        size_t offset = 0;
        pos = NULL;
        old_pos = NULL;
        found = NULL;
        search_length = 0;

        if(search_info->buffer2)
        {
            old_pos = search_info->buffer1 + search_info->len1 - str_length + 1;
            do
            {
                /*First check the starting byte*/
                pos = NULL;
                found = NULL;

                search_length = search_info->buffer1 + search_info->len1 - old_pos;

                if(search_length < 0)
                {
                    break;
                }

                pos = memchr(old_pos, *(search_info->search_str), search_length);

                if(pos)
                {
                    offset = search_info->buffer1 + search_info->len1 - pos;

                    /*First match the beginng to offset in buffer1*/

                    if(offset > 0)
                    {
                        if(memcmp(pos, search_info->search_str, offset) == 0)
                        {
                            found = pos;
                        }

                        /*We found something in buffer1 so lets match the
                         remaining in buffer2*/

                        if(found)
                        {
                            if(memcmp(search_info->buffer2, search_info->search_str + offset,
                                str_length - offset) == 0)
                            {
                                search_info->match_len2 = str_length - offset;
                                search_info->match_len1 = found - search_info->buffer1;
                                break;
                            }
                            else
                            {
                                old_pos = pos + 1;
                            }
                        }
                        else
                        {
                            old_pos = pos + 1;
                        }
                    }
                }
            }
            while(pos);

            /* We will set this to AXIS2_FALSE so when the next time this
             * search method is called it will do a full search first for buffer1 */
            search_info->primary_search = AXIS2_FALSE;

            return found;
        }
        else
        {
            return NULL;
        }
    }
}

/* This method creates a data_handler out of the attachment 
 * and store the data_handler in the mime_parts map */

static axis2_status_t
axiom_mime_parser_store_attachment(
    const axutil_env_t *env,
    axiom_mime_parser_t *mime_parser,
    axis2_char_t *mime_id,
    axis2_char_t *mime_type,
    axis2_char_t *mime_binary,
    size_t mime_binary_len,
    axis2_bool_t cached)
{
    if(mime_parser->mime_parts_map)
    {
        if(mime_id)
        {
            axiom_data_handler_t *data_handler = NULL;

            /* Handling the case where attachment is cached using a callback */

            if(mime_parser->callback_name && cached)
            {
                data_handler = axiom_data_handler_create(env, NULL, mime_type);
                if(data_handler)
                {
                    axiom_data_handler_set_cached(data_handler, env, AXIS2_TRUE);
                    axiom_data_handler_set_data_handler_type(data_handler, env,
                        AXIOM_DATA_HANDLER_TYPE_CALLBACK);
                }
            }

            /* Handling the case where attachment is cached to a file*/

            else if(mime_parser->attachment_dir && cached)
            {
                axis2_char_t *attachment_location = NULL;
                axis2_char_t *encoded_mime_id = NULL;

                /* Some times content-ids urls, hence we need to encode them 
                 * becasue we can't create files with / */

                encoded_mime_id = AXIS2_MALLOC(env->allocator, (sizeof(axis2_char_t)) * (strlen(
                    mime_id)));
                memset(encoded_mime_id, 0, strlen(mime_id));
                encoded_mime_id = axutil_url_encode(
                    env, encoded_mime_id, mime_id, (int)strlen(mime_id));
                if(!encoded_mime_id)
                {
                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Mime Id encoding failed");
                    return AXIS2_FAILURE;
                }

                attachment_location = axutil_stracat(env, mime_parser->attachment_dir,
                    encoded_mime_id);

                AXIS2_FREE(env->allocator, encoded_mime_id);
                encoded_mime_id = NULL;

                if(attachment_location)
                {

                    data_handler = axiom_data_handler_create(env, attachment_location, mime_type);
                    if(data_handler)
                    {
                        axiom_data_handler_set_cached(data_handler, env, AXIS2_TRUE);

                    }
                    AXIS2_FREE(env->allocator, attachment_location);
                    attachment_location = NULL;
                }
            }

            /* Attachment is in memory, either it is small to be cached or
             * user does not provided the attachment cached directory */

            else if(mime_binary)
            {
                data_handler = axiom_data_handler_create(env, NULL, mime_type);
                if(data_handler)
                {
                    axiom_data_handler_set_binary_data(data_handler, env, mime_binary,
                        mime_binary_len - 2);
                }
            }
            axiom_data_handler_set_mime_id(data_handler, env, mime_id);

            axutil_hash_set(mime_parser->mime_parts_map, mime_id, AXIS2_HASH_KEY_STRING,
                data_handler);
            if(mime_type)
            {
                AXIS2_FREE(env->allocator, mime_type);
            }
        }
        else
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Mime Id or Mime rype not found");
            return AXIS2_FAILURE;
            /*axis2_char_t temp_boundry[1024];
             sprintf(temp_boundry, "--%s--", mime_boundary);
             if (body_mime && axutil_strstr(body_mime, temp_boundry))
             {
             break;
             }*/
        }
        return AXIS2_SUCCESS;
    }
    else
    {
        return AXIS2_FAILURE;
    }
}

/* This method will process the mime_headers for a particualr
 attacment and return the mime_id  */

static axis2_char_t *
axiom_mime_parser_process_mime_headers(
    const axutil_env_t *env,
    axiom_mime_parser_t *mime_parser,
    axis2_char_t **mime_id,
    axis2_char_t *mime_headers)
{
    axis2_char_t *id = NULL;
    axis2_char_t *type = NULL;
    axis2_char_t *pos = NULL;

    /* Get the MIME ID */
    if(mime_headers)
    {
        id = axutil_strcasestr(mime_headers, AXIOM_MIME_HEADER_CONTENT_ID);
        type = axutil_strcasestr(mime_headers, AXIOM_MIME_HEADER_CONTENT_TYPE);
        if(type)
        {
            axis2_char_t *end = NULL;
            axis2_char_t *temp_type = NULL;
            type += axutil_strlen(AXIOM_MIME_HEADER_CONTENT_TYPE);
            while(type && *type && *type != ':')
            {
                type++;
            }
            type++;
            while(type && *type && *type == ' ')
            {
                type++;
            }
            end = type;
            while(end && *end && !isspace((int)*end))
            {
                end++;
            }
            if((end - type) > 0)
            {
                temp_type = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * ((end - type) + 1));
                if(!temp_type)
                {
                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                        "No memory. Failed in creating Content-Type");
                    return NULL;
                }
                memcpy(temp_type, type, (end - type));
                temp_type[end - type] = '\0';
                type = temp_type;
            }
        }
        if(id)
        {
            id += axutil_strlen(AXIOM_MIME_HEADER_CONTENT_ID);
            while(id && *id && *id != ':')
            {
                id++;
            }
            if(id)
            {
                while(id && *id && *id != '<')
                {
                    id++;
                }
                id++;
                pos = axutil_strstr(id, ">");
                if(pos)
                {
                    int mime_id_len = 0;
                    mime_id_len = (int)(pos - id);
                    *mime_id = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * mime_id_len + 1);
                    /* The MIME ID will be freed by the SOAP builder */
                    if(*mime_id)
                    {
                        memcpy(*mime_id, id, mime_id_len);
                        (*mime_id)[mime_id_len] = '\0';
                    }
                    else
                    {
                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                            "No memory. Failed in creating MIME ID");
                        return NULL;
                    }
                }
            }
        }
        else
        {
            /*axis2_char_t temp_boundry[1024];
             sprintf(temp_boundry, "--%s--", mime_boundary);
             if (body_mime && axutil_strstr(body_mime, temp_boundry))
             {
             break;
             }*/
            return NULL;
        }
        return type;
    }
    else
    {
        return NULL;
    }
}

/*This is used to free some unwanted buffers. For example we did
 not want the buffers which contains the data before the soap
 envelope starts. */

static void
axiom_mime_parser_clear_buffers(
    const axutil_env_t *env,
    axis2_char_t **buf_list,
    int free_from,
    int free_to)
{
    int i = 0;

    for(i = free_from; i <= free_to; i++)
    {
        if(buf_list[i])
        {
            AXIS2_FREE(env->allocator, buf_list[i]);
            buf_list[i] = NULL;
        }
    }
    return;
}

/* Instead of caching to a file this method will cache it
 * to a buffer */

static axis2_status_t
axiom_mime_parser_cache_to_buffer(
    const axutil_env_t *env,
    axis2_char_t *buf,
    size_t buf_len,
    axiom_search_info_t *search_info,
    axiom_mime_parser_t *mime_parser)
{
    axis2_char_t *data_buffer = NULL;
    axis2_char_t *temp_buf = NULL;
    size_t mime_binary_len = 0;

    temp_buf = (axis2_char_t *)search_info->handler;
    mime_binary_len = search_info->binary_size + buf_len;

    if(mime_binary_len > 0)
    {
        data_buffer = AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (mime_binary_len));

        if(data_buffer)
        {
            if(temp_buf && search_info->binary_size > 0)
            {
                memcpy(data_buffer, temp_buf, search_info->binary_size);
                AXIS2_FREE(env->allocator, temp_buf);
                temp_buf = NULL;
            }
            memcpy(data_buffer + (search_info->binary_size), buf, buf_len);
            search_info->binary_size = mime_binary_len;
            search_info->handler = (void *)data_buffer;

            return AXIS2_SUCCESS;
        }
        else
        {
            return AXIS2_FAILURE;
        }
    }
    else
    {
        return AXIS2_FAILURE;
    }
}

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_set_buffer_size(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    int size)
{
    mime_parser->buffer_size = size;
}

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_set_max_buffers(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    int num)
{
    mime_parser->max_buffers = num;
}

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_set_attachment_dir(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_char_t *attachment_dir)
{
    mime_parser->attachment_dir = attachment_dir;
}

/* Set the path of the caching callnack to be loaded */

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_set_caching_callback_name(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_char_t *callback_name)
{
    mime_parser->callback_name = callback_name;
}

AXIS2_EXTERN void AXIS2_CALL
axiom_mime_parser_set_mime_boundary(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_char_t *mime_boundary)
{
    mime_parser->mime_boundary = mime_boundary;
}

AXIS2_EXTERN axis2_char_t *AXIS2_CALL
axiom_mime_parser_get_mime_boundary(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env)
{
    return mime_parser->mime_boundary;
}

/* Load the caching callback dll */

static void*
axiom_mime_parser_initiate_callback(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_char_t *mime_id,
    void *user_param)
{
    axutil_dll_desc_t *dll_desc = NULL;
    axutil_param_t *impl_info_param = NULL;
    void *ptr = NULL;

    if(mime_parser->callback_name)
    {
        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Trying to load module = %s",
            mime_parser->callback_name);
        dll_desc = axutil_dll_desc_create(env);
        axutil_dll_desc_set_name(dll_desc, env, mime_parser->callback_name);
        impl_info_param = axutil_param_create(env, NULL, dll_desc);
        /*Set the free function*/
        axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg);
        axutil_class_loader_init(env);
        ptr = axutil_class_loader_create_dll(env, impl_info_param);

        if(!ptr)
        {
            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to load the module %s. ERROR",
                mime_parser->callback_name);
            return NULL;
        }

        mime_parser->mtom_caching_callback = (axiom_mtom_caching_callback_t *)ptr;
        mime_parser->mtom_caching_callback->param = impl_info_param;
        mime_parser->mtom_caching_callback->user_param = user_param;

        return AXIOM_MTOM_CACHING_CALLBACK_INIT_HANDLER(mime_parser->mtom_caching_callback, env,
            mime_id);
    }

    else
    {
        return NULL;
    }

}

/* This method will tell whether there are more data in the 
 * stream */

static axis2_bool_t
axiom_mime_parser_is_more_data(
    axiom_mime_parser_t *mime_parser,
    const axutil_env_t *env,
    axis2_callback_info_t *callback_info)
{
    /* In the case of axutil_http_chunked stream it is the 
     * end of chunk */

    if(callback_info->chunked_stream)
    {
        if(axutil_http_chunked_stream_get_end_of_chunks(callback_info->chunked_stream, env))
        {
            return AXIS2_FALSE;
        }
        else
        {
            return AXIS2_TRUE;
        }
    }

    /* When we are using content length or any wrapped 
     * stream it will be the unread_length */

    else if(callback_info->unread_len == 0)
    {
        return AXIS2_FALSE;
    }
    else
    {
        return AXIS2_TRUE;
    }
}

static axis2_status_t
axiom_mime_parser_cache_to_file(
    const axutil_env_t* env,
    axis2_char_t *buf,
    size_t buf_len,
    void *handler)
{
    size_t len = 0;
    FILE *fp = NULL;

    fp = (FILE *)handler;

    len = fwrite(buf, 1, buf_len, fp);
    if(len < 0)
    {
        return AXIS2_FAILURE;
    }
    else
    {
        return AXIS2_SUCCESS;
    }
}