root/msg/entity.cc

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "content_type.hh"
#include "entity.hh"
#include "lexutils.hh"
#include "message_entity.hh"
#include "multipart.hh"
#include "text_plain.hh"
#include "util.hh"
#include "raw_entity.hh"

#include "../util.hh"

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/format.hpp>
#include <boost/nondet_random.hpp>

#include "../assert.hh"

namespace msg
{
        size_t entity::get_size() const
        {
                std::string body = get_body();
                size_t n = 0;
                for (field_iterator it = fields_begin();
                     it != fields_end(); it++)
                {
                        n += it->length();
                }
                n += 2;
                n += body.length();
                return n;
        }

        size_t entity::get_body_lines() const
        {
                std::string body = get_body();
                unsigned long lines = -1;
                size_t inx = std::string::npos;
                do
                {
                        inx++;
                        lines++;
                        inx = body.find("\r\n", inx);
                } while (inx != std::string::npos);
                return lines;
        }

        entity::ptr entity::mk(std::string ms, bool validate, std::string dct)
        {
                entity_header::ptr hdr(new entity_header(ms, validate, dct));

                entity::ptr rv;
                content_type ct = hdr->get_content_type();
                switch (ct.get_type())
                {
                case content_type::MESSAGE:
                        rv.reset(new message_entity(hdr, ms));
                        break;
                case content_type::MULTIPART:
                        rv.reset(new multipart(hdr, ms));
                        break;
                case content_type::TEXT:
                        rv.reset(new text_plain(hdr, ms));
                        break;
                default:
                        rv.reset(new raw_entity(hdr, ms));
                        break;
                }
                return rv;
        }

        multipart::ptr entity::clone_as_multipart() const
        {
                static const char content_[] = "content-";
                boost::random_device urand;

                entity_header::ptr envh(new entity_header(*hdr));
                entity_header::ptr subh(new entity_header(DEFAULT_CT));

                for (field_iterator it = hdr->fields_begin();
                     it != hdr->fields_end(); it++)
                {
                        std::string fld = *it;
                        size_t colon = fld.find(':');
                        if (colon == std::string::npos) colon = 0;
                        std::string name = fld.substr(0, colon);
                        size_t start = colon + 1 < fld.length()
                                ? (fld[colon+1] == ' ' ? colon + 1 : colon)
                                : colon;
                        std::string content = fld.substr(start);
                        util::strip_crlf(content);
                        boost::to_lower(name);
                        if (name.substr(0, sizeof content_ - 1) != content_)
                                continue;
                        subh->replace_field(name, content);
                        envh->delete_field(name);
                }

                std::string body = get_body();

                std::string boundary;
        redo:
                {
                        std::ostringstream ss;
                        ss << urand() << urand() << urand() << urand();
                        if (body.find(ss.str()) != std::string::npos)
                                goto redo;
                        boundary = ss.str();
                }

                bool bit8 = false;
                for (size_t i = 0; i < body.length(); i++)
                {
                        if ((unsigned char)body[i] > 0x7f)
                        {
                                bit8 = true;
                                break;
                        }
                }

                envh->replace_field("MIME-Version", "1.0");
                envh->add_field("Content-Type",
                                std::string("multipart/mixed; boundary=") +
                                make_phrase(boundary));
                envh->add_field("Content-Transfer-Encoding",
                                bit8 ? "8bit" : "7bit");

                std::ostringstream nbss;
                nbss << "--" << boundary << "\r\n"
                     << subh->get_header() << "\r\n"
                     << body
                     << "\r\n--" << boundary << "--\r\n";
                
                multipart::ptr rv(new multipart(envh, nbss.str()));
                return rv;
        }

}