/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qmailcodec.h"

#include "qmaillog.h"

#include <QIODevice>

#include <QTextCodec>

#include <QtDebug>

#include <ctype.h>

// Allow these values to be reduced from test harness code:

int QTOPIAMAIL_EXPORT MaxCharacters = QMailCodec::ChunkCharacters;

// Must be an even multiple of 4:

int QTOPIAMAIL_EXPORT Base64MaxLineLength = 76;

// Can be any number:

int QTOPIAMAIL_EXPORT QuotedPrintableMaxLineLength = 74;

/*!

  \class QMailCodec

  \brief The QMailCodec class provides mechanisms for encoding and decoding between 7-bit ASCII strings

  and arbitrary octet sequences.

  \ingroup messaginglibrary

  Messages transferred via the SMTP protocol must be encoded in 7-bit ASCII characters, even though

  their contents are typically composed in sequences of 8-bit octets.  The QMailCodec class provides

  an interface through which data can be easily converted between an 8-bit octet sequence and

  a 7-bit ASCII character sequence.

  QMailCodec is an abstract class; in order to perform a coding operation, a derived class

  must be used that provides a policy for mapping 8-bit data to and from 7-bit ASCII characters.

  This policy is implemented by overriding the encodeChunk() and decodeChunk() virtual functions.

  Using the QMailCodec interface, data can be encoded or decoded from an input QDataStream to an 

  output QDataStream, or for convenience, from an input QByteArray to an output QByteArray.

  If the data to be encoded is in unicode form, then the QMailCodec interface can be used to

  convert the data to ASCII via an intermediate QTextCodec, which converts the incoming text

  to a sequence of octets.  The QTextCodec used is specified by the name of the encoding

  produced, or that decoded when decoding an ASCII input sequence.  QMailCodec provides functions 

  to encode from a QTextStream to a QDataStream, and to decode from a QDataStream to a QTextStream.

  For convenience, it is also possible to encode a QString to a QByteArray, and to decode a 

  QByteArray to a QString.

  \sa QDataStream, QTextStream, QTextCodec

*/

/*!

    \fn void QMailCodec::encodeChunk(QDataStream& out, const unsigned char* input, int length, bool finalChunk)

    Overridden by derived classes to perform an encoding operation.  The implementation function

    must encode \a length 8-bit octets at the location \a input, writing the resulting ASCII characters 

    to the stream \a out.  If \a finalChunk is false, further calls will be made to encodeChunk()

    with continued input data.  Otherwise, the encoding operation is complete.

*/

/*!

    \fn void QMailCodec::decodeChunk(QDataStream& out, const char* input, int length, bool finalChunk)

    Overridden by derived classes to perform a decoding operation.  The implementation function

    must decode \a length ASCII characters at the location \a input, writing the resulting octets

    to the stream \a out.  If \a finalChunk is false, further calls will be made to decodeChunk()

    with continued input data.  Otherwise, the decoding operation is complete.

*/

/*!

    Destroys a QMailCodec instance.

*/

QMailCodec::~QMailCodec()

{

}

/*!

    \fn QMailCodec::name() const

    Returns a string that identifies the subclass of QMailCodec that this instance belongs to.

*/

static void enumerateCodecs()

{

    static bool enumerated = false;

    if (!enumerated)

    {

        qWarning() << "Available codecs:";

        foreach (const QByteArray& codec, QTextCodec::availableCodecs())

            qWarning() << "  " << codec;

        enumerated = true;

    }

}

static QTextCodec* codecForName(const QByteArray& charset, bool translateAscii = true)

{

    QByteArray encoding(charset.toLower());

    if (!encoding.isEmpty())

    {

        int index;

        if (translateAscii && encoding.contains("ascii")) 

        {

            // We'll assume the text is plain ASCII, to be extracted to Latin-1

            encoding = "ISO-8859-1";

        }

        else if ((index = encoding.indexOf('*')) != -1)

        {

            // This charset specification includes a trailing language specifier

            encoding = encoding.left(index);

        }

        QTextCodec* codec = QTextCodec::codecForName(encoding);

        if (!codec)

        {

            qWarning() << "QMailCodec::codecForName - Unable to find codec for charset" << encoding;

            enumerateCodecs();

        }

        return codec;

    }

    return 0;

}

