File indexing completed on 2024-04-28 09:12:09

 /*  -*- c++ -*-
     kmime_header_parsing.cpp
 
     KMime, the KDE Internet mail/usenet news message library.
     SPDX-FileCopyrightText: 2001-2002 Marc Mutz <mutz@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kmime_header_parsing.h"
 
 #include "kmime_headerfactory_p.h"
 #include "kmime_headers.h"
 #include "kmime_util.h"
 #include "kmime_util_p.h"
 #include "kmime_codecs_p.h"
 #include "kmime_dateformatter.h"
 #include "kmime_debug.h"
 #include "kmime_warning_p.h"
 
 #include <KCodecs>
 
 #include <QMap>
 #include <QStringDecoder>
 #include <QTimeZone>
 
 #include <cassert>
 #include <cctype> // for isdigit
 
 using namespace KMime;
 using namespace KMime::Types;
 
 namespace KMime
 {
 
     namespace Types
     {
         // Optimization to avoid allocating QStrings when the value isn't encoded
         struct KMIME_EXPORT QStringOrQPair {
             QStringOrQPair() : qstring(), qpair(nullptr, 0) {}
             QString qstring;
             QPair<const char *, int> qpair;
         };
     } // namespace Types
 
 namespace HeaderParsing
 {
 
 // parse the encoded-word (scursor points to after the initial '=')
 bool parseEncodedWord(const char *&scursor, const char *const send,
                       QString &result, QByteArray &language,
                       QByteArray &usedCS, const QByteArray &defaultCS)
 {
     // make sure the caller already did a bit of the work.
     assert(*(scursor - 1) == '=');
 
     //
     // STEP 1:
     // scan for the charset/language portion of the encoded-word
     //
 
     char ch = *scursor++;
 
     if (ch != '?') {
         // qCDebug(KMIME_LOG) << "first";
         //KMIME_WARN_PREMATURE_END_OF( EncodedWord );
         return false;
     }
 
     // remember start of charset (ie. just after the initial "=?") and
     // language (just after the first '*') fields:
     const char *charsetStart = scursor;
     const char *languageStart = nullptr;
 
     // find delimiting '?' (and the '*' separating charset and language
     // tags, if any):
     for (; scursor != send ; scursor++) {
         if (*scursor == '?') {
             break;
         } else if (*scursor == '*' && languageStart == nullptr) {
             languageStart = scursor + 1;
         }
     }
 
     // not found? can't be an encoded-word!
     if (scursor == send || *scursor != '?') {
         // qCDebug(KMIME_LOG) << "second";
         KMIME_WARN_PREMATURE_END_OF(EncodedWord);
         return false;
     }
 
     // extract the language information, if any (if languageStart is 0,
     // language will be null, too):
     QByteArray maybeLanguage(languageStart, scursor - languageStart);
     // extract charset information (keep in mind: the size given to the
     // ctor is one off due to the \0 terminator):
     QByteArray maybeCharset(charsetStart,
                             (languageStart ? languageStart - 1 : scursor) - charsetStart);
 
     //
     // STEP 2:
     // scan for the encoding portion of the encoded-word
     //
 
     // remember start of encoding (just _after_ the second '?'):
     scursor++;
     const char *encodingStart = scursor;
 
     // find next '?' (ending the encoding tag):
     for (; scursor != send ; scursor++) {
         if (*scursor == '?') {
             break;
         }
     }
 
     // not found? Can't be an encoded-word!
     if (scursor == send || *scursor != '?') {
         // qCDebug(KMIME_LOG) << "third";
         KMIME_WARN_PREMATURE_END_OF(EncodedWord);
         return false;
     }
 
     // extract the encoding information:
     QByteArray maybeEncoding(encodingStart, scursor - encodingStart);
 
     // qCDebug(KMIME_LOG) << "parseEncodedWord: found charset == \"" << maybeCharset
     //         << "\"; language == \"" << maybeLanguage
     //         << "\"; encoding == \"" << maybeEncoding << "\"";
 
     //
     // STEP 3:
     // scan for encoded-text portion of encoded-word
     //
 
     // remember start of encoded-text (just after the third '?'):
     scursor++;
     const char *encodedTextStart = scursor;
 
     // find the '?=' sequence (ending the encoded-text):
     for (; scursor != send ; scursor++) {
         if (*scursor == '?') {
             if (scursor + 1 != send) {
                 if (*(scursor + 1) != '=') {     // We expect a '=' after the '?', but we got something else; ignore
                     KMIME_WARN << "Stray '?' in q-encoded word, ignoring this.";
                     continue;
                 } else { // yep, found a '?=' sequence
                     scursor += 2;
                     break;
                 }
             } else { // The '?' is the last char, but we need a '=' after it!
                 KMIME_WARN_PREMATURE_END_OF(EncodedWord);
                 return false;
             }
         }
     }
 
     if (*(scursor - 2) != '?' || *(scursor - 1) != '=' ||
             scursor < encodedTextStart + 2) {
         KMIME_WARN_PREMATURE_END_OF(EncodedWord);
         return false;
     }
 
     // set end sentinel for encoded-text:
     const char *const encodedTextEnd = scursor - 2;
 
     //
     // STEP 4:
     // setup decoders for the transfer encoding and the charset
     //
 
     // try if there's a codec for the encoding found:
     KCodecs::Codec *codec = KCodecs::Codec::codecForName(maybeEncoding);
     if (!codec) {
         KMIME_WARN_UNKNOWN(Encoding, maybeEncoding);
         return false;
     }
 
     // get an instance of a corresponding decoder:
     KCodecs::Decoder *dec = codec->makeDecoder();
     assert(dec);
 
     // try if there's a (text)codec for the charset found:
     QStringDecoder textCodec;
     if (maybeCharset.isEmpty()) {
         textCodec = QStringDecoder(defaultCS.constData());
         if (!textCodec.isValid()) {
             textCodec = QStringDecoder(QStringDecoder::Latin1);
         }
         usedCS = cachedCharset(defaultCS);
     } else {
         textCodec = QStringDecoder(maybeCharset.constData());
         if (textCodec.isValid()) {    //no suitable codec found => use default charset
             usedCS = cachedCharset(defaultCS);
         } else {
             textCodec = QStringDecoder(QStringDecoder::Latin1);
             usedCS = cachedCharset(maybeCharset);
         }
     }
 
     if (!textCodec.isValid()) {
         KMIME_WARN_UNKNOWN(Charset, maybeCharset);
         delete dec;
         return false;
     };
 
     // qCDebug(KMIME_LOG) << "mimeName(): \"" << textCodec->name() << "\"";
 
     // allocate a temporary buffer to store the 8bit text:
     int encodedTextLength = encodedTextEnd - encodedTextStart;
     QByteArray buffer;
     buffer.resize(codec->maxDecodedSizeFor(encodedTextLength));
     char *bbegin = buffer.data();
     char *bend = bbegin + buffer.length();
 
     //
     // STEP 5:
     // do the actual decoding
     //
 
     if (!dec->decode(encodedTextStart, encodedTextEnd, bbegin, bend)) {
         KMIME_WARN << codec->name() << "codec lies about its maxDecodedSizeFor("
                    << encodedTextLength << ")\nresult may be truncated";
     }
 
     result = textCodec.decode(QByteArrayView(buffer.data(), bbegin - buffer.data()));
 
     // qCDebug(KMIME_LOG) << "result now: \"" << result << "\"";
     // cleanup:
     delete dec;
     language = maybeLanguage;
 
     return true;
 }
 
 static inline void eatWhiteSpace(const char *&scursor, const char *const send)
 {
     while (scursor != send &&
             (*scursor == ' ' || *scursor == '\n' ||
              *scursor == '\t' || *scursor == '\r')) {
         scursor++;
     }
 }
 
 bool parseAtom(const char*&scursor, const char *const send,
                QByteArray &result, bool allow8Bit)
 {
     QPair<const char *, int> maybeResult;
 
     if (parseAtom(scursor, send, maybeResult, allow8Bit)) {
         result = QByteArray(maybeResult.first, maybeResult.second);
         return true;
     }
 
     return false;
 }
 
 bool parseAtom(const char*&scursor, const char *const send,
                QPair<const char *, int> &result, bool allow8Bit)
 {
     bool success = false;
     const char *start = scursor;
 
     while (scursor != send) {
         signed char ch = *scursor++;
         if (ch > 0 && isAText(ch)) {
             // AText: OK
             success = true;
         } else if (allow8Bit && ch < 0) {
             // 8bit char: not OK, but be tolerant.
             KMIME_WARN_8BIT(ch);
             success = true;
         } else {
             // CTL or special - marking the end of the atom:
             // re-set sursor to point to the offending
             // char and return:
             scursor--;
             break;
         }
     }
     result.first = start;
     result.second = scursor - start;
     return success;
 }
 
 bool parseToken(const char*&scursor, const char *const send,
                 QByteArray &result, ParseTokenFlags flags)
 {
     QPair<const char *, int> maybeResult;
 
     if (parseToken(scursor, send, maybeResult, flags)) {
         result = QByteArray(maybeResult.first, maybeResult.second);
         return true;
     }
 
     return false;
 }
 
 bool parseToken(const char*&scursor, const char *const send,
                 QPair<const char *, int> &result, ParseTokenFlags flags)
 {
     bool success = false;
     const char *start = scursor;
 
     while (scursor != send) {
         signed char ch = *scursor++;
         if (ch > 0 && isTText(ch)) {
             // TText: OK
             success = true;
         } else if ((flags & ParseTokenAllow8Bit) && ch < 0) {
             // 8bit char: not OK, but be tolerant.
             KMIME_WARN_8BIT(ch);
             success = true;
         } else if ((flags & ParseTokenRelaxedTText) && ch == '/') {
             success = true;
         } else {
             // CTL or tspecial - marking the end of the atom:
             // re-set sursor to point to the offending
             // char and return:
             scursor--;
             break;
         }
     }
     result.first = start;
     result.second = scursor - start;
     return success;
 }
 
 #define READ_ch_OR_FAIL if ( scursor == send ) {        \
         KMIME_WARN_PREMATURE_END_OF( GenericQuotedString ); \
         return false;                                       \
     } else {                                              \
         ch = *scursor++;                                    \
     }
 
 // known issues:
 //
 // - doesn't handle quoted CRLF
 
 bool parseGenericQuotedString(const char *&scursor, const char *const send,
                               QString &result, bool isCRLF,
                               const char openChar, const char closeChar)
 {
     // We are in a quoted-string or domain-literal or comment and the
     // cursor points to the first char after the openChar.
     // We will apply unfolding and quoted-pair removal.
     // We return when we either encounter the end or unescaped openChar
     // or closeChar.
     assert(*(scursor - 1) == openChar || *(scursor - 1) == closeChar);
 
     while (scursor != send) {
         char ch = *scursor++;
 
         if (ch == closeChar || ch == openChar) {
             // end of quoted-string or another opening char:
             // let caller decide what to do.
             return true;
         }
 
         switch (ch) {
         case '\\':      // quoted-pair
             // misses "\" CRLF LWSP-char handling, see rfc822, 3.4.5
             READ_ch_OR_FAIL;
             KMIME_WARN_IF_8BIT(ch);
             result += QLatin1Char(ch);
             break;
         case '\r':
             // ###
             // The case of lonely '\r' is easy to solve, as they're
             // not part of Unix Line-ending conventions.
             // But I see a problem if we are given Unix-native
             // line-ending-mails, where we cannot determine anymore
             // whether a given '\n' was part of a CRLF or was occurring
             // on it's own.
             READ_ch_OR_FAIL;
             if (ch != '\n') {
                 // CR on it's own...
                 KMIME_WARN_LONE(CR);
                 result += QLatin1Char('\r');
                 scursor--; // points to after the '\r' again
             } else {
                 // CRLF encountered.
                 // lookahead: check for folding
                 READ_ch_OR_FAIL;
                 if (ch == ' ' || ch == '\t') {
                     // correct folding;
                     // position cursor behind the CRLF WSP (unfolding)
                     // and add the WSP to the result
                     result += QLatin1Char(ch);
                 } else {
                     // this is the "shouldn't happen"-case. There is a CRLF
                     // inside a quoted-string without it being part of FWS.
                     // We take it verbatim.
                     KMIME_WARN_NON_FOLDING(CRLF);
                     result += QLatin1String("\r\n");
                     // the cursor is decremented again, so's we need not
                     // duplicate the whole switch here. "ch" could've been
                     // everything (incl. openChar or closeChar).
                     scursor--;
                 }
             }
             break;
         case '\n':
             // Note: CRLF has been handled above already!
             // ### LF needs special treatment, depending on whether isCRLF
             // is true (we can be sure a lonely '\n' was meant this way) or
             // false ('\n' alone could have meant LF or CRLF in the original
             // message. This parser assumes CRLF iff the LF is followed by
             // either WSP (folding) or NULL (premature end of quoted-string;
             // Should be fixed, since NULL is allowed as per rfc822).
             READ_ch_OR_FAIL;
             if (!isCRLF && (ch == ' ' || ch == '\t')) {
                 // folding
                 // correct folding
                 result += QLatin1Char(ch);
             } else {
                 // non-folding
                 KMIME_WARN_LONE(LF);
                 result += QLatin1Char('\n');
                 // pos is decremented, so's we need not duplicate the whole
                 // switch here. ch could've been everything (incl. <">, "\").
                 scursor--;
             }
             break;
         case '=': {
             // ### Work around broken clients that send encoded words in quoted-strings
             //     For example, older KMail versions.
             if (scursor == send) {
                 break;
             }
 
             const char *oldscursor = scursor;
             QString tmp;
             QByteArray lang;
             QByteArray charset;
             if (*scursor++ == '?') {
                 --scursor;
                 if (parseEncodedWord(scursor, send, tmp, lang, charset)) {
                     result += tmp;
                     //qDebug() << " tmp " << tmp;
                     if (scursor == send) {
                         break;
                     } else if (*scursor++ == ' ') { //Workaround Bug 362650 thunderbird add space for each new line
                         if (scursor == send) {
                             --scursor;
                             break;
                         } else if (*scursor++ == '=') {
                             if (scursor == send) {
                                 --scursor;
                                 --scursor;
                                 break;
                             } else if (*scursor++ == '?') {
                                 --scursor;
                                 --scursor;
                                 break;
                             }
                         } else {
                             --scursor;
                             --scursor;
                         }
                     } else {
                         --scursor;
                     }
 
                     break;
                 } else {
                     scursor = oldscursor;
                 }
             } else {
                 scursor = oldscursor;
             }
             // fall through
             [[fallthrough]];
         }
         default:
             KMIME_WARN_IF_8BIT(ch);
             result += QLatin1Char(ch);
         }
     }
 
     return false;
 }
 
 // known issues:
 //
 // - doesn't handle encoded-word inside comments.
 
 bool parseComment(const char *&scursor, const char *const send,
                   QString &result, bool isCRLF, bool reallySave)
 {
     int commentNestingDepth = 1;
     const char *afterLastClosingParenPos = nullptr;
     QString maybeCmnt;
     const char *oldscursor = scursor;
 
     assert(*(scursor - 1) == '(');
 
     while (commentNestingDepth) {
         QString cmntPart;
         if (parseGenericQuotedString(scursor, send, cmntPart, isCRLF, '(', ')')) {
             assert(*(scursor - 1) == ')' || *(scursor - 1) == '(');
             // see the kdoc for above function for the possible conditions
             // we have to check:
             switch (*(scursor - 1)) {
             case ')':
                 if (reallySave) {
                     // add the chunk that's now surely inside the comment.
                     result += maybeCmnt;
                     result += cmntPart;
                     if (commentNestingDepth > 1) {
                         // don't add the outermost ')'...
                         result += QLatin1Char(')');
                     }
                     maybeCmnt.clear();
                 }
                 afterLastClosingParenPos = scursor;
                 --commentNestingDepth;
                 break;
             case '(':
                 if (reallySave) {
                     // don't add to "result" yet, because we might find that we
                     // are already outside the (broken) comment...
                     maybeCmnt += cmntPart;
                     maybeCmnt += QLatin1Char('(');
                 }
                 ++commentNestingDepth;
                 break;
             default: assert(0);
             } // switch
         } else {
             // !parseGenericQuotedString, ie. premature end
             if (afterLastClosingParenPos) {
                 scursor = afterLastClosingParenPos;
             } else {
                 scursor = oldscursor;
             }
             return false;
         }
     } // while
 
     return true;
 }
 
 // known issues: none.
 
 bool parsePhrase(const char *&scursor, const char *const send,
                  QString &result, bool isCRLF)
 {
     enum {
         None, Phrase, Atom, EncodedWord, QuotedString
     } found = None;
 
     QString tmp;
     QByteArray lang;
     QByteArray charset;
     QPair<const char *, int> tmpAtom;
     const char *successfullyParsed = nullptr;
     // only used by the encoded-word branch
     const char *oldscursor;
     // used to suppress whitespace between adjacent encoded-words
     // (rfc2047, 6.2):
     bool lastWasEncodedWord = false;
 
     while (scursor != send) {
         char ch = *scursor++;
         switch (ch) {
         case '.': // broken, but allow for intorop's sake
             if (found == None) {
                 --scursor;
                 return false;
             } else {
                 if (scursor != send && (*scursor == ' ' || *scursor == '\t')) {
                     result += QLatin1String(". ");
                 } else {
                     result += QLatin1Char('.');
                 }
                 successfullyParsed = scursor;
             }
             break;
         case '"': // quoted-string
             tmp.clear();
             if (parseGenericQuotedString(scursor, send, tmp, isCRLF, '"', '"')) {
                 successfullyParsed = scursor;
                 assert(*(scursor - 1) == '"');
                 switch (found) {
                 case None:
                     found = QuotedString;
                     break;
                 case Phrase:
                 case Atom:
                 case EncodedWord:
                 case QuotedString:
                     found = Phrase;
                     result += QLatin1Char(' ');   // rfc822, 3.4.4
                     break;
                 default:
                     assert(0);
                 }
                 lastWasEncodedWord = false;
                 result += tmp;
             } else {
                 // premature end of quoted string.
                 // What to do? Return leading '"' as special? Return as quoted-string?
                 // We do the latter if we already found something, else signal failure.
                 if (found == None) {
                     return false;
                 } else {
                     result += QLatin1Char(' ');   // rfc822, 3.4.4
                     result += tmp;
                     return true;
                 }
             }
             break;
         case '(': // comment
             // parse it, but ignore content:
             tmp.clear();
             if (parseComment(scursor, send, tmp, isCRLF,
                              false /*don't bother with the content*/)) {
                 successfullyParsed = scursor;
                 lastWasEncodedWord = false; // strictly interpreting rfc2047, 6.2
             } else {
                 if (found == None) {
                     return false;
                 } else {
                     scursor = successfullyParsed;
                     return true;
                 }
             }
             break;
         case '=': // encoded-word
             tmp.clear();
             oldscursor = scursor;
             lang.clear();
             charset.clear();
             if (parseEncodedWord(scursor, send, tmp, lang, charset)) {
                 successfullyParsed = scursor;
                 switch (found) {
                 case None:
                     found = EncodedWord;
                     break;
                 case Phrase:
                 case EncodedWord:
                 case Atom:
                 case QuotedString:
                     if (!lastWasEncodedWord) {
                         result += QLatin1Char(' ');   // rfc822, 3.4.4
                     }
                     found = Phrase;
                     break;
                 default: assert(0);
                 }
                 lastWasEncodedWord = true;
                 result += tmp;
                 break;
             } else {
                 // parse as atom:
                 scursor = oldscursor;
             }
             [[fallthrough]];
             // fall though...
 
         default: //atom
             scursor--;
             if (parseAtom(scursor, send, tmpAtom, true /* allow 8bit */)) {
                 successfullyParsed = scursor;
                 switch (found) {
                 case None:
                     found = Atom;
                     break;
                 case Phrase:
                 case Atom:
                 case EncodedWord:
                 case QuotedString:
                     found = Phrase;
                     result += QLatin1Char(' ');   // rfc822, 3.4.4
                     break;
                 default:
                     assert(0);
                 }
                 lastWasEncodedWord = false;
                 result += QLatin1String(tmpAtom.first, tmpAtom.second);
             } else {
                 if (found == None) {
                     return false;
                 } else {
                     scursor = successfullyParsed;
                     return true;
                 }
             }
         }
         eatWhiteSpace(scursor, send);
     }
 
     return found != None;
 }
 
 bool parseDotAtom(const char *&scursor, const char *const send,
                   QByteArray &result, bool isCRLF)
 {
     eatCFWS(scursor, send, isCRLF);
 
     // always points to just after the last atom parsed:
     const char *successfullyParsed;
 
     QByteArray tmp;
     if (!parseAtom(scursor, send, tmp, false /* no 8bit */)) {
         return false;
     }
     result += tmp;
     successfullyParsed = scursor;
 
     while (scursor != send) {
 
         // end of header or no '.' -> return
         if (scursor == send || *scursor != '.') {
             return true;
         }
         scursor++; // eat '.'
 
         if (scursor == send || !isAText(*scursor)) {
             // end of header or no AText, but this time following a '.'!:
             // reset cursor to just after last successfully parsed char and
             // return:
             scursor = successfullyParsed;
             return true;
         }
 
         // try to parse the next atom:
         QByteArray maybeAtom;
         if (!parseAtom(scursor, send, maybeAtom, false /*no 8bit*/)) {
             scursor = successfullyParsed;
             return true;
         }
 
         result += '.';
         result += maybeAtom;
         successfullyParsed = scursor;
     }
 
     scursor = successfullyParsed;
     return true;
 }
 
 void eatCFWS(const char *&scursor, const char *const send, bool isCRLF)
 {
     QString dummy;
 
     while (scursor != send) {
         const char *oldscursor = scursor;
 
         char ch = *scursor++;
 
         switch (ch) {
         case ' ':
         case '\t': // whitespace
         case '\r':
         case '\n': // folding
             continue;
 
         case '(': // comment
             if (parseComment(scursor, send, dummy, isCRLF, false /*don't save*/)) {
                 continue;
             }
             scursor = oldscursor;
             return;
 
         default:
             scursor = oldscursor;
             return;
         }
     }
 }
 
 bool parseDomain(const char *&scursor, const char *const send,
                  QString &result, bool isCRLF)
 {
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     // domain := dot-atom / domain-literal / atom *("." atom)
     //
     // equivalent to:
     // domain = dot-atom / domain-literal,
     // since parseDotAtom does allow CFWS between atoms and dots
 
     if (*scursor == '[') {
         // domain-literal:
         QString maybeDomainLiteral;
         // eat '[':
         scursor++;
         while (parseGenericQuotedString(scursor, send, maybeDomainLiteral,
                                         isCRLF, '[', ']')) {
             if (scursor == send) {
                 // end of header: check for closing ']':
                 if (*(scursor - 1) == ']') {
                     // OK, last char was ']':
                     result = maybeDomainLiteral;
                     return true;
                 } else {
                     // not OK, domain-literal wasn't closed:
                     return false;
                 }
             }
             // we hit openChar in parseGenericQuotedString.
             // include it in maybeDomainLiteral and keep on parsing:
             if (*(scursor - 1) == '[') {
                 maybeDomainLiteral += QLatin1Char('[');
                 continue;
             }
             // OK, real end of domain-literal:
             result = maybeDomainLiteral;
             return true;
         }
     } else {
         // dot-atom:
         QByteArray maybeDotAtom;
         if (parseDotAtom(scursor, send, maybeDotAtom, isCRLF)) {
             // Domain may end with '.', if so preserve it'
             if (scursor != send && *scursor == '.') {
                 maybeDotAtom += '.';
                 scursor++;
             }
             result = QString::fromLatin1(maybeDotAtom);
             return true;
         }
     }
     return false;
 }
 
 bool parseObsRoute(const char *&scursor, const char *const send,
                    QStringList &result, bool isCRLF, bool save)
 {
     while (scursor != send) {
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
 
         // empty entry:
         if (*scursor == ',') {
             scursor++;
             if (save) {
                 result.append(QString());
             }
             continue;
         }
 
         // empty entry ending the list:
         if (*scursor == ':') {
             scursor++;
             if (save) {
                 result.append(QString());
             }
             return true;
         }
 
         // each non-empty entry must begin with '@':
         if (*scursor != '@') {
             return false;
         } else {
             scursor++;
         }
 
         QString maybeDomain;
         if (!parseDomain(scursor, send, maybeDomain, isCRLF)) {
             return false;
         }
         if (save) {
             result.append(maybeDomain);
         }
 
         // eat the following (optional) comma:
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
         if (*scursor == ':') {
             scursor++;
             return true;
         }
         if (*scursor == ',') {
             scursor++;
         }
     }
 
     return false;
 }
 
 bool parseAddrSpec(const char *&scursor, const char *const send,
                    AddrSpec &result, bool isCRLF)
 {
     //
     // STEP 1:
     // local-part := dot-atom / quoted-string / word *("." word)
     //
     // this is equivalent to:
     // local-part := word *("." word)
 
     QString maybeLocalPart;
     QString tmp;
     QPair<const char *, int> tmpAtom;
 
     while (scursor != send) {
         // first, eat any whitespace
         eatCFWS(scursor, send, isCRLF);
 
         char ch = *scursor++;
         switch (ch) {
         case '.': // dot
             maybeLocalPart += QLatin1Char('.');
             break;
 
         case '@':
             goto SAW_AT_SIGN;
             break;
 
         case '"': // quoted-string
             tmp.clear();
             if (parseGenericQuotedString(scursor, send, tmp, isCRLF, '"', '"')) {
                 maybeLocalPart += tmp;
             } else {
                 return false;
             }
             break;
 
         default: // atom
             scursor--; // re-set scursor to point to ch again
             if (parseAtom(scursor, send, tmpAtom, false /* no 8bit */)) {
                 maybeLocalPart += QLatin1String(tmpAtom.first, tmpAtom.second);
             } else {
                 return false; // parseAtom can only fail if the first char is non-atext.
             }
             break;
         }
     }
 
     return false;
 
     //
     // STEP 2:
     // domain
     //
 
 SAW_AT_SIGN:
 
     assert(*(scursor - 1) == '@');
 
     QString maybeDomain;
     if (!parseDomain(scursor, send, maybeDomain, isCRLF)) {
         return false;
     }
 
     result.localPart = maybeLocalPart;
     result.domain = maybeDomain;
 
     return true;
 }
 
 bool parseAngleAddr(const char *&scursor, const char *const send,
                     AddrSpec &result, bool isCRLF)
 {
     // first, we need an opening angle bracket:
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send || *scursor != '<') {
         return false;
     }
     scursor++; // eat '<'
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     if (*scursor == '@' || *scursor == ',') {
         // obs-route: parse, but ignore:
         KMIME_WARN << "obsolete source route found! ignoring.";
         QStringList dummy;
         if (!parseObsRoute(scursor, send, dummy,
                            isCRLF, false /* don't save */)) {
             return false;
         }
         // angle-addr isn't complete until after the '>':
         if (scursor == send) {
             return false;
         }
     }
 
     // parse addr-spec:
     AddrSpec maybeAddrSpec;
     if (!parseAddrSpec(scursor, send, maybeAddrSpec, isCRLF)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send || *scursor != '>') {
         return false;
     }
     scursor++;
 
     result = maybeAddrSpec;
     return true;
 
 }
 
 static QString stripQuotes(const QString &input)
 {
     const QLatin1Char quotes('"');
     if (input.startsWith(quotes) && input.endsWith(quotes)) {
         QString stripped(input.mid(1, input.size() - 2));
         return stripped;
     } else {
         return input;
     }
 }
 
 bool parseMailbox(const char *&scursor, const char *const send,
                   Mailbox &result, bool isCRLF)
 {
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     AddrSpec maybeAddrSpec;
     QString maybeDisplayName;
 
     // first, try if it's a vanilla addr-spec:
     const char *oldscursor = scursor;
     if (parseAddrSpec(scursor, send, maybeAddrSpec, isCRLF)) {
         result.setAddress(maybeAddrSpec);
         // check for the obsolete form of display-name (as comment):
         eatWhiteSpace(scursor, send);
         if (scursor != send && *scursor == '(') {
             scursor++;
             if (!parseComment(scursor, send, maybeDisplayName, isCRLF, true /*keep*/)) {
                 return false;
             }
         }
         result.setName(stripQuotes(maybeDisplayName));
         return true;
     }
     scursor = oldscursor;
 
     // second, see if there's a display-name:
     if (!parsePhrase(scursor, send, maybeDisplayName, isCRLF)) {
         // failed: reset cursor, note absent display-name
         maybeDisplayName.clear();
         scursor = oldscursor;
     } else {
         // succeeded: eat CFWS
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
     }
 
     // third, parse the angle-addr:
     if (!parseAngleAddr(scursor, send, maybeAddrSpec, isCRLF)) {
         return false;
     }
 
     if (maybeDisplayName.isNull()) {
         // check for the obsolete form of display-name (as comment):
         eatWhiteSpace(scursor, send);
         if (scursor != send && *scursor == '(') {
             scursor++;
             if (!parseComment(scursor, send, maybeDisplayName, isCRLF, true /*keep*/)) {
                 return false;
             }
         }
     }
 
     result.setName(stripQuotes(maybeDisplayName));
     result.setAddress(maybeAddrSpec);
     return true;
 }
 
 bool parseGroup(const char *&scursor, const char *const send,
                 Address &result, bool isCRLF)
 {
     // group         := display-name ":" [ mailbox-list / CFWS ] ";" [CFWS]
     //
     // equivalent to:
     // group   := display-name ":" [ obs-mbox-list ] ";"
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     // get display-name:
     QString maybeDisplayName;
     if (!parsePhrase(scursor, send, maybeDisplayName, isCRLF)) {
         return false;
     }
 
     // get ":":
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send || *scursor != ':') {
         return false;
     }
 
     // KDE5 TODO: Don't expose displayName as public, but rather add setter for it that
     //            automatically calls removeBidiControlChars
     result.displayName = removeBidiControlChars(maybeDisplayName);
 
     // get obs-mbox-list (may contain empty entries):
     scursor++;
     while (scursor != send) {
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
 
         // empty entry:
         if (*scursor == ',') {
             scursor++;
             continue;
         }
 
         // empty entry ending the list:
         if (*scursor == ';') {
             scursor++;
             return true;
         }
 
         Mailbox maybeMailbox;
         if (!parseMailbox(scursor, send, maybeMailbox, isCRLF)) {
             return false;
         }
         result.mailboxList.append(maybeMailbox);
 
         eatCFWS(scursor, send, isCRLF);
         // premature end:
         if (scursor == send) {
             return false;
         }
         // regular end of the list:
         if (*scursor == ';') {
             scursor++;
             return true;
         }
         // eat regular list entry separator:
         if (*scursor == ',') {
             scursor++;
         }
     }
     return false;
 }
 
 bool parseAddress(const char *&scursor, const char *const send,
                   Address &result, bool isCRLF)
 {
     // address       := mailbox / group
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     // first try if it's a single mailbox:
     Mailbox maybeMailbox;
     const char *oldscursor = scursor;
     if (parseMailbox(scursor, send, maybeMailbox, isCRLF)) {
         // yes, it is:
         result.displayName.clear();
         result.mailboxList.append(maybeMailbox);
         return true;
     }
     scursor = oldscursor;
 
     Address maybeAddress;
 
     // no, it's not a single mailbox. Try if it's a group:
     if (!parseGroup(scursor, send, maybeAddress, isCRLF)) {
         return false;
     }
 
     result = maybeAddress;
     return true;
 }
 
 bool parseAddressList(const char *&scursor, const char *const send,
                       AddressList &result, bool isCRLF)
 {
     while (scursor != send) {
         eatCFWS(scursor, send, isCRLF);
         // end of header: this is OK.
         if (scursor == send) {
             return true;
         }
         // empty entry: ignore:
         if (*scursor == ',') {
             scursor++;
             continue;
         }
         // broken clients might use ';' as list delimiter, accept that as well
         if (*scursor == ';') {
             scursor++;
             continue;
         }
 
         // parse one entry
         Address maybeAddress;
         if (!parseAddress(scursor, send, maybeAddress, isCRLF)) {
             return false;
         }
         result.append(maybeAddress);
 
         eatCFWS(scursor, send, isCRLF);
         // end of header: this is OK.
         if (scursor == send) {
             return true;
         }
         // comma separating entries: eat it.
         if (*scursor == ',') {
             scursor++;
         }
     }
     return true;
 }
 
 static bool parseParameter(const char *&scursor, const char *const send,
                            QPair<QString, QStringOrQPair> &result, bool isCRLF)
 {
     // parameter = regular-parameter / extended-parameter
     // regular-parameter = regular-parameter-name "=" value
     // extended-parameter =
     // value = token / quoted-string
     //
     // note that rfc2231 handling is out of the scope of this function.
     // Therefore we return the attribute as QByteArray and the value as
     // (start,length) tuple if we see that the value is encoded
     // (trailing asterisk), for parseParameterList to decode...
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     //
     // parse the parameter name:
     //
     QByteArray tmpAttr;
     if (!parseToken(scursor, send, tmpAttr, ParseTokenNoFlag)) {
         return false;
     }
     // FIXME: we could use QMap<QByteArray, ...> in the API for parameters
     QString maybeAttribute = QString::fromLatin1(tmpAttr);
 
     eatCFWS(scursor, send, isCRLF);
     // premature end: not OK (haven't seen '=' yet).
     if (scursor == send || *scursor != '=') {
         return false;
     }
     scursor++; // eat '='
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         // don't choke on attribute=, meaning the value was omitted:
         if (maybeAttribute.endsWith(QLatin1Char('*'))) {
             KMIME_WARN << "attribute ends with \"*\", but value is empty!"
                        "Chopping away \"*\".";
             maybeAttribute.chop(1);
         }
         result = qMakePair(maybeAttribute.toLower(), QStringOrQPair());
         return true;
     }
 
     const char *oldscursor = scursor;
 
     //
     // parse the parameter value:
     //
     QStringOrQPair maybeValue;
     if (*scursor == '"') {
         // value is a quoted-string:
         scursor++;
         if (maybeAttribute.endsWith(QLatin1Char('*'))) {
             // attributes ending with "*" designate extended-parameters,
             // which cannot have quoted-strings as values. So we remove the
             // trailing "*" to not confuse upper layers.
             KMIME_WARN << "attribute ends with \"*\", but value is a quoted-string!"
                        "Chopping away \"*\".";
             maybeAttribute.chop(1);
         }
 
         if (!parseGenericQuotedString(scursor, send, maybeValue.qstring, isCRLF)) {
             scursor = oldscursor;
             result = qMakePair(maybeAttribute.toLower(), QStringOrQPair());
             return false; // this case needs further processing by upper layers!!
         }
     } else {
         // value is a token:
         if (!parseToken(scursor, send, maybeValue.qpair, ParseTokenRelaxedTText)) {
             scursor = oldscursor;
             result = qMakePair(maybeAttribute.toLower(), QStringOrQPair());
             return false; // this case needs further processing by upper layers!!
         }
     }
 
     result = qMakePair(maybeAttribute.toLower(), maybeValue);
     return true;
 }
 
 static bool parseRawParameterList(const char *&scursor, const char *const send,
                                   QMap<QString, QStringOrQPair> &result,
                                   bool isCRLF)
 {
     // we use parseParameter() consecutively to obtain a map of raw
     // attributes to raw values. "Raw" here means that we don't do
     // rfc2231 decoding and concatenation. This is left to
     // parseParameterList(), which will call this function.
     //
     // The main reason for making this chunk of code a separate
     // (private) method is that we can deal with broken parameters
     // _here_ and leave the rfc2231 handling solely to
     // parseParameterList(), which will still be enough work.
     while (scursor != send) {
         eatCFWS(scursor, send, isCRLF);
         // empty entry ending the list: OK.
         if (scursor == send) {
             return true;
         }
         // empty list entry: ignore.
         if (*scursor == ';') {
             scursor++;
             continue;
         }
         QPair<QString, QStringOrQPair> maybeParameter;
         if (!parseParameter(scursor, send, maybeParameter, isCRLF)) {
             // we need to do a bit of work if the attribute is not
             // NULL. These are the cases marked with "needs further
             // processing" in parseParameter(). Specifically, parsing of the
             // token or the quoted-string, which should represent the value,
             // failed. We take the easy way out and simply search for the
             // next ';' to start parsing again. (Another option would be to
             // take the text between '=' and ';' as value)
             if (maybeParameter.first.isNull()) {
                 return false;
             }
             while (scursor != send) {
                 if (*scursor++ == ';') {
                     goto IS_SEMICOLON;
                 }
             }
             // scursor == send case: end of list.
             return true;
         IS_SEMICOLON:
             // *scursor == ';' case: parse next entry.
             continue;
         }
         // successful parsing brings us here:
         result.insert(maybeParameter.first, maybeParameter.second);
 
         eatCFWS(scursor, send, isCRLF);
         // end of header: ends list.
         if (scursor == send) {
             return true;
         }
         // regular separator: eat it.
         if (*scursor == ';') {
             scursor++;
         }
     }
     return true;
 }
 
 static void decodeRFC2231Value(KCodecs::Codec *&rfc2231Codec,
                                QStringDecoder &textcodec,
                                bool isContinuation, QString &value,
                                QPair<const char *, int> &source, QByteArray &charset)
 {
     //
     // parse the raw value into (charset,language,text):
     //
 
     const char *decBegin = source.first;
     const char *decCursor = decBegin;
     const char *decEnd = decCursor + source.second;
 
     if (!isContinuation) {
         // find the first single quote
         while (decCursor != decEnd) {
             if (*decCursor == '\'') {
                 break;
             } else {
                 decCursor++;
             }
         }
 
         if (decCursor == decEnd) {
             // there wasn't a single single quote at all!
             // take the whole value to be in latin-1:
             KMIME_WARN << "No charset in extended-initial-value."
                        "Assuming \"iso-8859-1\".";
             value += QString::fromLatin1(decBegin, source.second);
             return;
         }
 
         charset = QByteArray(decBegin, decCursor - decBegin);
 
         const char *oldDecCursor = ++decCursor;
         // find the second single quote (we ignore the language tag):
         while (decCursor != decEnd) {
             if (*decCursor == '\'') {
                 break;
             } else {
                 decCursor++;
             }
         }
         if (decCursor == decEnd) {
             KMIME_WARN << "No language in extended-initial-value."
                        "Trying to recover.";
             decCursor = oldDecCursor;
         } else {
             decCursor++;
         }
 
         // decCursor now points to the start of the
         // "extended-other-values":
 
         //
         // get the decoders:
         //
 
         textcodec = QStringDecoder(charset.constData());
         if (!textcodec.isValid()) {
             KMIME_WARN_UNKNOWN(Charset, charset);
         }
     }
 
     if (!rfc2231Codec) {
         rfc2231Codec = KCodecs::Codec::codecForName("x-kmime-rfc2231");
         assert(rfc2231Codec);
     }
 
     if (!textcodec.isValid()) {
         value += QString::fromLatin1(decCursor, decEnd - decCursor);
         return;
     }
 
     KCodecs::Decoder *dec = rfc2231Codec->makeDecoder();
     assert(dec);
 
     //
     // do the decoding:
     //
 
     QByteArray buffer;
     buffer.resize(rfc2231Codec->maxDecodedSizeFor(decEnd - decCursor));
     QByteArray::Iterator bit = buffer.begin();
     QByteArray::ConstIterator bend = buffer.end();
 
     if (!dec->decode(decCursor, decEnd, bit, bend)) {
         KMIME_WARN << rfc2231Codec->name()
                    << "codec lies about its maxDecodedSizeFor()"
                    << Qt::endl
                    << "result may be truncated";
     }
 
     value += textcodec.decode(QByteArrayView(buffer.begin(), bit - buffer.begin()));
 
     // qCDebug(KMIME_LOG) << "value now: \"" << value << "\"";
     // cleanup:
     delete dec;
 }
 
 // known issues:
 //  - permutes rfc2231 continuations when the total number of parts
 //    exceeds 10 (other-sections then becomes *xy, ie. two digits)
 
 bool parseParameterListWithCharset(const char *&scursor,
                                    const char *const send,
                                    QMap<QString, QString> &result,
                                    QByteArray &charset, bool isCRLF)
 {
 // parse the list into raw attribute-value pairs:
     QMap<QString, QStringOrQPair> rawParameterList;
     if (!parseRawParameterList(scursor, send, rawParameterList, isCRLF)) {
         return false;
     }
 
     if (rawParameterList.isEmpty()) {
         return true;
     }
 
     // decode rfc 2231 continuations and alternate charset encoding:
 
     // NOTE: this code assumes that what QMapIterator delivers is sorted
     // by the key!
 
     KCodecs::Codec *rfc2231Codec = nullptr;
     QStringDecoder textcodec;
     QString attribute;
     QString value;
     enum Mode {
         NoMode = 0x0, Continued = 0x1, Encoded = 0x2
     };
 
     enum EncodingMode {
         NoEncoding,
         RFC2047,
         RFC2231
     };
 
     QMap<QString, QStringOrQPair>::Iterator it;
     QMap<QString, QStringOrQPair>::Iterator end = rawParameterList.end();
 
     for (it = rawParameterList.begin() ; it != end ; ++it) {
         if (attribute.isNull() || !it.key().startsWith(attribute)) {
             //
             // new attribute:
             //
 
             // store the last attribute/value pair in the result map now:
             if (!attribute.isNull()) {
                 result.insert(attribute, value);
             }
             // and extract the information from the new raw attribute:
             value.clear();
             attribute = it.key();
             int mode = NoMode;
             EncodingMode encodingMode = NoEncoding;
 
             // is the value rfc2331-encoded?
             if (attribute.endsWith(QLatin1Char('*'))) {
                 attribute.chop(1);
                 mode |= Encoded;
                 encodingMode = RFC2231;
             }
             // is the value rfc2047-encoded?
             if (!(*it).qstring.isNull() && (*it).qstring.contains(QLatin1String("=?"))) {
                 mode |= Encoded;
                 encodingMode = RFC2047;
             }
             // is the value continued?
             if (attribute.endsWith(QLatin1String("*0"))) {
                 attribute.chop(2);
                 mode |= Continued;
             }
             //
             // decode if necessary:
             //
             if (mode & Encoded) {
                 if (encodingMode == RFC2231) {
                     decodeRFC2231Value(rfc2231Codec, textcodec,
                                        false, /* isn't continuation */
                                        value, (*it).qpair, charset);
                 } else if (encodingMode == RFC2047) {
                     value += KCodecs::decodeRFC2047String((*it).qstring.toLatin1(), &charset);
                 }
             } else {
                 // not encoded.
                 if ((*it).qpair.first) {
                     value += QString::fromLatin1((*it).qpair.first, (*it).qpair.second);
                 } else {
                     value += (*it).qstring;
                 }
             }
 
             //
             // shortcut-processing when the value isn't encoded:
             //
 
             if (!(mode & Continued)) {
                 // save result already:
                 result.insert(attribute, value);
                 // force begin of a new attribute:
                 attribute.clear();
             }
         } else { // it.key().startsWith( attribute )
             //
             // continuation
             //
 
             // ignore the section and trust QMap to have sorted the keys:
             if (it.key().endsWith(QLatin1Char('*'))) {
                 // encoded
                 decodeRFC2231Value(rfc2231Codec, textcodec,
                                    true, /* is continuation */
                                    value, (*it).qpair, charset);
             } else {
                 // not encoded
                 if ((*it).qpair.first) {
                     value += QString::fromLatin1((*it).qpair.first, (*it).qpair.second);
                 } else {
                     value += (*it).qstring;
                 }
             }
         }
     }
     // write last attr/value pair:
     if (!attribute.isNull()) {
         result.insert(attribute, value);
     }
 
     return true;
 }
 
 bool parseParameterList(const char *&scursor, const char *const send,
                         QMap<QString, QString> &result, bool isCRLF)
 {
     QByteArray charset;
     return parseParameterListWithCharset(scursor, send, result, charset, isCRLF);
 }
 
 static const char stdDayNames[][4] = {
     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 };
 static const int stdDayNamesLen = sizeof stdDayNames / sizeof *stdDayNames;
 
 static bool parseDayName(const char *&scursor, const char *const send)
 {
     // check bounds:
     if (send - scursor < 3) {
         return false;
     }
 
     for (int i = 0 ; i < stdDayNamesLen ; ++i) {
         if (qstrnicmp(scursor, stdDayNames[i], 3) == 0) {
             scursor += 3;
             // qCDebug(KMIME_LOG) << "found" << stdDayNames[i];
             return true;
         }
     }
 
     return false;
 }
 
 static const char stdMonthNames[][4] = {
     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 };
 static const int stdMonthNamesLen =
     sizeof stdMonthNames / sizeof *stdMonthNames;
 
 static bool parseMonthName(const char *&scursor, const char *const send,
                            int &result)
 {
     // check bounds:
     if (send - scursor < 3) {
         return false;
     }
 
     for (result = 0 ; result < stdMonthNamesLen ; ++result) {
         if (qstrnicmp(scursor, stdMonthNames[result], 3) == 0) {
             scursor += 3;
             return true;
         }
     }
 
     // not found:
     return false;
 }
 
 static const struct {
     const char tzName[5];
     long int secsEastOfGMT;
 } timeZones[] = {
     // rfc 822 timezones:
     { "GMT", 0 },
     { "UT", 0 },
     { "EDT", -4 * 3600 },
     { "EST", -5 * 3600 },
     { "MST", -5 * 3600 },
     { "CST", -6 * 3600 },
     { "MDT", -6 * 3600 },
     { "MST", -7 * 3600 },
     { "PDT", -7 * 3600 },
     { "PST", -8 * 3600 },
     // common, non-rfc-822 zones:
     { "CET", 1 * 3600 },
     { "MET", 1 * 3600 },
     { "UTC", 0 },
     { "CEST", 2 * 3600 },
     { "BST", 1 * 3600 },
     // rfc 822 military timezones:
     { "Z", 0 },
     { "A", -1 * 3600 },
     { "B", -2 * 3600 },
     { "C", -3 * 3600 },
     { "D", -4 * 3600 },
     { "E", -5 * 3600 },
     { "F", -6 * 3600 },
     { "G", -7 * 3600 },
     { "H", -8 * 3600 },
     { "I", -9 * 3600 },
     // J is not used!
     { "K", -10 * 3600 },
     { "L", -11 * 3600 },
     { "M", -12 * 3600 },
     { "N", 1 * 3600 },
     { "O", 2 * 3600 },
     { "P", 3 * 3600 },
     { "Q", 4 * 3600 },
     { "R", 5 * 3600 },
     { "S", 6 * 3600 },
     { "T", 7 * 3600 },
     { "U", 8 * 3600 },
     { "V", 9 * 3600 },
     { "W", 10 * 3600 },
     { "X", 11 * 3600 },
     { "Y", 12 * 3600 },
 };
 static const int timeZonesLen = sizeof timeZones / sizeof *timeZones;
 
 static bool parseAlphaNumericTimeZone(const char *&scursor,
                                       const char *const send,
                                       long int &secsEastOfGMT,
                                       bool &timeZoneKnown)
 {
     // allow the timezone to be wrapped in quotes; bug 260761
     if (scursor < send && *scursor == '"') {
         scursor++;
 
         if (scursor == send) {
             return false;
         }
     }
 
     QPair<const char *, int> maybeTimeZone(nullptr, 0);
     if (!parseToken(scursor, send, maybeTimeZone, ParseTokenNoFlag)) {
         return false;
     }
     for (int i = 0 ; i < timeZonesLen ; ++i) {
         if (qstrnicmp(timeZones[i].tzName,
                       maybeTimeZone.first, maybeTimeZone.second) == 0) {
             scursor += maybeTimeZone.second;
             secsEastOfGMT = timeZones[i].secsEastOfGMT;
             timeZoneKnown = true;
 
             if (scursor < send && *scursor == '"') {
                 scursor++;
             }
 
             return true;
         }
     }
 
     // don't choke just because we don't happen to know the time zone
     KMIME_WARN_UNKNOWN(time zone,
                        QByteArray(maybeTimeZone.first, maybeTimeZone.second));
     secsEastOfGMT = 0;
     timeZoneKnown = false;
     return true;
 }
 
 // parse a number and return the number of digits parsed:
 int parseDigits(const char *&scursor, const char *const send, int &result)
 {
     result = 0;
     int digits = 0;
     for (; scursor != send && isdigit(*scursor) ; scursor++, digits++) {
         result *= 10;
         result += int(*scursor - '0');
     }
     return digits;
 }
 
 static bool parseTimeOfDay(const char *&scursor, const char *const send,
                            int &hour, int &min, int &sec, bool isCRLF = false)
 {
     // time-of-day := 2DIGIT [CFWS] ":" [CFWS] 2DIGIT [ [CFWS] ":" 2DIGIT ]
 
     //
     // 2DIGIT representing "hour":
     //
     if (!parseDigits(scursor, send, hour)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send || *scursor != ':') {
         return false;
     }
     scursor++; // eat ':'
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     //
     // 2DIGIT representing "minute":
     //
     if (!parseDigits(scursor, send, min)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return true; // seconds are optional
     }
 
     //
     // let's see if we have a 2DIGIT representing "second":
     //
     if (*scursor == ':') {
         // yepp, there are seconds:
         scursor++; // eat ':'
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
 
         if (!parseDigits(scursor, send, sec)) {
             return false;
         }
     } else {
         sec = 0;
     }
 
     return true;
 }
 
 bool parseTime(const char *&scursor, const char *send,
                int &hour, int &min, int &sec, long int &secsEastOfGMT,
                bool &timeZoneKnown, bool isCRLF)
 {
     // time := time-of-day CFWS ( zone / obs-zone )
     //
     // obs-zone    := "UT" / "GMT" /
     //                "EST" / "EDT" / ; -0500 / -0400
     //                "CST" / "CDT" / ; -0600 / -0500
     //                "MST" / "MDT" / ; -0700 / -0600
     //                "PST" / "PDT" / ; -0800 / -0700
     //                "A"-"I" / "a"-"i" /
     //                "K"-"Z" / "k"-"z"
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     if (!parseTimeOfDay(scursor, send, hour, min, sec, isCRLF)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     // there might be no timezone but a year following
     if ((scursor == send) || isdigit(*scursor)) {
         timeZoneKnown = false;
         secsEastOfGMT = 0;
         return true; // allow missing timezone
     }
 
     timeZoneKnown = true;
     if (*scursor == '+' || *scursor == '-') {
         // remember and eat '-'/'+':
         const char sign = *scursor++;
         // numerical timezone:
         int maybeTimeZone;
         const int tzDigits = parseDigits(scursor, send, maybeTimeZone);
         if (tzDigits != 4) {
             // Allow timezones in 02:00 format
             if (tzDigits == 2 && scursor != send && *scursor == ':') {
                 scursor++;
                 int maybeTimeZone2;
                 if (parseDigits(scursor, send, maybeTimeZone2) != 2) {
                     return false;
                 }
                 maybeTimeZone = maybeTimeZone * 100 + maybeTimeZone2;
             } else {
                 return false;
             }
         }
         secsEastOfGMT = 60 * (maybeTimeZone / 100 * 60 + maybeTimeZone % 100);
         if (sign == '-') {
             secsEastOfGMT *= -1;
             if (secsEastOfGMT == 0) {
                 timeZoneKnown = false; // -0000 means indetermined tz
             }
         }
     } else {
         // maybe alphanumeric timezone:
         if (!parseAlphaNumericTimeZone(scursor, send, secsEastOfGMT, timeZoneKnown)) {
             return false;
         }
     }
     return true;
 }
 
 bool parseQDateTime(const char *&scursor, const char *const send,
                    QDateTime &result, bool isCRLF)
 {
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
     // In qt6 yy == 1900 ! => for sure we use 2000 here.
     result = QDateTime::fromString(QString::fromLatin1(scursor, 17), QStringLiteral("dd/MM/yy HH:mm:ss"));
     QDate resultDate = result.date();
     resultDate.setDate(resultDate.year() + 100, resultDate.month(), resultDate.day());
     result.setDate(resultDate);
     return result.isValid();
 }
 
 bool parseDateTime(const char *&scursor, const char *const send,
                    QDateTime &result, bool isCRLF)
 {
     // Parsing date-time; strict mode:
     //
     // date-time   := [ [CFWS] day-name [CFWS] "," ]                      ; wday
     // (expanded)     [CFWS] 1*2DIGIT CFWS month-name CFWS 2*DIGIT [CFWS] ; date
     //                time
     //
     // day-name    := "Mon" / "Tue" / "Wed" / "Thu" / "Fri" / "Sat" / "Sun"
     // month-name  := "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
     //                "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
 
     result = QDateTime();
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     //
     // let's see if there's a day-of-week:
     //
     if (parseDayName(scursor, send)) {
         eatCFWS(scursor, send, isCRLF);
         if (scursor == send) {
             return false;
         }
         // day-name should be followed by ',' but we treat it as optional:
         if (*scursor == ',') {
             scursor++; // eat ','
             eatCFWS(scursor, send, isCRLF);
         }
     }
 
     int maybeMonth = -1;
     bool asctimeFormat = false;
 
     // ANSI-C asctime() format is: Wed Jun 30 21:49:08 1993
     if (!isdigit(*scursor) && parseMonthName(scursor, send, maybeMonth)) {
         asctimeFormat = true;
         eatCFWS(scursor, send, isCRLF);
     }
 
     //
     // 1*2DIGIT representing "day" (of month):
     //
     int maybeDay;
     if (!parseDigits(scursor, send, maybeDay)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     // ignore ","; bug 54098
     if (*scursor == ',') {
         scursor++;
     }
 
     //
     // month-name:
     //
     if (!asctimeFormat && !parseMonthName(scursor, send, maybeMonth)) {
         return false;
     }
     if (scursor == send) {
         return false;
     }
     assert(maybeMonth >= 0); assert(maybeMonth <= 11);
     ++maybeMonth; // 0-11 -> 1-12
 
     eatCFWS(scursor, send, isCRLF);
     if (scursor == send) {
         return false;
     }
 
     // check for "year HH:MM:SS" or only "HH:MM:SS" (or "H:MM:SS")
     bool timeAfterYear = true;
     if ((send - scursor > 3) && ((scursor[1] == ':') || (scursor[2] == ':'))) {
         timeAfterYear = false;  // first read time, then year
     }
 
     //
     // 2*DIGIT representing "year":
     //
     int maybeYear = 0;
 
     if (timeAfterYear && !parseDigits(scursor, send, maybeYear)) {
         return false;
     }
 
     eatCFWS(scursor, send, isCRLF);
     int maybeHour;
     int maybeMinute;
     int maybeSecond;
     long int secsEastOfGMT = 0;
     QDate maybeDate;
     QTime maybeTime;
     if (scursor != send) {
         //
         // time
         //
         bool timeZoneKnown = true;
 
         if (!parseTime(scursor, send,
                        maybeHour, maybeMinute, maybeSecond,
                        secsEastOfGMT, timeZoneKnown, isCRLF)) {
             return false;
         }
 
         // in asctime() the year follows the time
         if (!timeAfterYear) {
             eatCFWS(scursor, send, isCRLF);
             if (scursor == send) {
                 return false;
             }
 
             if (!parseDigits(scursor, send, maybeYear)) {
                 return false;
             }
         }
 
         // RFC 2822 4.3 processing:
         if (maybeYear < 50) {
             maybeYear += 2000;
         } else if (maybeYear < 1000) {
             maybeYear += 1900;
         }
         // else keep as is
         if (maybeYear < 1900) {
             return false; // rfc2822, 3.3
         }
 
         maybeDate = QDate(maybeYear, maybeMonth, maybeDay);
         maybeTime = QTime(maybeHour, maybeMinute, maybeSecond);
 
         if (!maybeDate.isValid() || !maybeTime.isValid()) {
             return false;
         }
     } else {
         maybeDate = QDate(maybeYear, maybeMonth, maybeDay);
         maybeTime = QTime(0, 0, 0);
     }
 
     result = QDateTime(maybeDate, maybeTime, QTimeZone::fromSecondsAheadOfUtc(secsEastOfGMT));
     if (!result.isValid()) {
         return false;
     }
     return true;
 }
 
 namespace {
 
 Headers::Base *extractHeader(QByteArrayView head, const int headerStart, int &endOfFieldBody)
 {
     Headers::Base *header = {};
 
     int startOfFieldBody = head.indexOf(':', headerStart);
     if (startOfFieldBody < 0) {
         return nullptr;
     }
 
     const char *rawType = head.constData() + headerStart;
     const size_t rawTypeLen = startOfFieldBody - headerStart;
 
     startOfFieldBody++; //skip the ':'
     if (startOfFieldBody < head.size() - 1 &&  head[startOfFieldBody] == ' ') { // skip the space after the ':', if there's any
         startOfFieldBody++;
     }
 
     bool folded = false;
     endOfFieldBody = findHeaderLineEnd(head, startOfFieldBody, &folded);
 
     // We might get an invalid mail without a field name, don't crash on that.
     if (rawTypeLen > 0) {
         header = HeaderFactory::createHeader(rawType, rawTypeLen);
     }
     if (!header) {
         //qCWarning(KMIME_LOG)() << "Returning Generic header of type" << rawType;
         header = new Headers::Generic(rawType, rawTypeLen);
     }
     if (folded) {
         const auto unfoldedBody = unfoldHeader(head.constData() + startOfFieldBody, endOfFieldBody - startOfFieldBody);
         header->from7BitString(unfoldedBody);
     } else {
         header->from7BitString(head.constData() + startOfFieldBody, endOfFieldBody - startOfFieldBody);
     }
 
     return header;
 }
 
 }
 
 std::unique_ptr<KMime::Headers::Base> parseNextHeader(QByteArrayView &head)
 {
     int endOfFieldBody = 0;
     std::unique_ptr<KMime::Headers::Base> header(extractHeader(head, 0, endOfFieldBody));
     if (header) {
         head = head.mid(endOfFieldBody + 1);
     } else {
         head = {};
     }
 
     return header;
 }
 
 void extractHeaderAndBody(const QByteArray &content, QByteArray &header, QByteArray &body)
 {
     header.clear();
     body.clear();
 
     // empty header
     if (content.startsWith('\n')) {
         body = content.right(content.length() - 1);
         return;
     }
 
     int pos = content.indexOf("\n\n", 0);
     if (pos > -1) {
         header = content.left(++pos);    //header *must* end with "\n" !!
         body = content.mid(pos + 1);
         if (body.startsWith("\n")) {
             body = "\n" + body;
         }
     } else {
         header = content;
     }
 }
 
 QList<Headers::Base *> parseHeaders(const QByteArray &head) {
     QList<Headers::Base *> ret;
 
     int cursor = 0;
     while (cursor < head.size()) {
         const int headerStart = cursor;
         int endOfFieldBody;
         if (auto header = extractHeader(head, headerStart, endOfFieldBody)) {
             ret << header;
             cursor = endOfFieldBody + 1;
         } else {
             break;
         }
     }
 
     return ret;
 }
 
 } // namespace HeaderParsing
 
 } // namespace KMime