//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
//
// This program 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.
//
// This program 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 this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// Linking this library statically or dynamically with other modules is making
// a combined work based on this library. Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
#include "vmime/config.hpp"
#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
#include "vmime/net/imap/IMAPUtils.hpp"
#include "vmime/net/imap/IMAPStore.hpp"
#include "vmime/net/message.hpp"
#include "vmime/net/folder.hpp"
#include <sstream>
#include <iterator>
#include <algorithm>
namespace vmime {
namespace net {
namespace imap {
// static
const string IMAPUtils::quoteString(const string& text) {
//
// ATOM_CHAR ::= <any CHAR except atom_specials>
//
// atom_specials ::= "(" / ")" / "{" / SPACE / CTL /
// list_wildcards / quoted_specials
//
// list_wildcards ::= "%" / "*"
//
// quoted_specials ::= <"> / "\"
//
// CHAR ::= <any 7-bit US-ASCII character except NUL,
// 0x01 - 0x7f>
//
// CTL ::= <any ASCII control character and DEL,
// 0x00 - 0x1f, 0x7f>
//
bool needQuoting = text.empty();
for (string::const_iterator it = text.begin() ;
!needQuoting && it != text.end() ; ++it) {
const unsigned char c = *it;
switch (c) {
case '(':
case ')':
case '{':
case 0x20: // SPACE
case '%':
case '*':
case '"':
case '\\':
needQuoting = true;
break;
default:
if (c <= 0x1f || c >= 0x7f) {
needQuoting = true;
}
}
}
if (needQuoting) {
string quoted;
quoted.reserve((text.length() * 3) / 2 + 2);
quoted += '"';
for (string::const_iterator it = text.begin() ; it != text.end() ; ++it) {
const unsigned char c = *it;
if (c == '\\' || c == '"') {
quoted += '\\';
}
quoted += c;
}
quoted += '"';
return quoted;
} else {
return text;
}
}
const string IMAPUtils::pathToString(
const char hierarchySeparator,
const folder::path& path
) {
string result;
for (size_t i = 0 ; i < path.getSize() ; ++i) {
if (i > 0) result += hierarchySeparator;
result += toModifiedUTF7(hierarchySeparator, path[i]);
}
return (result);
}
const folder::path IMAPUtils::stringToPath(
const char hierarchySeparator,
const string& str
) {
folder::path result;
string::const_iterator begin = str.begin();
for (string::const_iterator it = str.begin() ; it != str.end() ; ++it) {
if (*it == hierarchySeparator) {
result /= fromModifiedUTF7(string(begin, it));
begin = it + 1;
}
}
if (begin != str.end()) {
result /= fromModifiedUTF7(string(begin, str.end()));
}
return result;
}
const string IMAPUtils::toModifiedUTF7(
const char hierarchySeparator,
const folder::path::component& text
) {
// We will replace the hierarchy separator with an equivalent
// UTF-7 sequence, so we compute it here...
const char base64alphabet[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,=";
const unsigned int hs = static_cast <unsigned int>(static_cast <unsigned char>(hierarchySeparator));
string hsUTF7;
hsUTF7.resize(3);
hsUTF7[0] = base64alphabet[0];
hsUTF7[1] = base64alphabet[(hs & 0xF0) >> 4];
hsUTF7[2] = base64alphabet[(hs & 0x0F) << 2];
// iconv() is buggy with UTF-8 to UTF-7 conversion, so we do it "by hand".
// This code is largely inspired from "imap/utf7.c", in mutt 1.4.
// Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org>
// WARNING: This may throw "exceptions::charset_conv_error"
const string cvt = text.getConvertedText(charset(charsets::UTF_8));
// In the worst case we convert 2 chars to 7 chars.
// For example: "\x10&\x10&..." -> "&ABA-&-&ABA-&-...".
string out;
out.reserve((cvt.length() / 2) * 7 + 6);
int b = 0, k = 0;
bool base64 = false;
size_t remaining = cvt.length();
for (size_t i = 0, len = cvt.length() ; i < len ; ) {
const unsigned char c = cvt[i];
// Replace hierarchy separator with an equivalent UTF-7 Base64 sequence
if (!base64 && c == hierarchySeparator) {
out += "&" + hsUTF7 + "-";
++i;
--remaining;
continue;
}
size_t n = 0;
int ch = 0;
if (c < 0x80) {
ch = c, n = 0;
} else if (c < 0xc2) {
return "";
} else if (c < 0xe0) {
ch = c & 0x1f, n = 1;
} else if (c < 0xf0) {
ch = c & 0x0f, n = 2;
} else if (c < 0xf8) {
ch = c & 0x07, n = 3;
} else if (c < 0xfc) {
ch = c & 0x03, n = 4;
} else if (c < 0xfe) {
ch = c & 0x01, n = 5;
} else {
return "";
}
if (n > remaining) {
return ""; // error
}
++i;
--remaining;
for (size_t j = 0 ; j < n ; j++) {
if ((cvt[i + j] & 0xc0) != 0x80) {
return ""; // error
}
ch = (ch << 6) | (cvt[i + j] & 0x3f);
}
if (n > 1 && !(ch >> (n * 5 + 1))) {
return ""; // error
}
i += n;
remaining -= n;
if (ch < 0x20 || ch >= 0x7f) {
if (!base64) {
out += '&';
base64 = true;
b = 0;
k = 10;
}
if (ch & ~0xffff) {
ch = 0xfffe;
}
out += base64alphabet[b | ch >> k];
k -= 6;
for ( ; k >= 0 ; k -= 6) {
out += base64alphabet[(ch >> k) & 0x3f];
}
b = (ch << (-k)) & 0x3f;
k += 16;
} else {
if (base64) {
if (k > 10) {
out += base64alphabet[b];
}
out += '-';
base64 = false;
}
out += static_cast <char>(ch);
if (ch == '&') {
out += '-';
}
}
}
if (base64) {
if (k > 10) {
out += base64alphabet[b];
}
out += '-';
}
return (out);
}
const folder::path::component IMAPUtils::fromModifiedUTF7(const string& text) {
// Transcode from modified UTF-7 (RFC-2060).
string out;
out.reserve(text.length());
bool inB64sequence = false;
bool plusOutput = false;
unsigned char prev = 0;
for (string::const_iterator it = text.begin() ; it != text.end() ; ++it) {
const unsigned char c = *it;
switch (c) {
// Start of Base64 sequence
case '&': {
if (!inB64sequence) {
inB64sequence = true;
plusOutput = false;
} else {
out += '&';
}
break;
}
// End of Base64 sequence (or "&-" --> "&")
case '-': {
if (inB64sequence && prev == '&') { // special case "&-" --> "&"
out += '&';
} else {
out += '-';
}
inB64sequence = false;
break;
}
// ',' is used instead of '/' in modified Base64
case ',': {
if (inB64sequence && !plusOutput) {
out += '+';
plusOutput = true;
}
out += (inB64sequence ? '/' : ',');
break;
}
default: {
if (inB64sequence && !plusOutput) {
out += '+';
plusOutput = true;
}
out += c;
break;
}
}
prev = c;
}
// Store it as UTF-8 by default
string cvt;
charset::convert(out, cvt, charset(charsets::UTF_7), charset(charsets::UTF_8));
return folder::path::component(cvt, charset(charsets::UTF_8));
}
// static
void IMAPUtils::mailboxFlagsToFolderAttributes(
const shared_ptr <const IMAPConnection>& cnt,
const folder::path &path,
const IMAPParser::mailbox_flag_list& list,
folderAttributes& attribs
) {
int specialUse = folderAttributes::SPECIALUSE_NONE;
int type = folderAttributes::TYPE_CONTAINS_MESSAGES | folderAttributes::TYPE_CONTAINS_FOLDERS;
int flags = 0;
// If CHILDREN extension (RFC-3348) is not supported, assume folder has children
// as we have no hint about it
if (!cnt->hasCapability("CHILDREN")) {
flags |= folderAttributes::FLAG_HAS_CHILDREN;
}
for (auto it = list.flags.begin() ; it != list.flags.end() ; ++it) {
switch ((*it)->type) {
case IMAPParser::mailbox_flag::NOSELECT:
type &= ~folderAttributes::TYPE_CONTAINS_MESSAGES;
flags |= folderAttributes::FLAG_NO_OPEN;
break;
case IMAPParser::mailbox_flag::NOINFERIORS:
case IMAPParser::mailbox_flag::HASNOCHILDREN:
flags &= ~folderAttributes::FLAG_HAS_CHILDREN;
break;
case IMAPParser::mailbox_flag::HASCHILDREN:
flags |= folderAttributes::FLAG_HAS_CHILDREN;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_ALL:
specialUse = folderAttributes::SPECIALUSE_ALL;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_ARCHIVE:
specialUse = folderAttributes::SPECIALUSE_ARCHIVE;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_DRAFTS:
specialUse = folderAttributes::SPECIALUSE_DRAFTS;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_FLAGGED:
specialUse = folderAttributes::SPECIALUSE_FLAGGED;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_JUNK:
specialUse = folderAttributes::SPECIALUSE_JUNK;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_SENT:
specialUse = folderAttributes::SPECIALUSE_SENT;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_TRASH:
specialUse = folderAttributes::SPECIALUSE_TRASH;
break;
case IMAPParser::mailbox_flag::SPECIALUSE_IMPORTANT:
specialUse = folderAttributes::SPECIALUSE_IMPORTANT;
break;
default:
break;
}
}
if (path.getSize() == 1 && path.getLastComponent().getBuffer() == "INBOX") {
specialUse = folderAttributes::SPECIALUSE_INBOX;
}
attribs.setSpecialUse(specialUse);
attribs.setType(type);
attribs.setFlags(flags);
}
int IMAPUtils::messageFlagsFromFlags(const IMAPParser::flag_list& list) {
int flags = 0;
for (auto &flag : list.flags) {
switch (flag->type) {
case IMAPParser::flag::ANSWERED:
flags |= message::FLAG_REPLIED;
break;
case IMAPParser::flag::FLAGGED:
flags |= message::FLAG_MARKED;
break;
case IMAPParser::flag::DELETED:
flags |= message::FLAG_DELETED;
break;
case IMAPParser::flag::SEEN:
flags |= message::FLAG_SEEN;
break;
case IMAPParser::flag::DRAFT:
flags |= message::FLAG_DRAFT;
break;
default:
//case IMAPParser::flag::UNKNOWN:
break;
}
}
return flags;
}
// static
const std::vector <string> IMAPUtils::messageFlagList(const int flags) {
std::vector <string> flagList;
if (flags == -1) {
return flagList; // default flags
}
if (flags & message::FLAG_REPLIED) flagList.push_back("\\Answered");
if (flags & message::FLAG_MARKED) flagList.push_back("\\Flagged");
if (flags & message::FLAG_DELETED) flagList.push_back("\\Deleted");
if (flags & message::FLAG_SEEN) flagList.push_back("\\Seen");
if (flags & message::FLAG_DRAFT) flagList.push_back("\\Draft");
return flagList;
}
// static
const string IMAPUtils::dateTime(const vmime::datetime& date) {
std::ostringstream res;
res.imbue(std::locale::classic());
// date_time ::= <"> date_day_fixed "-" date_month "-" date_year
// SPACE time SPACE zone <">
//
// time ::= 2digit ":" 2digit ":" 2digit
// ;; Hours minutes seconds
// zone ::= ("+" / "-") 4digit
// ;; Signed four-digit value of hhmm representing
// ;; hours and minutes west of Greenwich
res << '"';
// Date
if (date.getDay() < 10) res << ' ';
res << date.getDay();
res << '-';
static const char* monthNames[12] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
res << monthNames[std::min(std::max(date.getMonth() - 1, 0), 11)];
res << '-';
if (date.getYear() < 10) res << '0';
if (date.getYear() < 100) res << '0';
if (date.getYear() < 1000) res << '0';
res << date.getYear();
res << ' ';
// Time
if (date.getHour() < 10) res << '0';
res << date.getHour() << ':';
if (date.getMinute() < 10) res << '0';
res << date.getMinute() << ':';
if (date.getSecond() < 10) res << '0';
res << date.getSecond();
res << ' ';
// Zone
const int zs = (date.getZone() < 0 ? -1 : 1);
const int zh = (date.getZone() * zs) / 60;
const int zm = (date.getZone() * zs) % 60;
res << (zs < 0 ? '-' : '+');
if (zh < 10) res << '0';
res << zh;
if (zm < 10) res << '0';
res << zm;
res << '"';
return res.str();
}
// static
shared_ptr <IMAPCommand> IMAPUtils::buildFetchCommand(
const shared_ptr <IMAPConnection>& cnt,
const messageSet& msgs,
const fetchAttributes& options
) {
// Example:
// C: A654 FETCH 2:4 (FLAGS BODY[HEADER.FIELDS (DATE FROM)])
// S: * 2 FETCH ....
// S: * 3 FETCH ....
// S: * 4 FETCH ....
// S: A654 OK FETCH completed
std::vector <string> items;
if (options.has(fetchAttributes::SIZE)) {
items.push_back("RFC822.SIZE");
}
if (options.has(fetchAttributes::FLAGS)) {
items.push_back("FLAGS");
}
if (options.has(fetchAttributes::STRUCTURE)) {
items.push_back("BODYSTRUCTURE");
}
if (options.has(fetchAttributes::UID)) {
items.push_back("UID");
// Also fetch MODSEQ if CONDSTORE is supported
if (cnt && cnt->hasCapability("CONDSTORE") && !cnt->isMODSEQDisabled()) {
items.push_back("MODSEQ");
}
}
if (options.has(fetchAttributes::FULL_HEADER)) {
items.push_back("RFC822.HEADER");
} else {
if (options.has(fetchAttributes::ENVELOPE)) {
items.push_back("ENVELOPE");
}
std::vector <string> headerFields;
if (options.has(fetchAttributes::CONTENT_INFO)) {
headerFields.push_back("CONTENT_TYPE");
}
if (options.has(fetchAttributes::IMPORTANCE)) {
headerFields.push_back("IMPORTANCE");
headerFields.push_back("X-PRIORITY");
}
// Also add custom header fields to fetch, if any
const std::vector <string> customHeaderFields = options.getHeaderFields();
std::copy(customHeaderFields.begin(), customHeaderFields.end(), std::back_inserter(headerFields));
if (!headerFields.empty()) {
string list;
for (std::vector <string>::iterator it = headerFields.begin() ;
it != headerFields.end() ; ++it) {
if (it != headerFields.begin()) {
list += " ";
}
list += *it;
}
items.push_back("BODY[HEADER.FIELDS (" + list + ")]");
}
}
return IMAPCommand::FETCH(msgs, items);
}
// static
void IMAPUtils::convertAddressList(
const IMAPParser::address_list& src,
mailboxList& dest
) {
for (auto& addr : src.addresses) {
text name;
text::decodeAndUnfold(addr->addr_name->value, &name);
string email = addr->addr_mailbox->value
+ "@" + addr->addr_host->value;
dest.appendMailbox(make_shared <mailbox>(name, email));
}
}
class IMAPUIDMessageSetEnumerator : public messageSetEnumerator {
public:
IMAPUIDMessageSetEnumerator()
: m_first(true) {
m_oss.imbue(std::locale::classic());
}
void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) {
if (!m_first) {
m_oss << ",";
}
if (range.getFirst() == range.getLast()) {
m_oss << range.getFirst();
} else if (range.getLast() == size_t(-1)) {
m_oss << range.getFirst() << ":*";
} else {
m_oss << range.getFirst() << ":" << range.getLast();
}
m_first = false;
}
void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& range) {
if (!m_first) {
m_oss << ",";
}
if (range.getFirst() == range.getLast()) {
m_oss << range.getFirst();
} else if (range.getLast() == size_t(-1)) {
m_oss << range.getFirst() << ":*";
} else {
m_oss << range.getFirst() << ":" << range.getLast();
}
m_first = false;
}
const std::string str() const {
return m_oss.str();
}
private:
std::ostringstream m_oss;
bool m_first;
};
class IMAPMessageSetEnumerator : public messageSetEnumerator {
public:
void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) {
for (size_t i = range.getFirst(), last = range.getLast() ; i <= last ; ++i) {
m_list.push_back(i);
}
}
void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& /* range */) {
// Not used
}
const std::vector <size_t>& list() const {
return m_list;
}
public:
std::vector <size_t> m_list;
};
// static
const string IMAPUtils::messageSetToSequenceSet(const messageSet& msgs) {
IMAPUIDMessageSetEnumerator en;
msgs.enumerate(en);
return en.str();
}
// static
messageSet IMAPUtils::buildMessageSet(const IMAPParser::uid_set& uidSetRef) {
messageSet set = messageSet::empty();
const IMAPParser::uid_set* uidSet = &uidSetRef;
for ( ; uidSet ; uidSet = uidSet->next_uid_set.get()) {
if (uidSet->uid_range) {
set.addRange(
UIDMessageRange(
message::uid(uidSet->uid_range->uniqueid1->value),
message::uid(uidSet->uid_range->uniqueid2->value)
)
);
} else {
set.addRange(
UIDMessageRange(
message::uid(uidSet->uniqueid->value)
)
);
}
}
return set;
}
} // imap
} // net
} // vmime
#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
