File indexing completed on 2024-05-12 05:17:22

 /*
     Copyright (c) 2009 Kevin Ottens <ervin@kde.org>
     Copyright (c) 2017 Christian Mollekopf <mollekopf@kolabsys.com>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "fetchjob.h"
 
 #include "kimap_debug.h"
 
 #include "job_p.h"
 #include "message_p.h"
 #include "session_p.h"
 
 namespace KIMAP2
 {
 class FetchJobPrivate : public JobPrivate
 {
 public:
     FetchJobPrivate(FetchJob *job, Session *session, const QString &name)
         : JobPrivate(session, name)
         , q(job)
         , uidBased(false)
         , avoidParsing(false)
     { }
 
     ~FetchJobPrivate()
     { }
 
     void parseBodyStructure(const QByteArray &structure, int &pos, KMime::Content *content);
     void parsePart(const QByteArray &structure, int &pos, KMime::Content *content);
     QByteArray parseString(const QByteArray &structure, int &pos);
     QByteArray parseSentence(const QByteArray &structure, int &pos);
     void skipLeadingSpaces(const QByteArray &structure, int &pos);
 
     FetchJob *const q;
 
     ImapSet set;
     bool uidBased;
     FetchJob::FetchScope scope;
     QString selectedMailBox;
     bool avoidParsing;
 };
 }
 
 using namespace KIMAP2;
 
 FetchJob::FetchScope::FetchScope():
     mode(FetchScope::Content),
     changedSince(0),
     gmailExtensionsEnabled(false)
 {
 
 }
 
 FetchJob::FetchJob(Session *session)
     : Job(*new FetchJobPrivate(this, session, "Fetch"))
 {
 }
 
 FetchJob::~FetchJob()
 {
 }
 
 void FetchJob::setAvoidParsing(bool avoid)
 {
     Q_D(FetchJob);
     d->avoidParsing = avoid;
 }
 
 void FetchJob::setSequenceSet(const ImapSet &set)
 {
     Q_D(FetchJob);
     Q_ASSERT(!set.isEmpty());
     d->set = set;
 }
 
 ImapSet FetchJob::sequenceSet() const
 {
     Q_D(const FetchJob);
     return d->set;
 }
 
 void FetchJob::setUidBased(bool uidBased)
 {
     Q_D(FetchJob);
     d->uidBased = uidBased;
 }
 
 bool FetchJob::isUidBased() const
 {
     Q_D(const FetchJob);
     return d->uidBased;
 }
 
 void FetchJob::setScope(const FetchScope &scope)
 {
     Q_D(FetchJob);
     d->scope = scope;
 }
 
 FetchJob::FetchScope FetchJob::scope() const
 {
     Q_D(const FetchJob);
     return d->scope;
 }
 
 void FetchJob::doStart()
 {
     Q_D(FetchJob);
 
     d->set.optimize();
     QByteArray parameters = d->set.toImapSequenceSet() + ' ';
     Q_ASSERT(!parameters.trimmed().isEmpty());
 
     switch (d->scope.mode) {
     case FetchScope::Headers:
         if (d->scope.parts.isEmpty()) {
             parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] FLAGS UID";
         } else {
             parameters += '(';
             foreach (const QByteArray &part, d->scope.parts) {
                 parameters += "BODY.PEEK[" + part + ".MIME] ";
             }
             parameters += "UID";
         }
         break;
     case FetchScope::Flags:
         parameters += "(FLAGS UID";
         break;
     case FetchScope::Structure:
         parameters += "(BODYSTRUCTURE UID";
         break;
     case FetchScope::Content:
         if (d->scope.parts.isEmpty()) {
             parameters += "(BODY.PEEK[] UID";
         } else {
             parameters += '(';
             foreach (const QByteArray &part, d->scope.parts) {
                 parameters += "BODY.PEEK[" + part + "] ";
             }
             parameters += "UID";
         }
         break;
     case FetchScope::Full:
         parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[] FLAGS UID";
         break;
     case FetchScope::HeaderAndContent:
         if (d->scope.parts.isEmpty()) {
             parameters += "(BODY.PEEK[] FLAGS UID";
         } else {
             parameters += "(BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)]";
             foreach (const QByteArray &part, d->scope.parts) {
                 parameters += " BODY.PEEK[" + part + ".MIME] BODY.PEEK[" + part + "]"; //krazy:exclude=doublequote_chars
             }
             parameters += " FLAGS UID";
         }
         break;
     case FetchScope::FullHeaders:
         parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER] FLAGS UID";
         break;
     }
 
     if (d->scope.gmailExtensionsEnabled) {
         parameters += " X-GM-LABELS X-GM-MSGID X-GM-THRID";
     }
     parameters += ")";
 
     if (d->scope.changedSince > 0) {
         parameters += " (CHANGEDSINCE " + QByteArray::number(d->scope.changedSince) + ")";
     }
 
     QByteArray command = "FETCH";
     if (d->uidBased) {
         command = "UID " + command;
     }
 
     d->selectedMailBox = d->m_session->selectedMailBox();
     d->sendCommand(command, parameters);
 }
 
 void FetchJob::handleResponse(const Message &response)
 {
     Q_D(FetchJob);
 
     if (handleErrorReplies(response) == NotHandled) {
         if (response.content.size() == 4 &&
                 response.content[2].toString() == "FETCH" &&
                 response.content[3].type() == Message::Part::List) {
 
             const QList<QByteArray> content = response.content[3].toList();
 
             Result result;
             result.sequenceNumber = response.content[1].toString().toLongLong();
             bool shouldParseMessage = false;
             for (QList<QByteArray>::ConstIterator it = content.constBegin();
                     it != content.constEnd(); ++it) {
                 QByteArray str = *it;
                 ++it;
                 if (it == content.constEnd()) {   // Uh oh, message was truncated?
                     qCWarning(KIMAP2_LOG) << "FETCH reply got truncated, skipping.";
                     qCWarning(KIMAP2_LOG) << response.toString();
                     qCWarning(KIMAP2_LOG) << result.sequenceNumber;
                     qCWarning(KIMAP2_LOG) << content;
                     qCWarning(KIMAP2_LOG) << str;
                     break;
                 }
 
                 if (str == "UID") {
                     result.uid = it->toLongLong();
                 } else if (str == "RFC822.SIZE") {
                     result.size = it->toLongLong();
                 } else if (str == "INTERNALDATE") {
                     if (!result.message) {
                         result.message = MessagePtr(new KMime::Message);
                     }
                     result.message->date()->setDateTime(QDateTime::fromString(QLatin1String(*it), Qt::RFC2822Date));
                 } else if (str == "FLAGS") {
                     if ((*it).startsWith('(') && (*it).endsWith(')')) {
                         QByteArray str = *it;
                         str.chop(1);
                         str.remove(0, 1);
                         result.flags = str.split(' ');
                     } else {
                         result.flags << *it;
                     }
                 } else if (str == "X-GM-LABELS") {
                     result.attributes << qMakePair<QByteArray, QVariant>("X-GM-LABELS", *it);
                 } else if (str == "X-GM-THRID") {
                     result.attributes << qMakePair<QByteArray, QVariant>("X-GM-THRID", *it);
                 } else if (str == "X-GM-MSGID") {
                     result.attributes << qMakePair<QByteArray, QVariant>("X-GM-MSGID", *it);
                 } else if (str == "BODYSTRUCTURE") {
                     if (!result.message) {
                         result.message = MessagePtr(new KMime::Message);
                     }
                     int pos = 0;
                     d->parseBodyStructure(*it, pos, result.message.data());
                     result.message->assemble();
                 } else if (str.startsWith("BODY[")) {     //krazy:exclude=strings
                     if (!str.endsWith(']')) {     // BODY[ ... ] might have been split, skip until we find the ]
                         while (it != content.constEnd() && !(*it).endsWith(']')) {
                             ++it;
                         }
                     }
 
                     int index;
                     if ((index = str.indexOf("HEADER")) > 0 || (index = str.indexOf("MIME")) > 0) {           // headers
                         if (str[index - 1] == '.') {
                             QByteArray partId = str.mid(5, index - 6);
                             if (!result.parts.contains(partId)) {
                                 result.parts[partId] = ContentPtr(new KMime::Content);
                             }
                             result.parts[partId]->setHead(*it);
                             result.parts[partId]->parse();
                         } else {
                             if (!result.message) {
                                 result.message = MessagePtr(new KMime::Message);
                             }
                             shouldParseMessage = true;
                             result.message->setHead(*it);
                         }
                     } else { // full payload
                         if (str == "BODY[]") {
                             if (!result.message) {
                                 result.message = MessagePtr(new KMime::Message);
                             }
                             shouldParseMessage = true;
                             result.message->setContent(KMime::CRLFtoLF(*it));
                         } else {
                             QByteArray partId = str.mid(5, str.size() - 6);
                             if (!result.parts.contains(partId)) {
                                 result.parts[partId] = ContentPtr(new KMime::Content);
                             }
                             result.parts[partId]->setBody(*it);
                             result.parts[partId]->parse();
                         }
                     }
                 }
             }
 
             if (result.message && shouldParseMessage && !d->avoidParsing) {
                 result.message->parse();
             }
             emit resultReceived(result);
         }
     }
 }
 
 void FetchJobPrivate::parseBodyStructure(const QByteArray &structure, int &pos, KMime::Content *content)
 {
     skipLeadingSpaces(structure, pos);
 
     if (structure[pos] != '(') {
         return;
     }
 
     pos++;
 
     if (structure[pos] != '(') {   // simple part
         pos--;
         parsePart(structure, pos, content);
     } else { // multi part
         content->contentType()->setMimeType("MULTIPART/MIXED");
         while (pos < structure.size() && structure[pos] == '(') {
             KMime::Content *child = new KMime::Content;
             content->addContent(child);
             parseBodyStructure(structure, pos, child);
             child->assemble();
         }
 
         QByteArray subType = parseString(structure, pos);
         content->contentType()->setMimeType("MULTIPART/" + subType);
 
         QByteArray parameters = parseSentence(structure, pos);   // FIXME: Read the charset
         if (parameters.contains("BOUNDARY")) {
             content->contentType()->setBoundary(parameters.remove(0, parameters.indexOf("BOUNDARY") + 11).split('\"')[0]);
         }
 
         QByteArray disposition = parseSentence(structure, pos);
         if (disposition.contains("INLINE")) {
             content->contentDisposition()->setDisposition(KMime::Headers::CDinline);
         } else if (disposition.contains("ATTACHMENT")) {
             content->contentDisposition()->setDisposition(KMime::Headers::CDattachment);
         }
 
         parseSentence(structure, pos);   // Ditch the body language
     }
 
     // Consume what's left
     while (pos < structure.size() && structure[pos] != ')') {
         skipLeadingSpaces(structure, pos);
         parseSentence(structure, pos);
         skipLeadingSpaces(structure, pos);
     }
 
     pos++;
 }
 
 void FetchJobPrivate::parsePart(const QByteArray &structure, int &pos, KMime::Content *content)
 {
     if (structure[pos] != '(') {
         return;
     }
 
     pos++;
 
     QByteArray mainType = parseString(structure, pos);
     QByteArray subType = parseString(structure, pos);
 
     content->contentType()->setMimeType(mainType + '/' + subType);
 
     parseSentence(structure, pos);   // Ditch the parameters... FIXME: Read it to get charset and name
     parseString(structure, pos);   // ... and the id
 
     content->contentDescription()->from7BitString(parseString(structure, pos));
 
     parseString(structure, pos);   // Ditch the encoding too
     parseString(structure, pos);   // ... and the size
     parseString(structure, pos);   // ... and the line count
 
     QByteArray disposition = parseSentence(structure, pos);
     if (disposition.contains("INLINE")) {
         content->contentDisposition()->setDisposition(KMime::Headers::CDinline);
     } else if (disposition.contains("ATTACHMENT")) {
         content->contentDisposition()->setDisposition(KMime::Headers::CDattachment);
     }
     if ((content->contentDisposition()->disposition() == KMime::Headers::CDattachment ||
             content->contentDisposition()->disposition() == KMime::Headers::CDinline) &&
             disposition.contains("FILENAME")) {
         QByteArray filename = disposition.remove(0, disposition.indexOf("FILENAME") + 11).split('\"')[0];
         content->contentDisposition()->setFilename(QLatin1String(filename));
     }
 
     // Consume what's left
     while (pos < structure.size() && structure[pos] != ')') {
         skipLeadingSpaces(structure, pos);
         parseSentence(structure, pos);
         skipLeadingSpaces(structure, pos);
     }
 }
 
 QByteArray FetchJobPrivate::parseSentence(const QByteArray &structure, int &pos)
 {
     QByteArray result;
     int stack = 0;
 
     skipLeadingSpaces(structure, pos);
 
     if (structure[pos] != '(') {
         return parseString(structure, pos);
     }
 
     int start = pos;
 
     do {
         switch (structure[pos]) {
         case '(':
             pos++;
             stack++;
             break;
         case ')':
             pos++;
             stack--;
             break;
         case '[':
             pos++;
             stack++;
             break;
         case ']':
             pos++;
             stack--;
             break;
         default:
             skipLeadingSpaces(structure, pos);
             parseString(structure, pos);
             skipLeadingSpaces(structure, pos);
             break;
         }
     } while (pos < structure.size() && stack != 0);
 
     result = structure.mid(start, pos - start);
 
     return result;
 }
 
 QByteArray FetchJobPrivate::parseString(const QByteArray &structure, int &pos)
 {
     QByteArray result;
 
     skipLeadingSpaces(structure, pos);
 
     int start = pos;
     bool foundSlash = false;
 
     // quoted string
     if (structure[pos] == '"') {
         pos++;
         Q_FOREVER {
         if (structure[pos] == '\\')
             {
                 pos += 2;
                 foundSlash = true;
                 continue;
             }
             if (structure[pos] == '"')
             {
                 result = structure.mid(start + 1, pos - start - 1);
                 pos++;
                 break;
             }
             pos++;
         }
     } else { // unquoted string
         Q_FOREVER {
         if (structure[pos] == ' ' ||
             structure[pos] == '(' ||
             structure[pos] == ')' ||
             structure[pos] == '[' ||
             structure[pos] == ']' ||
             structure[pos] == '\n' ||
             structure[pos] == '\r' ||
             structure[pos] == '"')
             {
                 break;
             }
             if (structure[pos] == '\\')
             {
                 foundSlash = true;
             }
             pos++;
         }
 
         result = structure.mid(start, pos - start);
 
         // transform unquoted NIL
         if (result == "NIL") {
             result.clear();
         }
     }
 
     // simplify slashes
     if (foundSlash) {
         while (result.contains("\\\"")) {
             result.replace("\\\"", "\"");
         }
         while (result.contains("\\\\")) {
             result.replace("\\\\", "\\");
         }
     }
 
     return result;
 }
 
 void FetchJobPrivate::skipLeadingSpaces(const QByteArray &structure, int &pos)
 {
     while (pos < structure.size() && structure[pos] == ' ') {
         pos++;
     }
 }
 
 #include "moc_fetchjob.cpp"