You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
270 lines
8.6 KiB
270 lines
8.6 KiB
// This file is under GNU General Public License 3.0
|
|
// see LICENSE.txt
|
|
|
|
#include "bodyparser.hh"
|
|
#include "pEpMIME_internal.hh"
|
|
#include "mime_headers.hh"
|
|
#include "message.hh"
|
|
#include "rules.hh"
|
|
#include "base64.hxx"
|
|
#include "headerparser.hh" // for add_opt_field()
|
|
#include "quoted_printable.hxx"
|
|
#include "string_case.hh"
|
|
#include "nfc.hh"
|
|
#include "to_utf8.hh"
|
|
#include <pEp/pEp_string.h>
|
|
|
|
#include <boost/spirit/include/qi.hpp>
|
|
#include <boost/spirit/include/phoenix.hpp>
|
|
#include <boost/fusion/include/adapt_struct.hpp>
|
|
|
|
|
|
namespace qi = boost::spirit::qi;
|
|
namespace px = boost::phoenix;
|
|
|
|
|
|
namespace pEpMIME
|
|
{
|
|
|
|
typedef std::vector<Message> MultipartMessage;
|
|
|
|
MultipartMessage parse_multipart(const BodyLines& body, const sv& boundary)
|
|
{
|
|
bool is_last = false;
|
|
qi::rule<const char*, qi::unused_type()> is_delimiter_parser = qi::lit("--") >> qi::lit(boundary.data())
|
|
>> -qi::lit("--")[ px::ref(is_last) = true] >> qi::omit[*qi::char_(" \t")];
|
|
|
|
MultipartMessage vm;
|
|
bool after_preamble = false;
|
|
BodyLines part;
|
|
LOG << "Parse_Multipart: " << body.size() << " body lines. bounardy=“" << boundary << "”. \n";
|
|
for(const auto& line : body)
|
|
{
|
|
is_last = false;
|
|
auto begin = line.cbegin();
|
|
const bool is_delimiter = qi::parse( begin, line.cend(), is_delimiter_parser );
|
|
if(is_delimiter)
|
|
{
|
|
LOG << "\t Line “" << line << "” is " << (is_last ? "LAST ":"") << "delimiter!\n";
|
|
if(after_preamble)
|
|
{
|
|
vm.emplace_back( part );
|
|
part.clear();
|
|
}else{
|
|
after_preamble = true;
|
|
}
|
|
|
|
if(is_last == true)
|
|
{
|
|
break;
|
|
}
|
|
}else{
|
|
if(after_preamble)
|
|
{
|
|
part.emplace_back(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
return vm;
|
|
}
|
|
|
|
|
|
char* create_string(const BodyLines& body, const sv& charset, MimeHeaders::Decoder decoder)
|
|
{
|
|
if(body.empty())
|
|
return nullptr;
|
|
|
|
size_t decoded_size = 0;
|
|
char* decoded = decoder(body, decoded_size);
|
|
|
|
LOG << "CREATE_STRING: " << body.size() << " body lines into " << decoded_size << " raw octets (charset=\"" << charset << "\")\n";
|
|
|
|
if(charset=="UTF-8" || charset=="UTF8")
|
|
{
|
|
// Move all NUL bytes to the end where they don't hurt.
|
|
std::remove(decoded, decoded + decoded_size, '\0' );
|
|
return decoded; // fine. :-)
|
|
}else{
|
|
// Sigh, the hard way. At the moment with a lot of unecessary copying. :-/
|
|
// Rule 1: Make it work. Profile. Make it fast. In this order.
|
|
std::string converted = to_utf8((charset.empty() ? "us-ascii" : charset), sv(decoded, decoded_size) ); // 1st copy...
|
|
|
|
// remove any NUL bytes
|
|
converted.erase( std::remove(converted.begin(), converted.end(), '\0'), converted.end() );
|
|
pEp_free(decoded);
|
|
return new_string( converted.data(), converted.size() ); // copy again. :'-(
|
|
}
|
|
}
|
|
|
|
|
|
void add_attachment(message* msg, const BodyLines& body, const MimeHeaders& mh)
|
|
{
|
|
size_t decoded_size = 0;
|
|
char* decoded = mh.decoder(body, decoded_size);
|
|
sv filename = header_value(mh.dparams, "filename");
|
|
LOG << "ATTACHMENT filename=“" << filename << "”\n";
|
|
if(filename.empty()) // no "filename" field in Content-Disposition?
|
|
{
|
|
filename = header_value(mh.tparams, "name"); // legacy: use "name" field from Content-Type header
|
|
LOG << "ATTACHMENT name=“" << filename << "”\n";
|
|
}
|
|
|
|
const std::string content_type = mh.mime_type();
|
|
if( (msg->attachments==nullptr) && (content_type=="message/rfc822") ) // very special requirement. See MIME-12
|
|
{
|
|
const sv forwarded = header_value( mh.tparams, "forwarded");
|
|
if(forwarded.size())
|
|
{
|
|
add_opt_field(msg, Pseudo_Header_Forwarded, forwarded);
|
|
}
|
|
}
|
|
|
|
bloblist_t* bl = bloblist_add(msg->attachments, decoded, decoded_size, content_type.c_str(), (filename.empty()? nullptr : filename.data()) );
|
|
if(msg->attachments==nullptr)
|
|
{
|
|
msg->attachments = bl;
|
|
}
|
|
}
|
|
|
|
|
|
struct has_mimetype
|
|
{
|
|
has_mimetype(const char* _mime_type)
|
|
: mt(_mime_type)
|
|
{}
|
|
|
|
bool operator()(const Message& m) const
|
|
{
|
|
return m.mh.mime_type() == mt;
|
|
}
|
|
|
|
const char* mt;
|
|
};
|
|
|
|
|
|
void set_longmsg(message* msg, const MimeHeaders& mh, const BodyLines& body)
|
|
{
|
|
const sv txt_charset = header_value( mh.tparams, "charset" );
|
|
const sv format = header_value( mh.tparams, "format");
|
|
const sv delsp = header_value( mh.tparams, "delsp");
|
|
|
|
msg->longmsg = create_string(body, txt_charset, mh.decoder );
|
|
if(format.size())
|
|
{
|
|
add_opt_field(msg, Pseudo_Header_Format, format);
|
|
}
|
|
if(delsp.size())
|
|
{
|
|
add_opt_field(msg, Pseudo_Header_Delsp, delsp);
|
|
}
|
|
}
|
|
|
|
|
|
void handle_multipart(message* msg, const MimeHeaders& mh, const BodyLines& body, unsigned level = 1)
|
|
{
|
|
const sv boundary = header_value(mh.tparams, "boundary");
|
|
MultipartMessage mm = parse_multipart( body, boundary );
|
|
LOG << "MULTIPART/" << mh.subtype << ": " << mm.size() << " parts. Boundary = “" << boundary << "” :\n";
|
|
|
|
LOG << "MM.size=" << mm.size() << ", level=" << level << ":\n";
|
|
for(const auto& m : mm)
|
|
{
|
|
LOG << "°°M: " << m << "\n";
|
|
}
|
|
|
|
// All "multipart" MimeTypes: handle as "multipart/mixed":
|
|
for(const Message& m : mm)
|
|
{
|
|
if(m.mh.type == "multipart")
|
|
{
|
|
if(level < MaxMultipartNestingLevel)
|
|
{
|
|
handle_multipart(msg, m.mh, m.body, level+1);
|
|
}else{
|
|
add_attachment(msg, m.body, m.mh);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(m.mh.dispo_type == PEP_CONTENT_DISP_INLINE)
|
|
{
|
|
const auto mime_type = m.mh.mime_type();
|
|
if(mime_type=="text/plain" && msg->longmsg==nullptr)
|
|
{
|
|
// the first "text/plain" part is handeld specially:
|
|
set_longmsg(msg, m.mh, m.body);
|
|
continue;
|
|
}else if(mime_type=="text/html" && msg->longmsg_formatted==nullptr)
|
|
{
|
|
// first inline "text/html" part goes to longmsg_formatted
|
|
const sv mc_charset = header_value( m.mh.tparams, "charset" );
|
|
msg->longmsg_formatted = create_string(m.body, mc_charset, m.mh.decoder );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
add_attachment(msg, m.body, m.mh);
|
|
}
|
|
}
|
|
|
|
|
|
void handle_mime(message* msg, const MimeHeaders& mh, const BodyLines& body)
|
|
{
|
|
if(mh.type == "text")
|
|
{
|
|
const sv charset = header_value( mh.tparams, "charset" );
|
|
LOG << "\t Content-Type: " << mh.mime_type() << ", mh: " << mh << "\n";
|
|
if(mh.subtype == "plain" && msg->longmsg==nullptr)
|
|
{
|
|
// put it in msg->longmsg
|
|
set_longmsg(msg, mh, body);
|
|
}else if(mh.subtype=="html" && msg->longmsg_formatted==nullptr)
|
|
{
|
|
// put it in msg->longmsg_formatted
|
|
msg->longmsg_formatted = create_string(body, charset, mh.decoder);
|
|
}else{
|
|
// add it as attachment
|
|
add_attachment(msg, body, mh);
|
|
}
|
|
}else if(mh.type == "multipart")
|
|
{
|
|
handle_multipart(msg, mh, body, 1);
|
|
}else if(mh.type == "message")
|
|
{
|
|
// TODO: What shall I do with this MimeType?
|
|
add_attachment(msg, body, mh);
|
|
}else{
|
|
// all other MIME types
|
|
add_attachment(msg, body, mh);
|
|
}
|
|
}
|
|
|
|
|
|
// parses the header and fill the parts in msg
|
|
void parse_body(message* msg, const HeaderSection& headers, const BodyLines& body)
|
|
{
|
|
LOG << "ParseBody: " << body.size() << " body lines.\n";
|
|
|
|
// anything that might be a MIME mail I try to parse as a MIME mail:
|
|
if( header_value(headers, "mime-version").size() || header_value(headers, "content-type").size() )
|
|
{
|
|
MimeHeaders mh(headers);
|
|
handle_mime(msg, mh, body);
|
|
}else{ // Non-MIME mail
|
|
LOG << "<<< NO_MIME_MAIL >>> " << body.size() << " body lines.\n";
|
|
sv combined_body = combineLines(body);
|
|
if(isUtf8(combined_body.begin(), combined_body.end()) )
|
|
{
|
|
const std::string& nfc_string = toNFC( combined_body ); // FIXME: double copy! :-((
|
|
msg->longmsg = new_string(nfc_string.c_str(), nfc_string.size()); // FIXME: 3rd copy! :-(((
|
|
}else{
|
|
char* pbody = msg->longmsg = new_string(combined_body.data(), combined_body.size());
|
|
// no valid UTF-8? Hum, whatever it is, make it 7-bit ASCII for safety.
|
|
std::for_each(pbody, pbody+combined_body.size(), [](char& c) { c &= 0x7f; } );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // end of namespace pEpMIME
|