mime_part.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "mime_part.h"
#include "regexp.h"
#include "file.h"
#include "exception.h"
#include "string_help.h"

// CL_MimePart Construction:

CL_MimePart::CL_MimePart()
: header_pos(0), header_length(0), body_pos(0), body_length(0)
{
}

CL_MimePart::CL_MimePart(const CL_MimePart &copy)
: headers(copy.headers), header_pos(copy.header_pos), header_length(copy.header_length),
        body_pos(copy.body_pos), body_length(copy.body_length), parts(copy.parts)
{
}

// CL_MimePart Attributes:

// CL_MimePart Operations:

CL_MimePart &CL_MimePart::operator =(const CL_MimePart &copy)
{
        headers = copy.headers;
        header_pos = copy.header_pos;
        header_length = copy.header_length;
        body_pos = copy.body_pos;
        body_length = copy.body_length;
        parts = copy.parts;
        return *this;
}

void CL_MimePart::load(CL_File &file, const CL_StringA &next_mime_boundary)
{
        // Reset mime part:
        headers.clear();
        header_pos = file.get_position();
        header_length = 0;
        body_pos = 0;
        body_length = 0;
        parts.clear();

        // Look for header end:
        char buffer[16*1024];
        int bytes_read = file.read(buffer, 16*1024);
        if (bytes_read <= 0)
                throw CL_Exception(TEXT("Premature end of MIME document"));

        CL_RegExp regexp_header_end("\\r\\n(\\r\\n)");
        CL_RegExpMatch match_header_end = regexp_header_end.search(buffer, bytes_read);
        if (!match_header_end.is_match())
                throw CL_Exception(TEXT("Premature end of MIME entity header"));

        header_length = match_header_end.get_capture_pos(1);
        headers = CL_StringA(
                buffer,
                header_length);

        body_pos = header_pos + match_header_end.get_capture_pos(0)+match_header_end.get_capture_length(0);
        body_length = 0;
        file.seek(body_pos);

        // Examine header we got:
        CL_StringA content_type = get_content_type();
        CL_RegExp regexp_multipart("multipart\\/|message\\/", CL_RegExp::compile_caseless);
        bool is_multipart = regexp_multipart.search(content_type).is_match();

        // Read body:
        CL_RegExp boundary_begin_exp("\\r\\n--");
        CL_RegExp boundary_end_exp(".*?\\r\\n");
        CL_RegExpMatch match_result;
        if (is_multipart)
        {
                CL_StringA boundary = get_content_type_parameter_value("boundary");
                if (boundary.empty())
                        throw CL_Exception(CL_StringHelp::local8_to_text(content_type) + TEXT(" missing expected boundary parameter"));

                // Find end of multipart descriptional body:
                int offset = 0;
                file.seek(body_pos-2);
                bytes_read = file.read(buffer, 16*1024);
                if (bytes_read <= 0)
                        throw CL_Exception(TEXT("Premature end of MIME entity"));

                // Get offset to point at the end of the boundary, but not including any possible additional boundary whitespace.
                while (true)
                {
                        boundary_begin_exp.search(buffer, bytes_read, offset, 0, match_result);
                        if (!match_result.is_match())
                                throw CL_Exception(TEXT("MIME boundary not found"));
                        offset = match_result.get_capture_pos(0) + match_result.get_capture_length(0);
                        if (offset + boundary.length() > 16*1024)
                                throw CL_Exception(TEXT("MIME boundary not found"));
                        if (memcmp(boundary.data(), buffer+offset, boundary.length()) == 0)
                                break;
                }

                // Body should be anything between header and body start boundary marker:
                body_length = offset-4;
                if (body_length < 0)
                        body_length = 0;

                // Look for end of boundary line:
                boundary_end_exp.search(buffer, bytes_read, offset, 0, match_result);
                if (!match_result.is_match())
                        throw CL_Exception(TEXT("MIME boundary marker line never ended!"));
                int multipart_start = body_pos-2+match_result.get_capture_pos(0)+match_result.get_capture_length(0);
                file.seek(multipart_start);

                // Read multipart parts:
                while (true)
                {
                        CL_MimePart child_part;
                        child_part.load(file, boundary);
                        parts.push_back(child_part);

                        // End of multiparts marker?
                        bytes_read = file.read(buffer, 4);
                        if (bytes_read < 4)
                                throw CL_Exception(TEXT("Premature end of MIME entity"));
                        if (memcmp(buffer, "--\r\n", 4) == 0)
                                break;
                        else
                                file.seek(-4, CL_File::seek_cur);
                }

                // Find next mime boundary, if needed:
                if (!next_mime_boundary.empty())
                {
                        int pos = file.get_position();
                        int offset = 0;
                        bytes_read = file.read(buffer, 16*1024);
                        if (bytes_read <= 0)
                                throw CL_Exception(TEXT("Premature end of MIME entity"));

                        // Get offset to point at the end of the boundary, but not including any possible additional boundary whitespace.
                        while (true)
                        {
                                boundary_begin_exp.search(buffer, bytes_read, offset, 0, match_result);
                                if (!match_result.is_match())
                                        throw CL_Exception(TEXT("MIME boundary not found"));
                                offset = match_result.get_capture_pos(0) + match_result.get_capture_length(0);
                                if (offset + boundary.length() > 16*1024)
                                        throw CL_Exception(TEXT("MIME boundary not found"));
                                if (memcmp(boundary.data(), buffer+offset, boundary.length()) == 0)
                                        break;
                        }

                        // Look for end of boundary line:
                        boundary_end_exp.search(buffer, bytes_read, offset, 0, match_result);
                        if (!match_result.is_match())
                                throw CL_Exception(TEXT("MIME boundary marker line never ended!"));
                        int multipart_end = pos + match_result.get_capture_pos(0)+match_result.get_capture_length(0);
                        file.seek(multipart_end);
                }
        }
        else if (!next_mime_boundary.empty())
        {
                int offset = 0;
                bytes_read = file.read(buffer, 16*1024);
                if (bytes_read <= 0)
                        throw CL_Exception(TEXT("Premature end of MIME entity"));

                // Get offset to point at the end of the boundary, but not including any possible additional boundary whitespace.
                while (true)
                {
                        boundary_begin_exp.search(buffer, bytes_read, offset, CL_RegExp::search_partial, match_result);
                        if (match_result.is_match() || match_result.is_partial())
                        {
                                int start_match_offset = match_result.get_capture_pos(0);
                                int boundary_begin_size = 4;
                                int end_match_offset = start_match_offset + boundary_begin_size + next_mime_boundary.length();
                                if (end_match_offset > bytes_read)
                                {
                                        // Partial match. Need more data to complete match.
                                        int size = bytes_read-start_match_offset;
                                        memcpy(buffer, buffer+start_match_offset, size);
                                        bytes_read = file.read(buffer+size, 16*1024-size);
                                        if (bytes_read <= 0)
                                                throw CL_Exception(TEXT("Premature end of MIME entity"));
                                        bytes_read += size;
                                        offset = 0;
                                        continue;
                                }

                                if (memcmp(
                                        buffer+start_match_offset+boundary_begin_size,
                                        next_mime_boundary.data(),
                                        next_mime_boundary.length()) == 0)
                                {
                                        // Full match.
                                        file.seek(end_match_offset - bytes_read, CL_File::seek_cur);
                                        body_length = file.get_position()-boundary_begin_size - body_pos;
                                        break;
                                }

                                offset = start_match_offset + boundary_begin_size;
                        }
                        else
                        {
                                offset = 0;
                                bytes_read = file.read(buffer, 16*1024);
                                if (bytes_read <= 0)
                                        throw CL_Exception(TEXT("Premature end of MIME entity"));
                        }
                }
        }
        else
        {
                body_length = file.get_size()-body_pos;
        }
}

