File indexing completed on 2024-09-29 06:30:33

 /*  -*- c++ -*-
     SPDX-FileCopyrightText: 2002 Marc Mutz <mutz@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 /**
   @file
   This file is part of the API for handling @ref MIME data and
   defines the @ref QuotedPrintable, @ref  RFC2047Q, and
   @ref RFC2231 @ref Codec classes.
 
   @brief
   Defines the classes QuotedPrintableCodec, Rfc2047QEncodingCodec, and
   Rfc2231EncodingCodec.
 
   @authors Marc Mutz \<mutz@kde.org\>
 */
 
 #include "kcodecsqp.h"
 #include "kcodecs_p.h"
 
 #include <QDebug>
 
 #include <cassert>
 
 using namespace KCodecs;
 
 namespace KCodecs
 {
 // none except a-zA-Z0-9!*+-/
 const uchar eTextMap[16] = {0x00, 0x00, 0x00, 0x00, 0x40, 0x35, 0xFF, 0xC0, 0x7F, 0xFF, 0xFF, 0xE0, 0x7F, 0xFF, 0xFF, 0xE0};
 
 // some helpful functions:
 
 /**
   Converts a 4-bit @p value into its hexadecimal characater representation.
   So input of value [0,15] returns ['0','1',... 'F'].  Input values
   greater than 15 will produce undesired results.
   @param value is an unsigned character containing the 4-bit input value.
 */
 static inline char binToHex(uchar value)
 {
     if (value > 9) {
         return value + 'A' - 10;
     } else {
         return value + '0';
     }
 }
 
 /**
   Returns the high-order 4 bits of an 8-bit value in another 8-bit value.
   @param ch is an unsigned character containing the 8-bit input value.
 */
 static inline uchar highNibble(uchar ch)
 {
     return ch >> 4;
 }
 
 /**
   Returns the low-order 4 bits of an 8-bit value in another 8-bit value.
   @param ch is an unsigned character containing the 8-bit input value.
 */
 static inline uchar lowNibble(uchar ch)
 {
     return ch & 0xF;
 }
 
 /**
   Returns true if the specified value is a not Control character or
   question mark; else true.
   @param ch is an unsigned character containing the 8-bit input value.
 */
 static inline bool keep(uchar ch)
 {
     // no CTLs, except HT and not '?'
     return !((ch < ' ' && ch != '\t') || ch == '?');
 }
 
 //
 // QuotedPrintableCodec
 //
 
 class QuotedPrintableEncoder : public Encoder
 {
     char mInputBuffer[16];
     uchar mCurrentLineLength; // 0..76
     uchar mAccu;
     uint mInputBufferReadCursor : 4; // 0..15
     uint mInputBufferWriteCursor : 4; // 0..15
     enum {
         Never,
         AtBOL,
         Definitely,
     } mAccuNeedsEncoding : 2;
     bool mSawLineEnd : 1;
     bool mSawCR : 1;
     bool mFinishing : 1;
     bool mFinished : 1;
 
 protected:
     friend class QuotedPrintableCodec;
     QuotedPrintableEncoder(Codec::NewlineType newline = Codec::NewlineLF)
         : Encoder(newline)
         , mCurrentLineLength(0)
         , mAccu(0)
         , mInputBufferReadCursor(0)
         , mInputBufferWriteCursor(0)
         , mAccuNeedsEncoding(Never)
         , mSawLineEnd(false)
         , mSawCR(false)
         , mFinishing(false)
         , mFinished(false)
     {
     }
 
     bool needsEncoding(uchar ch)
     {
         return ch > '~' || (ch < ' ' && ch != '\t') || ch == '=';
     }
     bool needsEncodingAtEOL(uchar ch)
     {
         return ch == ' ' || ch == '\t';
     }
     bool needsEncodingAtBOL(uchar ch)
     {
         return ch == 'F' || ch == '.' || ch == '-';
     }
     bool fillInputBuffer(const char *&scursor, const char *const send);
     bool processNextChar();
     void createOutputBuffer(char *&dcursor, const char *const dend);
 
 public:
     ~QuotedPrintableEncoder() override
     {
     }
 
     bool encode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend) override;
 
     bool finish(char *&dcursor, const char *const dend) override;
 };
 
 class QuotedPrintableDecoder : public Decoder
 {
     const char mEscapeChar;
     char mBadChar;
     /** @p accu holds the msb nibble of the hexchar or zero. */
     uchar mAccu;
     /** @p insideHexChar is true iff we're inside an hexchar (=XY).
         Together with @ref mAccu, we can build this states:
         @li @p insideHexChar == @p false:
         normal text
         @li @p insideHexChar == @p true, @p mAccu == 0:
         saw the leading '='
         @li @p insideHexChar == @p true, @p mAccu != 0:
         saw the first nibble '=X'
     */
     const bool mQEncoding;
     bool mInsideHexChar;
     bool mFlushing;
     bool mExpectLF;
     bool mHaveAccu;
     /** @p mLastChar holds the first char of an encoded char, so that
         we are able to keep the first char if the second char is invalid. */
     char mLastChar;
 
 protected:
     friend class QuotedPrintableCodec;
     friend class Rfc2047QEncodingCodec;
     friend class Rfc2231EncodingCodec;
     QuotedPrintableDecoder(Codec::NewlineType newline = Codec::NewlineLF, bool aQEncoding = false, char aEscapeChar = '=')
         : Decoder(newline)
         , mEscapeChar(aEscapeChar)
         , mBadChar(0)
         , mAccu(0)
         , mQEncoding(aQEncoding)
         , mInsideHexChar(false)
         , mFlushing(false)
         , mExpectLF(false)
         , mHaveAccu(false)
         , mLastChar(0)
     {
     }
 
 public:
     ~QuotedPrintableDecoder() override
     {
     }
 
     bool decode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend) override;
     bool finish(char *&dcursor, const char *const dend) override;
 };
 
 class Rfc2047QEncodingEncoder : public Encoder
 {
     uchar mAccu;
     uchar mStepNo;
     const char mEscapeChar;
     bool mInsideFinishing : 1;
 
 protected:
     friend class Rfc2047QEncodingCodec;
     friend class Rfc2231EncodingCodec;
     Rfc2047QEncodingEncoder(Codec::NewlineType newline = Codec::NewlineLF, char aEscapeChar = '=')
         : Encoder(newline)
         , mAccu(0)
         , mStepNo(0)
         , mEscapeChar(aEscapeChar)
         , mInsideFinishing(false)
     {
         // else an optimization in ::encode might break.
         assert(aEscapeChar == '=' || aEscapeChar == '%');
     }
 
     bool isEText(uchar ch)
     {
         return (ch < 128) && (eTextMap[ch / 8] & 0x80 >> ch % 8);
     }
 
     // this code assumes that isEText( mEscapeChar ) == false!
     bool needsEncoding(uchar ch)
     {
         if (ch > 'z') {
             return true; // {|}~ DEL and 8bit chars need
         }
         if (!isEText(ch)) {
             return true; // all but a-zA-Z0-9!/*+- need, too
         }
         if (mEscapeChar == '%' && (ch == '*' || ch == '/')) {
             return true; // not allowed in rfc2231 encoding
         }
         return false;
     }
 
 public:
     ~Rfc2047QEncodingEncoder() override
     {
     }
 
     bool encode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend) override;
     bool finish(char *&dcursor, const char *const dend) override;
 };
 
 // this doesn't access any member variables, so it can be defined static
 // but then we can't call it from virtual functions
 static qsizetype QuotedPrintableDecoder_maxDecodedSizeFor(qsizetype insize, Codec::NewlineType newline)
 {
     // all chars unencoded:
     qsizetype result = insize;
     // but maybe all of them are \n and we need to make them \r\n :-o
     if (newline == Codec::NewlineCRLF) {
         result += insize;
     }
 
     // there might be an accu plus escape
     result += 2;
 
     return result;
 }
 
 Encoder *QuotedPrintableCodec::makeEncoder(Codec::NewlineType newline) const
 {
     return new QuotedPrintableEncoder(newline);
 }
 
 Decoder *QuotedPrintableCodec::makeDecoder(Codec::NewlineType newline) const
 {
     return new QuotedPrintableDecoder(newline);
 }
 
 qsizetype QuotedPrintableCodec::maxDecodedSizeFor(qsizetype insize, Codec::NewlineType newline) const
 {
     return QuotedPrintableDecoder_maxDecodedSizeFor(insize, newline);
 }
 
 Encoder *Rfc2047QEncodingCodec::makeEncoder(Codec::NewlineType newline) const
 {
     return new Rfc2047QEncodingEncoder(newline);
 }
 
 Decoder *Rfc2047QEncodingCodec::makeDecoder(Codec::NewlineType newline) const
 {
     return new QuotedPrintableDecoder(newline, true);
 }
 
 qsizetype Rfc2047QEncodingCodec::maxDecodedSizeFor(qsizetype insize, Codec::NewlineType newline) const
 {
     return QuotedPrintableDecoder_maxDecodedSizeFor(insize, newline);
 }
 
 Encoder *Rfc2231EncodingCodec::makeEncoder(Codec::NewlineType newline) const
 {
     return new Rfc2047QEncodingEncoder(newline, '%');
 }
 
 Decoder *Rfc2231EncodingCodec::makeDecoder(Codec::NewlineType newline) const
 {
     return new QuotedPrintableDecoder(newline, true, '%');
 }
 
 qsizetype Rfc2231EncodingCodec::maxDecodedSizeFor(qsizetype insize, Codec::NewlineType newline) const
 {
     return QuotedPrintableDecoder_maxDecodedSizeFor(insize, newline);
 }
 
 /********************************************************/
 /********************************************************/
 /********************************************************/
 
 bool QuotedPrintableDecoder::decode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend)
 {
     if (d->newline == Codec::NewlineCRLF) {
         qWarning() << "CRLF output for decoders isn't yet supported!";
     }
 
     while (scursor != send && dcursor != dend) {
         if (mFlushing) {
             // we have to flush chars in the aftermath of a decoding
             // error. The way to request a flush is to
             // - store the offending character in mBadChar and
             // - set mFlushing to true.
             // The supported cases are (H: hexchar, X: bad char):
             // =X, =HX, CR
             // mBadChar is only written out if it is not by itself illegal in
             // quoted-printable (e.g. CTLs, 8Bits).
             // A fast way to suppress mBadChar output is to set it to NUL.
             if (mInsideHexChar) {
                 // output '='
                 *dcursor++ = mEscapeChar;
                 mInsideHexChar = false;
             } else if (mHaveAccu) {
                 // output the high nibble of the accumulator:
                 *dcursor++ = mLastChar;
                 mHaveAccu = false;
                 mAccu = 0;
             } else {
                 // output mBadChar
                 assert(mAccu == 0);
                 if (mBadChar) {
                     if (mBadChar == '=') {
                         mInsideHexChar = true;
                     } else {
                         *dcursor++ = mBadChar;
                     }
                     mBadChar = 0;
                 }
                 mFlushing = false;
             }
             continue;
         }
         assert(mBadChar == 0);
 
         uchar ch = *scursor++;
 
         if (mExpectLF && ch != '\n') {
             // qWarning() << "QuotedPrintableDecoder:"
             //              "illegally formed soft linebreak or lonely CR!";
             mInsideHexChar = false;
             mExpectLF = false;
             if (mAccu != 0) {
                 return false;
             }
         }
 
         if (mInsideHexChar) {
             uchar value = 255;
             // next char(s) represent nibble instead of itself:
             if (ch <= '9') {
                 if (ch >= '0') {
                     value = ch - '0';
                 } else {
                     switch (ch) {
                     case '\r':
                         mExpectLF = true;
                         break;
                     case '\n':
                         // soft line break, but only if mAccu is NUL.
                         if (!mHaveAccu) {
                             mExpectLF = false;
                             mInsideHexChar = false;
                             break;
                         }
                     // else fall through
                     default:
                         // qWarning() << "QuotedPrintableDecoder:"
                         //              "illegally formed hex char! Outputting verbatim.";
                         mBadChar = ch;
                         mFlushing = true;
                     }
                     continue;
                 }
             } else { // ch > '9'
                 if (ch <= 'F') {
                     if (ch >= 'A') {
                         value = 10 + ch - 'A';
                     } else { // [:-@]
                         mBadChar = ch;
                         mFlushing = true;
                         continue;
                     }
                 } else { // ch > 'F'
                     if (ch <= 'f' && ch >= 'a') {
                         value = 10 + ch - 'a';
                     } else {
                         mBadChar = ch;
                         mFlushing = true;
                         continue;
                     }
                 }
             }
 
             assert(value < 16);
             assert(mBadChar == 0);
             assert(!mExpectLF);
 
             if (mHaveAccu) {
                 *dcursor++ = char(mAccu | value);
                 mAccu = 0;
                 mHaveAccu = false;
                 mInsideHexChar = false;
             } else {
                 mHaveAccu = true;
                 mAccu = value << 4;
                 mLastChar = ch;
             }
         } else { // not mInsideHexChar
             if ((ch <= '~' && ch >= ' ') || ch == '\t') {
                 if (ch == mEscapeChar) {
                     mInsideHexChar = true;
                 } else if (mQEncoding && ch == '_') {
                     *dcursor++ = char(0x20);
                 } else {
                     *dcursor++ = char(ch);
                 }
             } else if (ch == '\n') {
                 *dcursor++ = '\n';
                 mExpectLF = false;
             } else if (ch == '\r') {
                 mExpectLF = true;
             } else {
                 // qWarning() << "QuotedPrintableDecoder:" << ch <<
                 //  "illegal character in input stream!";
                 *dcursor++ = char(ch);
             }
         }
     }
 
     return scursor == send;
 }
 
 bool QuotedPrintableDecoder::finish(char *&dcursor, const char *const dend)
 {
     while ((mInsideHexChar || mHaveAccu || mFlushing) && dcursor != dend) {
         // we have to flush chars
         if (mInsideHexChar) {
             // output '='
             *dcursor++ = mEscapeChar;
             mInsideHexChar = false;
         } else if (mHaveAccu) {
             // output the high nibble of the accumulator:
             *dcursor++ = mLastChar;
             mHaveAccu = false;
             mAccu = 0;
         } else {
             // output mBadChar
             assert(mAccu == 0);
             if (mBadChar) {
                 *dcursor++ = mBadChar;
                 mBadChar = 0;
             }
             mFlushing = false;
         }
     }
 
     // return false if we are not finished yet; note that mInsideHexChar is always false
     return !(mHaveAccu || mFlushing);
 }
 
 bool QuotedPrintableEncoder::fillInputBuffer(const char *&scursor, const char *const send)
 {
     // Don't read more if there's still a tail of a line in the buffer:
     if (mSawLineEnd) {
         return true;
     }
 
     // Read until the buffer is full or we have found CRLF or LF (which
     // don't end up in the input buffer):
     for (; (mInputBufferWriteCursor + 1) % 16 != mInputBufferReadCursor && scursor != send; mInputBufferWriteCursor++) {
         char ch = *scursor++;
         if (ch == '\r') {
             mSawCR = true;
         } else if (ch == '\n') {
             // remove the CR from the input buffer (if any) and return that
             // we found a line ending:
             if (mSawCR) {
                 mSawCR = false;
                 assert(mInputBufferWriteCursor != mInputBufferReadCursor);
                 mInputBufferWriteCursor--;
             }
             mSawLineEnd = true;
             return true; // saw CRLF or LF
         } else {
             mSawCR = false;
         }
         mInputBuffer[mInputBufferWriteCursor] = ch;
     }
     mSawLineEnd = false;
     return false; // didn't see a line ending...
 }
 
 bool QuotedPrintableEncoder::processNextChar()
 {
     // If we process a buffer which doesn't end in a line break, we
     // can't process all of it, since the next chars that will be read
     // could be a line break. So we empty the buffer only until a fixed
     // number of chars is left (except when mFinishing, which means that
     // the data doesn't end in newline):
     const int minBufferFillWithoutLineEnd = 4;
 
     assert(d->outputBufferCursor == 0);
 
     int bufferFill = int(mInputBufferWriteCursor) - int(mInputBufferReadCursor);
     if (bufferFill < 0) {
         bufferFill += 16;
     }
 
     assert(bufferFill >= 0 && bufferFill <= 15);
 
     if (!mFinishing //
         && !mSawLineEnd //
         && bufferFill < minBufferFillWithoutLineEnd) {
         return false;
     }
 
     // buffer is empty, return false:
     if (mInputBufferReadCursor == mInputBufferWriteCursor) {
         return false;
     }
 
     // Real processing goes here:
     mAccu = mInputBuffer[mInputBufferReadCursor++];
     if (needsEncoding(mAccu)) { // always needs encoding or
         mAccuNeedsEncoding = Definitely;
     } else if ((mSawLineEnd || mFinishing) // needs encoding at end of line
                && bufferFill == 1 // or end of buffer
                && needsEncodingAtEOL(mAccu)) {
         mAccuNeedsEncoding = Definitely;
     } else if (needsEncodingAtBOL(mAccu)) {
         mAccuNeedsEncoding = AtBOL;
     } else {
         // never needs encoding
         mAccuNeedsEncoding = Never;
     }
 
     return true;
 }
 
 // Outputs processed (verbatim or hex-encoded) chars and inserts soft
 // line breaks as necessary. Depends on processNextChar's directions
 // on whether to encode the current char, and whether
 // the current char is the last one in it's input line:
 void QuotedPrintableEncoder::createOutputBuffer(char *&dcursor, const char *const dend)
 {
     const int maxLineLength = 76; // rfc 2045
 
     assert(d->outputBufferCursor == 0);
 
     /* clang-format off */
     bool lastOneOnThisLine = mSawLineEnd
                              && mInputBufferReadCursor == mInputBufferWriteCursor;
     /* clang-format on */
 
     int neededSpace = 1;
     if (mAccuNeedsEncoding == Definitely) {
         neededSpace = 3;
     }
 
     // reserve space for the soft hyphen (=)
     if (!lastOneOnThisLine) {
         neededSpace++;
     }
 
     if (mCurrentLineLength > maxLineLength - neededSpace) {
         // current line too short, insert soft line break:
         write('=', dcursor, dend);
         writeCRLF(dcursor, dend);
         mCurrentLineLength = 0;
     }
 
     if (Never == mAccuNeedsEncoding //
         || (AtBOL == mAccuNeedsEncoding && mCurrentLineLength != 0)) {
         write(mAccu, dcursor, dend);
         mCurrentLineLength++;
     } else {
         write('=', dcursor, dend);
         write(binToHex(highNibble(mAccu)), dcursor, dend);
         write(binToHex(lowNibble(mAccu)), dcursor, dend);
         mCurrentLineLength += 3;
     }
 }
 
 bool QuotedPrintableEncoder::encode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend)
 {
     // support probing by the caller:
     if (mFinishing) {
         return true;
     }
 
     while (scursor != send && dcursor != dend) {
         if (d->outputBufferCursor && !flushOutputBuffer(dcursor, dend)) {
             return scursor == send;
         }
 
         assert(d->outputBufferCursor == 0);
 
         // fill input buffer until eol has been reached or until the
         // buffer is full, whatever comes first:
         fillInputBuffer(scursor, send);
 
         if (processNextChar()) {
             // there was one...
             createOutputBuffer(dcursor, dend);
         } else if (mSawLineEnd && mInputBufferWriteCursor == mInputBufferReadCursor) {
             // load a hard line break into output buffer:
             writeCRLF(dcursor, dend);
             // signal fillInputBuffer() we are ready for the next line:
             mSawLineEnd = false;
             mCurrentLineLength = 0;
         } else {
             // we are supposedly finished with this input block:
             break;
         }
     }
 
     // make sure we write as much as possible and don't stop _writing_
     // just because we have no more _input_:
     if (d->outputBufferCursor) {
         flushOutputBuffer(dcursor, dend);
     }
 
     return scursor == send;
 
 } // encode
 
 bool QuotedPrintableEncoder::finish(char *&dcursor, const char *const dend)
 {
     mFinishing = true;
 
     if (mFinished) {
         return flushOutputBuffer(dcursor, dend);
     }
 
     while (dcursor != dend) {
         if (d->outputBufferCursor && !flushOutputBuffer(dcursor, dend)) {
             return false;
         }
 
         assert(d->outputBufferCursor == 0);
 
         if (processNextChar()) {
             // there was one...
             createOutputBuffer(dcursor, dend);
         } else if (mSawLineEnd && mInputBufferWriteCursor == mInputBufferReadCursor) {
             // load a hard line break into output buffer:
             writeCRLF(dcursor, dend);
             mSawLineEnd = false;
             mCurrentLineLength = 0;
         } else {
             mFinished = true;
             return flushOutputBuffer(dcursor, dend);
         }
     }
 
     return mFinished && !d->outputBufferCursor;
 
 } // finish
 
 bool Rfc2047QEncodingEncoder::encode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend)
 {
     if (mInsideFinishing) {
         return true;
     }
 
     while (scursor != send && dcursor != dend) {
         uchar value = 0;
         switch (mStepNo) {
         case 0:
             // read the next char and decide if and how do encode:
             mAccu = *scursor++;
             if (!needsEncoding(mAccu)) {
                 *dcursor++ = char(mAccu);
             } else if (mEscapeChar == '=' && mAccu == 0x20) {
                 // shortcut encoding for 0x20 (latin-1/us-ascii SPACE)
                 // (not for rfc2231 encoding)
                 *dcursor++ = '_';
             } else {
                 // needs =XY encoding - write escape char:
                 *dcursor++ = mEscapeChar;
                 mStepNo = 1;
             }
             continue;
         case 1:
             // extract hi-nibble:
             value = highNibble(mAccu);
             mStepNo = 2;
             break;
         case 2:
             // extract lo-nibble:
             value = lowNibble(mAccu);
             mStepNo = 0;
             break;
         default:
             assert(0);
         }
 
         // and write:
         *dcursor++ = binToHex(value);
     }
 
     return scursor == send;
 } // encode
 
 bool Rfc2047QEncodingEncoder::finish(char *&dcursor, const char *const dend)
 {
     mInsideFinishing = true;
 
     // write the last bits of mAccu, if any:
     while (mStepNo != 0 && dcursor != dend) {
         uchar value = 0;
         switch (mStepNo) {
         case 1:
             // extract hi-nibble:
             value = highNibble(mAccu);
             mStepNo = 2;
             break;
         case 2:
             // extract lo-nibble:
             value = lowNibble(mAccu);
             mStepNo = 0;
             break;
         default:
             assert(0);
         }
 
         // and write:
         *dcursor++ = binToHex(value);
     }
 
     return mStepNo == 0;
 }
 
 } // namespace KCodecs