/*!

    Writes the data read from the stream \a in to the stream \a out, as a sequence 

    of 7-bit ASCII characters.  The unicode characters read from \a in are first 

    encoded to the text encoding \a charset.

    \sa QTextCodec::codecForName()

*/

void QMailCodec::encode(QDataStream& out, QTextStream& in, const QString& charset)

{

    if (QTextCodec* codec = codecForName(charset.toLatin1()))

    {

        while (!in.atEnd())

        {

            QString chunk = in.read(MaxCharacters);

            QByteArray charsetEncoded = codec->fromUnicode(chunk);

            encodeChunk(out, 

                        reinterpret_cast<const unsigned char*>(charsetEncoded.constData()), 

                        charsetEncoded.length(),

                        in.atEnd());

        }

    }

}

/*!

    Writes the data read from the stream \a in to the stream \a out, converting from 

    a sequence of 7-bit ASCII characters.  The characters read from \a in are 

    decoded from the text encoding \a charset to unicode.

    \sa QTextCodec::codecForName()

*/

void QMailCodec::decode(QTextStream& out, QDataStream& in, const QString& charset)

{

    if (QTextCodec* codec = codecForName(charset.toLatin1()))

    {

        QByteArray decoded;

        {

            QDataStream decodedStream(&decoded, QIODevice::WriteOnly);

            char* buffer = new char[MaxCharacters];

            while (!in.atEnd())

            {

                int length = in.readRawData(buffer, MaxCharacters);

                // Allow for decoded data to be twice the size without reallocation

                decoded.reserve(decoded.size() + (MaxCharacters * 2));

                decodeChunk(decodedStream, buffer, length, in.atEnd());

            }

            delete [] buffer;

        }

        // This is an unfortunately-necessary copy operation; we should investigate

        // modifying QTextCodec to support a stream interface

        QString unicode = codec->toUnicode(decoded);

        out << unicode;

        out.flush();

    }

}

/*!

    Writes the data read from the stream \a in to the stream \a out, as a sequence 

    of 7-bit ASCII characters.

*/

void QMailCodec::encode(QDataStream& out, QDataStream& in)

{

    char* buffer = new char[MaxCharacters];

    while (!in.atEnd())

    {

        int length = in.readRawData(buffer, MaxCharacters);

        encodeChunk(out, reinterpret_cast<unsigned char*>(buffer), length, in.atEnd());

    }

    delete [] buffer;

}

/*!

    Writes the data read from the stream \a in to the stream \a out, converting from 

    a sequence of 7-bit ASCII characters.

*/

void QMailCodec::decode(QDataStream& out, QDataStream& in)

{

    char* buffer = new char[MaxCharacters];

    while (!in.atEnd())

    {

        int length = in.readRawData(buffer, MaxCharacters);

        decodeChunk(out, buffer, length, in.atEnd());

    }

    delete [] buffer;

}

/*!

    Writes the data read from the stream \a in to the stream \a out, without conversion.

*/

void QMailCodec::copy(QDataStream& out, QDataStream& in)

{

    char* buffer = new char[MaxCharacters];

    while (!in.atEnd())

    {

        int length = in.readRawData(buffer, MaxCharacters);

        out.writeRawData(buffer, length);

    }

    delete [] buffer;

}

/*!

    Writes the data read from the stream \a in to the stream \a out, without conversion.

*/

void QMailCodec::copy(QTextStream& out, QTextStream& in)

{

    while (!in.atEnd())

    {

        QString input = in.read(MaxCharacters);

        out << input;

    }

}

/*!

    Returns a QByteArray containing the string \a input, encoded to the text encoding \a charset 

    and then to a sequence of 7-bit ASCII characters.

    \sa QTextCodec::codecForName()

*/

