Changeset 99057e4d73dbb905f06f5ccc4ea49708b8aaa0a8

Timestamp:

09/19/10 20:59:45 (20 months ago)

Author:

Antti-Juhani Kaijanaho <antti-juhani@…>

Children:

11cf105fe323361072281747558cb61752f33fa8

Parents:

81c6e32180ba6f1018c28ae75b7281fd38121812

git-committer:

Antti-Juhani Kaijanaho <antti-juhani@…> (09/19/10 20:59:45)

Message:

Rework entity handling

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>

Files:

• db/db.cc (modified) (1 diff)
• db/group.cc (modified) (1 diff)
• http/article_entry.cc (modified) (1 diff)
• http/article_entry.hh (modified) (1 diff)
• http/compose.cc (modified) (2 diffs)
• http/feed_resource.cc (modified) (2 diffs)
• http/feed_resource.hh (modified) (2 diffs)
• local/connection.cc (modified) (2 diffs)
• msg/content_type.hh (modified) (2 diffs)
• msg/entity.cc (modified) (5 diffs)
• msg/entity.hh (modified) (2 diffs)
• msg/entity_header.cc (added)
• msg/entity_header.hh (added)
• msg/message_entity.cc (modified) (2 diffs)
• msg/message_entity.hh (modified) (1 diff)
• msg/mime_entity.hh (deleted)
• msg/multipart.cc (modified) (5 diffs)
• msg/multipart.hh (modified) (1 diff)
• msg/raw_entity.hh (added)
• msg/text_plain.cc (modified) (2 diffs)
• msg/text_plain.hh (modified) (5 diffs)
• msg/util.cc (modified) (1 diff)
• nntp/post.cc (modified) (1 diff)
• smtp_client/smtp_client.cc (modified) (1 diff)
• tlate/date_value.cc (modified) (1 diff)
• tlate/msg_value.cc (modified) (2 diffs)

db/db.cc

@@ -225 +225 @@
 
                 // commit
-                ::msg::entity::ptr entity(new ::msg::entity(msgstr));
+                ::msg::entity::ptr entity = ::msg::entity::mk(msgstr, false);
                 msg::ptr message(new msg::msg(msgid,entity));
                 for (std::map<std::string, group::number>::const_iterator it = 

db/group.cc

@@ -69 +69 @@
                 if (recv.empty()) return rv;
 
-                ::msg::entity::ptr nm(new ::msg::entity(*m->get_entity()));
+                ::msg::entity::ptr nm = m->get_entity()->clone();
                 {
                         std::string subject = nm->get_field("subject", false);

http/article_entry.cc

@@ -65 +65 @@
         }
 
-        boost::shared_ptr<const msg::mime_entity>
+        boost::shared_ptr<const msg::entity>
         article_entry::get_content() const
         {
                 db::msg::const_ptr m = tn->get_article();
-                return m->get_entity()->get_mime_entity();
+                return m->get_entity();
         }
 

http/article_entry.hh

@@ -42 +42 @@
                 std::string get_title() const;
                 std::string get_author() const;
-                boost::shared_ptr<const msg::mime_entity> get_content() const;
+                boost::shared_ptr<const msg::entity> get_content() const;
                 std::string get_link() const;
                 boost::posix_time::ptime get_date() const;

http/compose.cc

@@ -228 +228 @@
                 try
                 {
-                        msg::entity::ptr e(new msg::entity(os.str()));
+                        msg::entity::ptr e = msg::entity::mk(os.str(), false);
                         msg::complete_mime(e);
                         m = cb.dbase().file(e, req->get_peer(), usr, cb);
@@ -382 +382 @@
                 body << from << " wrote: \n\n";
 
-                msg::text_plain tp(*precursor->get_entity());
+                msg::text_plain tp(precursor->get_entity());
 
                 for (size_t i = 0; i < tp.num_paras(); i++)

http/feed_resource.cc

@@ -27 +27 @@
 #include "../logger/logline.hh"
 #include "../html/util.hh"
-#include "../msg/mime_entity.hh"
+#include "../msg/entity.hh"
 
 namespace
@@ -100 +100 @@
                      it != entries.end(); it++)
                 {
-                        msg::mime_entity::const_ptr me = (*it)->get_content();
+                        msg::entity::const_ptr me = (*it)->get_content();
                         tlate::value::ptr tv = me->get_tlate_value(true);
                         tlate::data_model::ptr am(new tlate::data_model);

http/feed_resource.hh

@@ -29 +29 @@
 #include <list>
 
-namespace msg { class mime_entity; }
+namespace msg { class entity; }
 
 namespace http
@@ -61 +61 @@
                         virtual std::string get_title() const = 0;
                         virtual std::string get_author() const = 0;
-                        virtual boost::shared_ptr<const msg::mime_entity>
+                        virtual boost::shared_ptr<const msg::entity>
                         get_content() const = 0;
                         virtual std::string get_link() const = 0;

local/connection.cc

@@ -99 +99 @@
                                         util::streambuf_to_string(*sbp, n);
                                 if (s.length() > n) s.resize(n);
-                                ent.reset(new msg::entity(s));
+                                ent = msg::entity::mk(s, false);
                         }
                         catch (msg::format_violation &fv)
@@ -113 +113 @@
                         }
 