CL_StringA CL_MimePart::get_content_id() const
{
        CL_RegExp regexp("^Content-ID\\s*:\\s*(\\\"<.*?>\\\"|<\\.+?>)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (match.is_match())
        {
                CL_StringA id = headers.substr(match.get_capture_pos(1)+1, match.get_capture_length(1)-2);
                if (id[0] == '<')
                        id = id.substr(1, id.length()-2);
                return id;
        }
        return CL_StringA();
}

bool CL_MimePart::has_content_id() const
{
        CL_RegExp regexp("^Content-ID\\s*:\\s*(\\\"<.*?>\\\"|<\\.+?>)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        return match.is_match();
}

CL_StringA CL_MimePart::get_content_description() const
{
        CL_RegExp regexp("^Content-Description\\s*:\\s*(\\\".*?\\\"|\\w+)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (match.is_match())
        {
                CL_StringA description = headers.substr(match.get_capture_pos(1), match.get_capture_length(1));
                if (description[0] == '"')
                        description = description.substr(1, description.length()-2);
                return description;
        }
        return CL_StringA();
}

bool CL_MimePart::has_content_description() const
{
        CL_RegExp regexp("^Content-Description\\s*:\\s*(\\\".*?\\\"|\\w+)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        return match.is_match();
}

CL_StringA CL_MimePart::get_content_transfer_encoding() const
{
        CL_RegExp regexp("^Content-Transfer-Encoding\\s*:\\s*(\\\".*?\\\"|\\w+)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (match.is_match())
        {
                CL_StringA encoding = headers.substr(match.get_capture_pos(1), match.get_capture_length(1));
                if (encoding[0] == '"')
                        encoding = encoding.substr(1, encoding.length()-2);
                return encoding;
        }
        return CL_StringA("7bit");
}

CL_StringA CL_MimePart::get_content_type() const
{
        CL_RegExp regexp("^Content-Type\\s*:\\s*(\\\".*?\\\"|\\w+/\\w+)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (match.is_match())
        {
                CL_StringA content_type = headers.substr(match.get_capture_pos(1), match.get_capture_length(1));
                if (content_type[0] == '"')
                        content_type = content_type.substr(1, content_type.length()-2);
                return content_type;
        }
        return CL_StringA("text/plain");
}

bool CL_MimePart::has_content_type() const
{
        CL_RegExp regexp("^Content-Type\\s*:\\s*(\\\".*?\\\"|\\w+/\\w+)", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (match.is_match())
                return true;
        return false;
}

CL_StringA CL_MimePart::get_content_type_parameters() const
{
        CL_RegExp regexp("^Content-Type\\s*:\\s*(\\\".*?\\\"|\\w+/\\w+)\\s*;\\s*", CL_RegExp::compile_multi_line|CL_RegExp::compile_caseless);
        CL_RegExpMatch match = regexp.search(headers);
        if (!match.is_match())
                return CL_StringA();
        int parameters_offset = match.get_capture_pos(0)+match.get_capture_length(0);
        CL_RegExp regexp_next_line("^\\w+\\s*:", CL_RegExp::compile_multi_line);
        CL_RegExpMatch match_next_line = regexp_next_line.search(headers, parameters_offset);
        if (match_next_line.is_match())
                return headers.substr(parameters_offset, match_next_line.get_capture_pos(0)-parameters_offset);
        else
                return headers.substr(parameters_offset);
}

CL_StringA CL_MimePart::get_content_type_parameter_value(const CL_StringA &search_name) const
{
        if (!has_content_type())
        {
                // If no Content-Type header exist, the default content type is:
                //     Content-type: text/plain; charset=us-ascii
                if (CL_StringHelp::compare(search_name, "charset", true) == 0)
                        return CL_StringA("us-ascii");
                return CL_StringA();
        }

        CL_StringA parameters = get_content_type_parameters();

        CL_RegExp regexp("\\s*(\\w+)\\s*=(\".*?\"|\\w*)\\s*;*");
        int offset = 0;
        while (true)
        {
                CL_RegExpMatch match = regexp.search(parameters, offset);
                if (!match.is_match())
                        break;
                CL_StringA name = parameters.substr(match.get_capture_pos(1), match.get_capture_length(1));
                CL_StringA value = parameters.substr(match.get_capture_pos(2), match.get_capture_length(2));
                if (value[0] == '"')
                        value = value.substr(1, value.length()-2);
                if (CL_StringHelp::compare(search_name, name, true) == 0)
                        return value;
                offset = match.get_capture_pos(0)+match.get_capture_length(0);
        }
        return CL_StringA();
}

bool CL_MimePart::has_content_type_parameter(const CL_StringA &search_name) const
{
        if (!has_content_type())
        {
                // If no Content-Type header exist, the default content type is:
                //     Content-type: text/plain; charset=us-ascii
                if (CL_StringHelp::compare(search_name, "charset", true) == 0)
                        return true;
                return false;
        }

        CL_StringA parameters = get_content_type_parameters();

        CL_RegExp regexp("\\s*(\\w+)\\s*=(\".*?\"|\\w*)\\s*;*");
        int offset = 0;
        while (true)
        {
                CL_RegExpMatch match = regexp.search(parameters, offset);
                if (!match.is_match())
                        break;
                CL_StringA name = parameters.substr(match.get_capture_pos(1), match.get_capture_length(1));
                if (CL_StringHelp::compare(search_name, name, true) == 0)
                        return true;
                offset = match.get_capture_pos(0)+match.get_capture_length(0);
        }

        return false;
}

int CL_MimePart::get_header_lines_count() const
{
        CL_RegExp regexp("^\\w+\\s*:", CL_RegExp::compile_multi_line);
        int offset = 0;
        int matches = 0;
        while (true)
        {
                CL_RegExpMatch match = regexp.search(headers, offset);
                if (!match.is_match())
                        break;
                offset = match.get_capture_pos(0)+match.get_capture_length(0);
                matches++;
        }
        return matches;
}

CL_StringA CL_MimePart::get_header_line(int line) const
{
        CL_RegExp regexp("^\\w+\\s*:", CL_RegExp::compile_multi_line);
        int offset = 0;
        int matches = 0;
        while (true)
        {
                CL_RegExpMatch match = regexp.search(headers, offset);
                if (!match.is_match())
                        break;
                offset = match.get_capture_pos(0)+match.get_capture_length(0);
                if (matches == line)
                {
                        CL_RegExpMatch match_next_line = regexp.search(headers, offset);
                        if (match.is_match())
                                return headers.substr(
                                        match.get_capture_pos(0),
                                        match_next_line.get_capture_pos(0)-match.get_capture_pos(0));
                        else
                                return headers.substr(match.get_capture_pos(0));
                }
                matches++;
        }
        return CL_StringA();
}

// CL_MimePart Implementation:

---