QByteArray QMailCodec::encode(const QString& input, const QString& charset)

{

    QByteArray result;

    {

        QDataStream out(&result, QIODevice::WriteOnly);

        // We can't currently guarantee that this is safe - we should investigate modifying

        // QTextStream to support a read-only interface...

        QTextStream in(const_cast<QString*>(&input), QIODevice::ReadOnly);

        encode(out, in, charset);

    }

    return result;

}

/*!

    Returns a QString containing characters decoded from the text encoding \a charset, which 

    are decoded from the sequence of 7-bit ASCII characters read from \a input. 

    \sa QTextCodec::codecForName()

*/

QString QMailCodec::decode(const QByteArray& input, const QString& charset)

{

    QString result;

    {

        QTextStream out(&result, QIODevice::WriteOnly);

        QDataStream in(input);

        decode(out, in, charset);

    }

    return result;

}

/*!

    Returns a QByteArray containing the octets from \a input, encoded to a sequence of 

    7-bit ASCII characters.

*/

QByteArray QMailCodec::encode(const QByteArray& input)

{

    QByteArray result;

    {

        QDataStream out(&result, QIODevice::WriteOnly);

        QDataStream in(input);

        encode(out, in);

    }

    return result;

}

/*!

    Returns a QByteArray containing the octets decoded from the sequence of 7-bit ASCII

    characters in \a input.

*/

QByteArray QMailCodec::decode(const QByteArray& input)

{

    QByteArray result;

    {

        QDataStream out(&result, QIODevice::WriteOnly);

        QDataStream in(input);

        decode(out, in);

    }

    return result;

}

// ASCII character values used throughout

const unsigned char MinPrintableRange = 0x20;

const unsigned char MaxPrintableRange = 0x7e;

const unsigned char HorizontalTab = 0x09;

const unsigned char LineFeed = 0x0a;

const unsigned char FormFeed = 0x0c;

const unsigned char CarriageReturn = 0x0d;

const unsigned char Space = 0x20;

const unsigned char Equals = 0x3d;

const unsigned char ExclamationMark = 0x21;

const unsigned char Asterisk = 0x2a;

const unsigned char Plus = 0x2b;

const unsigned char Minus = 0x2d;

const unsigned char Slash = 0x2f;

const unsigned char Underscore = 0x5f;

// Static data and functions for Base 64 codec