-                        msg::entity::ptr m(new msg::entity(ms));
+                        msg::entity::ptr m(msg::entity::mk(ms, false));
 
                         // identify action

msg/content_type.hh

@@ -1 +1 @@
 /*  This file is part of Alue, the multiprotocol Internet discussion daemon
 
-    Copyright © 2009 Antti-Juhani Kaijanaho
+    Copyright © 2009, 2010 Antti-Juhani Kaijanaho
 
     Alue is free software: you can redistribute it and/or modify it
@@ -51 +51 @@
                         return it->second;
                 }
+                void set_param(std::string name, std::string value) {
+                        params[name] = value;
+                }
 
                 std::string to_string() const;

msg/entity.cc

@@ -24 +24 @@
 #include "text_plain.hh"
 #include "util.hh"
+#include "raw_entity.hh"
 
 #include "../util.hh"
@@ -32 +33 @@
 #include "../assert.hh"
 
-namespace
-{
-        // RFC 5322 ftext
-        inline bool is_ftext(char c)
-        {
-                return  (33 <= c && c <=  57) ||
-                        (59 <= c && c <= 126);
-        }
-
-        // RFC 5234 VCHAR
-        inline bool is_vchar(char c)
-        {
-                return 0x21 <= c && c <= 0x7e;
-        }
-
-        // RFC 5234 WSP
-        inline bool is_wsp(char c)
-        {
-                return c == ' ' || c == '\t';
-        }
-
-}
-
 namespace msg
 {
-        entity::entity(const entity &ent)
-                : default_ct(ent.default_ct)
-                , field_content(ent.field_content)
-                , body(ent.body)
-                , the_date(boost::posix_time::not_a_date_time)
-        {
-                for (std::list<std::string>::iterator it=field_content.begin();
-                     it != field_content.end(); it++)
-                {
-                        std::string fc = *it;
-                        size_t colon = fc.find(':');
-                        assert(colon != std::string::npos);
-                        std::string fn = util::to_lower(fc.substr(0, colon));
-                        fields[fn] = it;
-                }
-        }
-
-        entity::entity(std::string msgstr,
-                       std::string default_ct)
-                : default_ct(default_ct)
-                , the_date(boost::posix_time::not_a_date_time)
-        {
-                parse_headers(msgstr);
-        }
-
-        void entity::parse_headers(std::string msgstr)
-        {
-                size_t inx = 0;
-                size_t name_start = 0;
-                size_t body_start = 0;
-                std::string field_name;
-
-        FIELD_NAME:
-                if (inx >= msgstr.length())
-                {
-                        errors +=
-                                "message ends in the middle of a header name\n";
-                        goto HEADER_END;
-                }
-
-                if (is_ftext(msgstr[inx]))
-                {
-                        inx++;
-                        goto FIELD_NAME;
-                }
-                if (msgstr[inx] != ':')
-                {
-                        errors += boost::str(boost::format
-                                             ("invalid character (0x%02x) "
-                                              "in header field name\n")
-                                             % (unsigned)msgstr[inx]);
-                }
-                field_name = msgstr.substr(name_start, inx - name_start);
-                inx++;
-                if (inx >= msgstr.length() || msgstr[inx] != ' ')
-                {
-                        errors += "header field '" + field_name + "' "
-                                "is missing the mandatory space after colon\n";
-                }
-                inx++;
-                body_start = inx;
-                goto FIELD_BODY;
-
-        FIELD_BODY:
-                if (inx >= msgstr.length())
-                {
-                        errors += "header field '" + field_name + "' "
-                                "terminates abruptly\n";
-                        goto HEADER_END;
-                }
-                if (is_vchar(msgstr[inx]) || is_wsp(msgstr[inx]))
-                {
-                        inx++;
-                        goto FIELD_BODY;
-                }
-                if (msgstr[inx] != '\r') 
-                {
-                        errors += "header field '" + field_name + "' "
-                                "contains a character that is not allowed\n";
-                }
-                inx++;
-                if (inx >= msgstr.length() || msgstr[inx] != '\n') 
-                {
-                        errors += "header field '" + field_name + "' "
-                                "contains a stray CR\n";
-                }
-                assert(inx  < msgstr.length());
-                inx++;
-                if (inx < msgstr.length() && is_wsp(msgstr[inx]))
-                {
-                        // folded header field
-                        goto FIELD_BODY;
-                }
-                // header field ends
-                field_content.push_back(msgstr.substr(name_start,
-                                                      inx - name_start));
-                boost::to_lower(field_name);
-                fields[field_name] = boost::prior(field_content.end());
-                if (inx + 1 < msgstr.length() &&
-                    msgstr[inx+0] == '\r' && msgstr[inx+1] == '\n')
-                {
-                        inx += 2;
-                        goto HEADER_END;
-                }
-                name_start = inx;
-                goto FIELD_NAME;
-
-        HEADER_END:
-                body = msgstr.substr(inx);
-        }
-
-        boost::posix_time::ptime entity::parsed_date() const
-        {
-                if (the_date == boost::posix_time::not_a_date_time)
-                        the_date = parse_date(get_field("Date", false));
-                return the_date;
-        }
-
-        std::string entity::get_header() const
-        {
-                std::string rv;
-                for (field_iterator it = fields_begin();
-                     it != fields_end(); it++)
-                {
-                        rv += *it;
-                }
-                return rv;
-        }        
-
-        std::string entity::get_field(std::string name, bool full) const
-        {
-                boost::to_lower(name);
-
-                std::map<std::string, std::list<std::string>::iterator>
-                        ::const_iterator it = fields.find(name);
-                if (it == fields.end()) return "";
-                
-                const std::string content = *it->second;
-                if (full) { 
-                        return content;
-                } else {
-                        return content.substr(name.length() + 2);
-                }
-        }
-
         size_t entity::get_size() const
         {
+                std::string body = get_body();
                 size_t n = 0;
                 for (field_iterator it = fields_begin();
@@ -217 +51 @@
         size_t entity::get_body_lines() const
         {
+                std::string body = get_body();
                 unsigned long lines = -1;
                 size_t inx = std::string::npos;
@@ -228 +63 @@
         }
 
-        void entity::replace_field(std::string name, std::string body)
+        entity::ptr entity::mk(std::string ms, bool validate, std::string dct)
         {
-                std::string fld = name + ": " + body + "\r\n";
-                fld.reserve(fld.length());
-                // fold it
-                const size_t line_maxlen = 998;
-                size_t lb = 0;
-                for (size_t i = line_maxlen; i < fld.length(); i += line_maxlen)
-                {
-                        while (i > lb && fld[i] != ' ' && fld[i] != '\t') i--;
-                        if (i == lb) break;
-                        fld.insert(i, "\r\n");
-                        i += 2;
-                }
-                boost::to_lower(name);
-                std::map<std::string, std::list<std::string>::iterator>
-                        ::iterator it = fields.find(name);
-                if (it == fields.end()) {
-                        field_content.push_front(fld);
-                        fields[name] = field_content.begin();
-                } else {
-                        *it->second = fld;
-                }
-                if (name == "date")
-                        the_date = boost::posix_time::not_a_date_time;
-        }
+                entity_header::ptr hdr(new entity_header(ms, validate, dct));
 
-        content_type entity::get_content_type() const
-        {
-                return content_type(has_field("content-type")
-                                    ? get_field("content-type", false)
-                                    : default_ct);
-        }
-
-        boost::shared_ptr<mime_entity> entity::get_mime_entity() const
-        {
-                boost::shared_ptr<mime_entity> rv;
-                content_type ct = get_content_type();
+                entity::ptr rv;
+                content_type ct = hdr->get_content_type();
                 switch (ct.get_type())
                 {
                 case content_type::MESSAGE:
-                        rv.reset(new message_entity(*this));
+                        rv.reset(new message_entity(hdr, ms));
                         break;
                 case content_type::MULTIPART:
-                        rv.reset(new multipart(*this));
+                        rv.reset(new multipart(hdr, ms));
                         break;
-                case content_type::TEXT: default:
-                        rv.reset(new text_plain(*this));
+                case content_type::TEXT:
+                        rv.reset(new text_plain(hdr, ms));
+                        break;
+                default:
+                        rv.reset(new raw_entity(hdr, ms));
                         break;
                 }
@@ -281 +87 @@
         }
 
-        std::string entity::get_decoded_body() const
-        {
-                /* This here would decode content-transfer-encoding,
-                   but lacking realistic test cases I'm leaving this
-                   for later. */
-                return get_body();
-        }
 }

msg/entity.hh

@@ -21 +21 @@
 #define GUARD_MSG_ENTITY_HH
 
-#include "format_violation.hh"
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/shared_ptr.hpp>
-#include <list>
-#include <map>
-#include <string>
+#include "entity_header.hh"
+
+#define DEFAULT_CT "text/plain; charset=\"US-ASCII\""
+
+namespace tlate { class value; }
 
 namespace msg
@@ -36 +34 @@
         class entity
         {
-                std::string errors;
-
         public:
                 typedef boost::shared_ptr<entity> ptr;
                 typedef boost::shared_ptr<const entity> const_ptr;
-                typedef std::list<std::string>::const_iterator field_iterator;
+                typedef entity_header::field_iterator field_iterator;
 
-                explicit entity(std::string msgstr,
-                                std::string default_ct = 
-                                "text/plain; charset=\"US-ASCII\"");
-                explicit entity(const entity &);
+                static ptr mk(std::string msgstr,
+                              bool validate,
+                              std::string default_ct = DEFAULT_CT);
 
                 virtual ~entity() {}
 
-                boost::posix_time::ptime parsed_date() const;
+                virtual ptr clone() const = 0;
 
-                void validate_format() const {
-                        if (!errors.empty()) throw format_violation(errors);
+                virtual boost::shared_ptr<tlate::value>
+                get_tlate_value(bool hide_addreses) const = 0;
+
+                boost::posix_time::ptime parsed_date() const {
+                        return hdr->parsed_date();
                 }
 
                 field_iterator fields_begin() const {
-                        return field_content.begin();
+                        return hdr->fields_begin();
                 }
 
-                field_iterator fields_end() const {
-                        return field_content.end();
+                field_iterator fields_end() const { return hdr->fields_end(); }
+
+                std::string get_header() const { return hdr->get_header(); } 
+                virtual std::string get_body() const = 0;
+                virtual std::string get_decoded_body() const {
+                        return get_body();
                 }
-
-                std::string get_header() const;
-                std::string get_body() const { return body; }
-                std::string get_decoded_body() const;
                 std::string get_entity() const {
                         return get_header() + "\r\n" + get_body();
                 }
 
-
-                bool has_field(std::string s) const{
-                        boost::to_lower(s);
-                        return fields.find(s) != fields.end();
-                }
+                bool has_field(std::string s) const{ return hdr->has_field(s); }
 
                 // returns the field unprocessed
-                std::string get_field(std::string s, bool full) const;
+                std::string get_field(std::string s, bool full) const {
+                        return hdr->get_field(s, full);
+                }
 
                 size_t get_size() const;
                 size_t get_body_lines() const;
 
-                virtual void replace_field(std::string name, std::string body);
+                void replace_field(std::string name, std::string body) {
+                        return hdr->replace_field(name, body);
+                }
 
-                void replace_body(std::string s) { body = s; }
+                content_type get_content_type() const {
+                        return hdr->get_content_type();
+                }
 
-                content_type get_content_type() const;
-
-                boost::shared_ptr<mime_entity> get_mime_entity() const;
+        protected:
+                entity(entity_header::ptr hdr)
+                        : hdr(hdr)
+                        {}
+                entity(const entity &ent)
+                        : hdr(new entity_header(*ent.hdr))
+                        {}
 
         private:
-                std::string default_ct;
-                // this split is to both provide a fast name lookup
-                // and to preserve the field ordering
-                std::list<std::string> field_content; // includes the names
-                std::map<std::string, std::list<std::string>::iterator> fields;
-                std::string body;
-                mutable boost::posix_time::ptime the_date;
-
-                void parse_headers(std::string);
+                entity_header::ptr hdr;
 
                 entity &operator=(const entity &); // DISABLED

msg/message_entity.cc

@@ -28 +28 @@
 namespace msg
 {
-        message_entity::message_entity(const entity & ent)
-                : mime_entity(ent)
-                , m(new entity(get_body()))
-        {
-        }
 
         boost::shared_ptr<tlate::value>
@@ -56 +51 @@
                            new tlate::date_value
                            (parse_date(m->get_field("Date", false))));
-                mime_entity::const_ptr bme = m->get_mime_entity();
-                am->insert("body", bme->get_tlate_value(munge));
+                am->insert("body", m->get_tlate_value(munge));
                 return am;
         }

msg/message_entity.hh

@@ -21 +21 @@
 #define GUARD_MSG_MESSAGE_ENTITY_HH
 
-#include "mime_entity.hh"
+#include "entity.hh"
 
 namespace msg
 {
-        class message_entity : public mime_entity
+        class message_entity : public entity
         {
                 entity::ptr m;
+
         public:
-                explicit message_entity(const entity &);
+                message_entity(entity_header::ptr hdr, std::string body)
+                        : entity(hdr)
+                        , m(entity::mk(body, false))
+                        {}
+
+                entity::ptr clone() const { 
+                        entity::ptr rv(new message_entity(*this));
+                        return rv;
+                }
+
+                std::string get_body() const { return m->get_entity(); }
 
                 boost::shared_ptr<tlate::value> get_tlate_value(bool) const;

msg/multipart.cc

@@ -25 +25 @@
 namespace msg
 {
-        multipart::multipart(const entity &ent)
-                : mime_entity(ent)
+        multipart::multipart(entity_header::ptr hdr, std::string str)
+                : entity(hdr)
         {
                 content_type ct = get_content_type();
@@ -32 +32 @@
                         throw std::logic_error("not multipart");
                 std::string boundary = ct.get_param("boundary");
-                std::string str = get_body();
                 size_t bs = str.find("\r\n--"+boundary);
+                preamble = str.substr(0,bs);
                 std::string default_ct = ct.get_subtype() == "digest"
                         ? "message/rfc822"
@@ -39 +39 @@
                 while (bs != std::string::npos)
                 {
-                        if (str.substr(bs + 4 + boundary.length(), 2) == "--")
-                                break;
                         size_t be = str.find("\r\n", bs+2);
                         if (be == std::string::npos) be = str.length() - 2;
+                        if (str.substr(bs + 4 + boundary.length(), 2) == "--")
+                        {
+                                trailer = be + 2 < str.length()
+                                        ? str.substr(be+2)
+                                        : "";
+                                break;
+                        }
                         size_t ns = str.find("\r\n--"+boundary, be);
                         std::string sub = str.substr(be+2, ns - be);
-                        entity::ptr sen(new entity(sub, default_ct));
+                        entity::ptr sen(entity::mk(sub, false, default_ct));
                         parts.push_back(sen);
                         bs = ns;
@@ -57 +62 @@
                 for (size_t i = 0; i < parts.size(); i++)
                 {
-                        mime_entity::ptr men = parts[i]->get_mime_entity();
-                        li->push_back(men->get_tlate_value(hide_addresses));
+                        entity::ptr en = parts[i];
+                        li->push_back(en->get_tlate_value(hide_addresses));
                 }
                 tlate::data_model::ptr am(new tlate::data_model);
@@ -64 +69 @@
                 return am;
         }
+
+        std::string multipart::get_body() const
+        {
+                content_type ct = get_content_type();
+                std::string boundary = ct.get_param("boundary");
+                std::ostringstream os;
+                os << preamble;
+                for (size_t i = 0; i < parts.size(); i++)
+                {
+                        os << "\r\n--" << boundary << "\r\n";
+                        os << parts[i]->get_entity();
+                }
+                os << "\r\n--" << boundary << "--\r\n";
+                os << trailer;
+                return os.str();
+        }
 }

msg/multipart.hh

@@ -21 +21 @@
 #define GUARD_MSG_MULTIPART_HH
 
-#include "mime_entity.hh"
+#include "entity.hh"
 #include <vector>
 
 namespace msg
 {
-        class multipart : public mime_entity
+        class multipart : public entity
         {
                 std::vector<entity::ptr> parts;
+                std::string preamble, trailer;
         public:
-                explicit multipart(const entity &);
+                multipart(entity_header::ptr hdr, std::string body);
+
+                entity::ptr clone() const {
+                        entity::ptr rv(new multipart(*this));
+                        return rv;
+                }
+
+                std::string get_body() const;
 
                 boost::shared_ptr<tlate::value> get_tlate_value(bool) const;

msg/text_plain.cc

@@ -19 +19 @@
 
 #include "content_type.hh"
+#include "entity_header.hh"
 #include "text_plain.hh"
 
@@ -26 +27 @@
 #include "../util.hh"
 
+namespace
+{
+        msg::entity_header::ptr ct_hdr(msg::content_type ct)
+        {
+                std::string str =
+                        std::string("Content-Type: ") +
+                        ct.to_string() + "\r\n" +
+                        "Content-Transfer-Encoding: 8bit\r\n" +
+                        "\r\n";
+                msg::entity_header::ptr rv(new msg::entity_header(str,
+                                                                  false,
+                                                                  ct.to_string()
+                                                   )
+                        );
+                return rv;
+        }
+}
+
 namespace msg
 {
-        text_plain::text_plain(const entity &ent)
-                : mime_entity(ent)
-        {
-                init();
-        }
-
-        text_plain::text_plain(std::string text, content_type ct)
-                : mime_entity(std::string("Content-Type: ") +
-                              ct.to_string() + "\r\n" +
-                              "Content-Transfer-Encoding: 8bit\r\n" +
-                              "\r\n" +
-                              text)
-        {
-                init();
-        }
-
-        void text_plain::init()
-        {
-                std::string text = get_decoded_body();
+        text_plain::text_plain(entity_header::ptr hdr, std::string body)
+                : entity(hdr)
+        {
+                init(body);
+        }
+
+        text_plain::text_plain(std::string body, content_type ct)
+                : entity(ct_hdr(ct))
+        {
+                init(body);
+        }
+
+        text_plain::text_plain(entity::const_ptr e)
+                : entity(*e)
+        {
+                init(e->get_body());
+        }
+
+        void text_plain::init(std::string text)
+        {
+                raw_body = text;
                 content_type ct = get_content_type();
                 if (ct.get_type() != msg::content_type::TEXT ||

msg/text_plain.hh

@@ -1 +1 @@
 /*  This file is part of Alue, the multiprotocol Internet discussion daemon
 
-    Copyright © 2009 Antti-Juhani Kaijanaho
+    Copyright © 2009, 2010 Antti-Juhani Kaijanaho
 
     Alue is free software: you can redistribute it and/or modify it
@@ -22 +22 @@
 
 #include "content_type.hh"
-#include "mime_entity.hh"
+#include "entity.hh"
 
 #include <string>
@@ -29 +29 @@
 namespace msg
 {
-        class text_plain : public mime_entity
+        class text_plain : public entity
         {
         public:
@@ -47 +47 @@
 
                 explicit text_plain(std::string body, content_type);
-                explicit text_plain(const entity &);
+                explicit text_plain(entity_header::ptr hdr, std::string body);
+                explicit text_plain(entity::const_ptr e);
 
                 size_t num_paras() const { return paras.size(); }
@@ -54 +55 @@
                 boost::shared_ptr<tlate::value>
                 get_tlate_value(bool hide_addreses) const;
+
+                std::string get_body() const { return raw_body; }
+
+                entity::ptr clone() const {
+                        entity::ptr rv(new text_plain(*this));
+                        return rv;
+                }
         private:
+                std::string raw_body;
                 std::vector<para> paras;
 
-                void init();
+                void init(std::string body);
         };
 }

msg/util.cc

@@ -256 +256 @@
         void validate_imf(entity::const_ptr e) 
         {
-                e->validate_format();
                 check_present(e, "From");                
                 check_present(e, "Date");                

nntp/post.cc

@@ -42 +42 @@
                 try {
                         msg::entity::ptr e
-                                (new msg::entity(msg::dot_destuff(data)));
+                                (msg::entity::mk(msg::dot_destuff(data), true));
                         m = c.dbase().file(e, c.peer(), c.identity(),
                                            c.srv_cb());

smtp_client/smtp_client.cc

@@ -40 +40 @@
                 message = msg::crlf_canonize(message);
                 msg::entity::ptr msg
-                        (new msg::entity(msg::dot_destuff(message)));
+                        (msg::entity::mk(msg::dot_destuff(message), true));
                 msg::complete_imf(msg);
                 msg::complete_mime(msg);

tlate/date_value.cc

@@ -29 +29 @@
 #include "../http/compose.hh"
 #include "../msg/lexutils.hh"
-#include "../msg/mime_entity.hh"
 #include "../uri.hh"
 

tlate/msg_value.cc

@@ -33 +33 @@
 #include "../msg/entity.hh"
 #include "../msg/lexutils.hh"
-#include "../msg/mime_entity.hh"
 #include "../uri.hh"
 
@@ -174 +173 @@
                         rv.reset(new header_value(e,!u));
                 else if (rauthz && m && var == "body")
-                {
-                        msg::mime_entity::const_ptr me = e->get_mime_entity();
-                        rv = me->get_tlate_value(authn);
-                }
+                        rv = e->get_tlate_value(authn);
                 else if (rauthz && m && var == "xref")
                         rv.reset(new xref_seq(m, u));