static const char Base64Characters[64 + 1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static const unsigned char* Base64Values = reinterpret_cast<const unsigned char*>(Base64Characters);

static const unsigned char Base64PaddingByte = 0x3d;

static inline unsigned char base64Index(const char ascii)

{

    if (ascii >= 'A' && ascii <= 'Z')

        return (ascii - 'A');

    if (ascii >= 'a' && ascii <= 'z')

        return (ascii - 'a') + 26;

    if (ascii >= '0' && ascii <= '9')

        return (ascii - '0') + 52;

    if (ascii == '+')

        return 62;

    if (ascii == '/')

        return 63;

    if (ascii == Base64PaddingByte)

        return 64;

    return 65;

}

/*!

  \class QMailBase64Codec

  \brief The QMailBase64Codec class encodes or decodes between 8-bit data and 7-bit ASCII, using the Base64

  character mapping scheme.

  \ingroup messaginglibrary

  The Base64 character mapping scheme maps arbitrary 8-bit values into a range of 64 printable 

  characters from the 7-bit ASCII set.  The mapping scheme used is defined in 

  \l{http://www.ietf.org/rfc/rfc2045.txt} {RFC 2045} (Multipurpose Internet Mail Extensions Part One). 

  This encoding is also defined as the '"B" encoding' for 'encoded words' in

  \l{http://www.ietf.org/rfc/rfc2047.txt} {RFC 2047} (Multipurpose Internet Mail Extensions Part Three). 

  The Base64 scheme encodes every incoming octet regardless of its original value, and thus 

  produces the same ratio of output length to input length for any input data sequence.  Since

  Base64 encodes four output characters for every three input octets, it produces a 33% 

  increase in stream size when encoding.

  An instance of QMailBase64Codec contains state information about the encoding or decoding

  operation it performs, so an instance should be used for a single coding operation only:

  \code

  QString textData = acquireInput();

  // Encode the string data to a UTF-8 byte sequence, and then encode to Base64

  QMailBase64Codec encoder;

  QByteArray base64Data = encoder.encode(textData, "UTF-8");

  \endcode

  \sa QMailCodec

*/

/*!

    \enum QMailBase64Codec::ContentType

    This enumerated type is used to specify whether content is textual data or binary data. 

    \value Text     The data is textual data; newline sequences within the data will be converted during coding.

    \value Binary   The data is not textual, and does not contain newline sequences.

*/

/*!

    Constructs a codec object for coding to or from Base64 encoding.

    If \a content is QMailBase64Codec::Text, then newline sequences will be converted

    between the local representation (for example, 0x0A on Unix) and the transmission standard

    representation (0x0D 0x0A). Otherwise, the data will be coded without modification.

    The maximum number of encoded characters per output line can be specified as \a maximumLineLength.  

    If not specified, or specified to a non-positive value, a default value will be used.

*/

QMailBase64Codec::QMailBase64Codec(ContentType content, int maximumLineLength)

    : _content(content),

      _maximumLineLength(maximumLineLength),

      _lastChar(0)

{

    // Our buffer output iterators - initially at start of buffer

    _encodeBufferOut = _encodeBuffer;

    _decodeBufferOut = _decodeBuffer;

    // Each encoded line will contain 76 output chars - 57 input chars

    if (_maximumLineLength <= 0)

        _maximumLineLength = Base64MaxLineLength;

    _encodeLineCharsRemaining = (_maximumLineLength / 4 * 3);

    // Count the number of padding characters encountered during decode

    _decodePaddingCount = 0;

}

/*! \reimp */

QString QMailBase64Codec::name() const

{

    return "QMailBase64Codec";

}

/*! \internal */

void QMailBase64Codec::encodeChunk(QDataStream& out, const unsigned char* it, int length, bool finalChunk)

{

    unsigned char* bufferEnd = _encodeBuffer + 3;

    // Set the input pointers relative to this input

    const unsigned char* lineEnd = it + _encodeLineCharsRemaining;

    const unsigned char* const end = it + length;

    while (it != end)

    {

        bool trailingLF = false;

        const unsigned char input = *it++;

        if ((input == CarriageReturn || input == LineFeed) && (_content == Text))

        {

            if (_lastChar == CarriageReturn && input == LineFeed)

            {

                // We have already encoded this character-sequence

                // We can accept one more input character than accounted for

                lineEnd += 1;

            }

            else 

            {

                // We must replace this character with ASCII CRLF

                *_encodeBufferOut++ = CarriageReturn;

                if (_encodeBufferOut != bufferEnd)

                {

                    *_encodeBufferOut++ = LineFeed;

                }

                else 

                {

                    trailingLF = true;

                }

                // We can accept one fewer input character than expected, now

                lineEnd -= 1;

            }

            _lastChar = input;

        }

        else

            *_encodeBufferOut++ = input;

        if (_encodeBufferOut == bufferEnd)

        {

            // We have buffered 3 input bytes - write them out as four output bytes

            out << Base64Values[(_encodeBuffer[0] >> 2) & 0x3f];

            out << Base64Values[(((_encodeBuffer[0] & 0x03) << 4) | (_encodeBuffer[1] >> 4)) & 0x3f];

            out << Base64Values[(((_encodeBuffer[1] & 0x0f) << 2) | (_encodeBuffer[2] >> 6)) & 0x3f];

            out << Base64Values[_encodeBuffer[2] & 0x3f];

            _encodeBufferOut = _encodeBuffer;

            if ((it >= lineEnd) && ((it != end) || !finalChunk))

            {