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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $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 "qfontengine_qpf_p.h"

#include "private/qpaintengine_raster_p.h"

#include <QtCore/qlibraryinfo.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qfile.h>

#include <QtCore/qdir.h>

#include <QtCore/qbuffer.h>

#if !defined(QT_NO_FREETYPE)

#include "private/qfontengine_ft_p.h"

#endif

#include "private/qcore_unix_p.h" // overrides QT_OPEN

// for mmap

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <errno.h>

QT_BEGIN_NAMESPACE

#ifndef QT_NO_QWS_QPF2

#include "qpfutil.cpp"

QT_BEGIN_INCLUDE_NAMESPACE

#if defined(Q_WS_QWS)

#   include "private/qwscommand_qws_p.h"

#   include "qwsdisplay_qws.h"

#   include "qabstractfontengine_p.h"

#endif

#include "qplatformdefs.h"

QT_END_INCLUDE_NAMESPACE

//#define DEBUG_HEADER

//#define DEBUG_FONTENGINE

#if defined(DEBUG_HEADER)

# define DEBUG_VERIFY qDebug

#else

# define DEBUG_VERIFY if (0) qDebug

#endif

#define READ_VERIFY(type, variable) \

    if (tagPtr + sizeof(type) > endPtr) { \

        DEBUG_VERIFY() << "read verify failed in line" << __LINE__; \

        return 0; \

    } \

    variable = qFromBigEndian<type>(tagPtr); \

    DEBUG_VERIFY() << "read value" << variable << "of type " #type; \

    tagPtr += sizeof(type)

template <typename T>

T readValue(const uchar *&data)

{

    T value = qFromBigEndian<T>(data);

    data += sizeof(T);

    return value;

}

#define VERIFY(condition) \

    if (!(condition)) { \

        DEBUG_VERIFY() << "condition " #condition " failed in line" << __LINE__; \

        return 0; \

    }

#define VERIFY_TAG(condition) \

    if (!(condition)) { \

        DEBUG_VERIFY() << "verifying tag condition " #condition " failed in line" << __LINE__ << "with tag" << tag; \

        return 0; \

    }

static inline const uchar *verifyTag(const uchar *tagPtr, const uchar *endPtr)

{

    quint16 tag, length;

    READ_VERIFY(quint16, tag);

    READ_VERIFY(quint16, length);

    if (tag == QFontEngineQPF::Tag_EndOfHeader)

        return endPtr;

    if (tag < QFontEngineQPF::NumTags) {

        switch (tagTypes[tag]) {

            case QFontEngineQPF::BitFieldType:

            case QFontEngineQPF::StringType:

                // can't do anything...

                break;

            case QFontEngineQPF::UInt32Type:

                VERIFY_TAG(length == sizeof(quint32));

                break;

            case QFontEngineQPF::FixedType:

                VERIFY_TAG(length == sizeof(quint32));

                break;

            case QFontEngineQPF::UInt8Type:

                VERIFY_TAG(length == sizeof(quint8));

                break;

        }

#if defined(DEBUG_HEADER)

        if (length == 1)

            qDebug() << "tag data" << hex << *tagPtr;

        else if (length == 4)

            qDebug() << "tag data" << hex << tagPtr[0] << tagPtr[1] << tagPtr[2] << tagPtr[3];

#endif

    }

    return tagPtr + length;

}

const QFontEngineQPF::Glyph *QFontEngineQPF::findGlyph(glyph_t g) const

{

    if (!g || g >= glyphMapEntries)

        return 0;

    const quint32 *gmapPtr = reinterpret_cast<const quint32 *>(fontData + glyphMapOffset);

    quint32 glyphPos = qFromBigEndian<quint32>(gmapPtr[g]);

    if (glyphPos > glyphDataSize) {

        if (glyphPos == 0xffffffff)

            return 0;

#if defined(DEBUG_FONTENGINE)

        qDebug() << "glyph" << g << "outside of glyphData, remapping font file";

#endif

#if !defined(QT_NO_FREETYPE) && !defined(QT_FONTS_ARE_RESOURCES)

        const_cast<QFontEngineQPF *>(this)->remapFontData();

#endif

        if (glyphPos > glyphDataSize)

            return 0;

    }

    return reinterpret_cast<const Glyph *>(fontData + glyphDataOffset + glyphPos);

}

bool QFontEngineQPF::verifyHeader(const uchar *data, int size)

{

    VERIFY(size >= int(sizeof(Header)));

    const Header *header = reinterpret_cast<const Header *>(data);

    if (header->magic[0] != 'Q'

        || header->magic[1] != 'P'

        || header->magic[2] != 'F'

        || header->magic[3] != '2')

        return false;

    VERIFY(header->majorVersion <= CurrentMajorVersion);

    const quint16 dataSize = qFromBigEndian<quint16>(header->dataSize);

    VERIFY(size >= int(sizeof(Header)) + dataSize);

    const uchar *tagPtr = data + sizeof(Header);

    const uchar *tagEndPtr = tagPtr + dataSize;

    while (tagPtr < tagEndPtr - 3) {

        tagPtr = verifyTag(tagPtr, tagEndPtr);

        VERIFY(tagPtr);

    }

    VERIFY(tagPtr <= tagEndPtr);

    return true;

}

QVariant QFontEngineQPF::extractHeaderField(const uchar *data, HeaderTag requestedTag)

{

    const Header *header = reinterpret_cast<const Header *>(data);

    const uchar *tagPtr = data + sizeof(Header);

    const uchar *endPtr = tagPtr + qFromBigEndian<quint16>(header->dataSize);

    while (tagPtr < endPtr - 3) {

        quint16 tag = readValue<quint16>(tagPtr);

        quint16 length = readValue<quint16>(tagPtr);

        if (tag == requestedTag) {

            switch (tagTypes[requestedTag]) {

                case StringType:

                    return QVariant(QString::fromUtf8(reinterpret_cast<const char *>(tagPtr), length));

                case UInt32Type:

                    return QVariant(readValue<quint32>(tagPtr));

                case UInt8Type:

                    return QVariant(uint(*tagPtr));

                case FixedType:

                    return QVariant(QFixed::fromFixed(readValue<quint32>(tagPtr)).toReal());

                case BitFieldType:

                    return QVariant(QByteArray(reinterpret_cast<const char *>(tagPtr), length));

            }

            return QVariant();

        } else if (tag == Tag_EndOfHeader) {

            break;

        }

        tagPtr += length;

    }

    return QVariant();

}

#endif // QT_NO_QWS_QPF2

QString qws_fontCacheDir()

{

    QString dir;

#if defined(Q_WS_QWS)

    extern QString qws_dataDir();

    dir = qws_dataDir();

#else

    dir = QDir::tempPath();

#endif

    dir.append(QLatin1String("/fonts/"));

    QDir qd(dir);

    if (!qd.exists() && !qd.mkpath(dir))

        dir = QDir::tempPath();

    return dir;

}

#ifndef QT_NO_QWS_QPF2

#ifndef QT_FONTS_ARE_RESOURCES

QList<QByteArray> QFontEngineQPF::cleanUpAfterClientCrash(const QList<int> &crashedClientIds)

{

    QList<QByteArray> removedFonts;

    QDir dir(qws_fontCacheDir(), QLatin1String("*.qsf"));

    for (int i = 0; i < int(dir.count()); ++i) {

        const QByteArray fileName = QFile::encodeName(dir.absoluteFilePath(dir[i]));

        int fd = QT_OPEN(fileName.constData(), O_RDONLY, 0);

        if (fd >= 0) {

            void *header = ::mmap(0, sizeof(QFontEngineQPF::Header), PROT_READ, MAP_SHARED, fd, 0);

            if (header && header != MAP_FAILED) {

                quint32 lockValue = reinterpret_cast<QFontEngineQPF::Header *>(header)->lock;

                if (lockValue && crashedClientIds.contains(lockValue)) {

                    removedFonts.append(fileName);

                    QFile::remove(QFile::decodeName(fileName));

                }

                ::munmap(header, sizeof(QFontEngineQPF::Header));

            }

            QT_CLOSE(fd);

        }

    }

    if (!removedFonts.isEmpty())

        qDebug() << "list of corrupted and removed fonts:" << removedFonts;

    return removedFonts;

}

#endif

static inline unsigned int getChar(const QChar *str, int &i, const int len)

{

    unsigned int uc = str[i].unicode();

    if (uc >= 0xd800 && uc < 0xdc00 && i < len-1) {

        uint low = str[i+1].unicode();

       if (low >= 0xdc00 && low < 0xe000) {

            uc = (uc - 0xd800)*0x400 + (low - 0xdc00) + 0x10000;

            ++i;

        }

    }

    return uc;

}

#ifdef QT_FONTS_ARE_RESOURCES

QFontEngineQPF::QFontEngineQPF(const QFontDef &def, const uchar *bytes, int size)

    : fd(-1), fontData(bytes), dataSize(size), renderingFontEngine(0)

#else

QFontEngineQPF::QFontEngineQPF(const QFontDef &def, int fileDescriptor, QFontEngine *fontEngine)

    : fd(fileDescriptor), fontData(0), dataSize(0), renderingFontEngine(fontEngine)

#endif

{

    fontDef = def;

    cache_cost = 100;

    freetype = 0;

    externalCMap = 0;

    cmapOffset = 0;

    cmapSize = 0;

    glyphMapOffset = 0;

    glyphMapEntries = 0;

    glyphDataOffset = 0;

    glyphDataSize = 0;

    kerning_pairs_loaded = false;

    readOnly = true;

#if defined(DEBUG_FONTENGINE)

    qDebug() << "QFontEngineQPF::QFontEngineQPF( fd =" << fd << ", renderingFontEngine =" << renderingFontEngine << ')';

#endif

#ifndef QT_FONTS_ARE_RESOURCES

    if (fd < 0) {

        if (!renderingFontEngine)

            return;

        fileName = fontDef.family.toLower() + QLatin1Char('_')

                   + QString::number(fontDef.pixelSize)

                   + QLatin1Char('_') + QString::number(fontDef.weight)

                   + (fontDef.style != QFont::StyleNormal ?

                      QLatin1String("_italic") : QLatin1String(""))

                   + QLatin1String(".qsf");

        fileName.replace(QLatin1Char(' '), QLatin1Char('_'));

        fileName.prepend(qws_fontCacheDir());

        encodedFileName = QFile::encodeName(fileName);

        if (::access(encodedFileName, F_OK) == 0) {

#if defined(DEBUG_FONTENGINE)

            qDebug() << "found existing qpf:" << fileName;

#endif

            if (::access(encodedFileName, W_OK | R_OK) == 0) {

                fd = QT_OPEN(encodedFileName, O_RDWR);

            }

            // read-write access failed - try read-only access

            if (fd == -1 && ::access(encodedFileName, R_OK) == 0) {

                fd = QT_OPEN(encodedFileName, O_RDONLY);

                if (fd == -1) {

#if defined(DEBUG_FONTENGINE)

                    qErrnoWarning("QFontEngineQPF: unable to open %s", encodedName.constData());

#endif

                    return;

                }

            }

            if (fd == -1) {

#if defined(DEBUG_FONTENGINE)

                qWarning("QFontEngineQPF: insufficient access rights to %s", encodedName.constData());

#endif

                return;

            }

        } else {

#if defined(DEBUG_FONTENGINE)

            qDebug() << "creating qpf on the fly:" << fileName;

#endif

            if (::access(QFile::encodeName(qws_fontCacheDir()), W_OK) == 0) {

                fd = QT_OPEN(encodedFileName, O_RDWR | O_EXCL | O_CREAT, 0644);

                if (fd == -1) {

#if defined(DEBUG_FONTENGINE)

                    qErrnoWarning(errno, "QFontEngineQPF: open() failed for %s", encodedName.constData());

#endif

                    return;

                }

                QBuffer buffer;

                buffer.open(QIODevice::ReadWrite);

                QPFGenerator generator(&buffer, renderingFontEngine);

                generator.generate();

                buffer.close();

                const QByteArray &data = buffer.data();

                if (QT_WRITE(fd, data.constData(), data.size()) == -1) {

#if defined(DEBUG_FONTENGINE)

                    qErrnoWarning(errno, "QFontEngineQPF: write() failed for %s", encodedName.constData());

#endif

                    return;

                }

            } else {

#if defined(DEBUG_FONTENGINE)

                qErrnoWarning(errno, "QFontEngineQPF: access() failed for %s", qPrintable(qws_fontCacheDir()));

#endif

                return;

            }

        }

    }

    QT_STATBUF st;

    if (QT_FSTAT(fd, &st)) {

#if defined(DEBUG_FONTENGINE)

        qErrnoWarning(errno, "QFontEngineQPF: fstat failed!");

#endif

        return;

    }

    dataSize = st.st_size;

    fontData = (const uchar *)::mmap(0, st.st_size, PROT_READ | (renderingFontEngine ? PROT_WRITE : 0), MAP_SHARED, fd, 0);

    if (!fontData || fontData == (const uchar *)MAP_FAILED) {

#if defined(DEBUG_FONTENGINE)

        perror("mmap failed");

#endif

        fontData = 0;

        return;

    }

#endif //QT_FONTS_ARE_RESOURCES

    if (!verifyHeader(fontData, dataSize)) {

#if defined(DEBUG_FONTENGINE)

        qDebug() << "verifyHeader failed!";

#endif

        return;

    }

    const Header *header = reinterpret_cast<const Header *>(fontData);

    readOnly = (header->lock == 0xffffffff);

    const uchar *data = fontData + sizeof(Header) + qFromBigEndian<quint16>(header->dataSize);

    const uchar *endPtr = fontData + dataSize;

    while (data <= endPtr - 8) {

        quint16 blockTag = readValue<quint16>(data);

        data += 2; // skip padding

        quint32 blockSize = readValue<quint32>(data);

        if (blockTag == CMapBlock) {

            cmapOffset = data - fontData;

            cmapSize = blockSize;

        } else if (blockTag == GMapBlock) {

            glyphMapOffset = data - fontData;

            glyphMapEntries = blockSize / 4;

        } else if (blockTag == GlyphBlock) {

            glyphDataOffset = data - fontData;

            glyphDataSize = blockSize;

        }

        data += blockSize;

    }

    face_id.filename = QFile::encodeName(extractHeaderField(fontData, Tag_FileName).toString());

    face_id.index = extractHeaderField(fontData, Tag_FileIndex).toInt();

#if !defined(QT_NO_FREETYPE) && !defined(QT_FONTS_ARE_RESOURCES)

    freetype = QFreetypeFace::getFace(face_id);

    if (!freetype) {

        QString newPath =

#ifndef QT_NO_SETTINGS

            QLibraryInfo::location(QLibraryInfo::LibrariesPath) +

#endif

                          QLatin1String("/fonts/") +

                          QFileInfo(QFile::decodeName(face_id.filename)).fileName();

        face_id.filename = QFile::encodeName(newPath);

        freetype = QFreetypeFace::getFace(face_id);

    }

    if (freetype) {

        const quint32 qpfTtfRevision = extractHeaderField(fontData, Tag_FontRevision).toUInt();

        uchar data[4];

        uint length = 4;

        bool ok = freetype->getSfntTable(MAKE_TAG('h', 'e', 'a', 'd'), data, &length);

        if (!ok || length != 4

            || qFromBigEndian<quint32>(data) != qpfTtfRevision) {

            freetype->release(face_id);

            freetype = 0;

        }

    }

    if (!cmapOffset && freetype) {

        freetypeCMapTable = getSfntTable(MAKE_TAG('c', 'm', 'a', 'p'));

        externalCMap = reinterpret_cast<const uchar *>(freetypeCMapTable.constData());

        cmapSize = freetypeCMapTable.size();

    }

#endif

    // get the real cmap

    if (cmapOffset) {

        int tableSize = cmapSize;

        const uchar *cmapPtr = getCMap(fontData + cmapOffset, tableSize, &symbol, &cmapSize);

        if (cmapPtr)

            cmapOffset = cmapPtr - fontData;

        else

            cmapOffset = 0;

    } else if (externalCMap) {

        int tableSize = cmapSize;

        externalCMap = getCMap(externalCMap, tableSize, &symbol, &cmapSize);

    }

    // verify all the positions in the glyphMap

    if (glyphMapOffset) {

        const quint32 *gmapPtr = reinterpret_cast<const quint32 *>(fontData + glyphMapOffset);

        for (uint i = 0; i < glyphMapEntries; ++i) {

            quint32 glyphDataPos = qFromBigEndian<quint32>(gmapPtr[i]);

            if (glyphDataPos == 0xffffffff)

                continue;

            if (glyphDataPos >= glyphDataSize) {

                // error

                glyphMapOffset = 0;

                glyphMapEntries = 0;

                break;

            }

        }

    }

#if defined(DEBUG_FONTENGINE)

    if (!isValid())

        qDebug() << "fontData" <<  fontData << "dataSize" << dataSize

                 << "externalCMap" << externalCMap << "cmapOffset" << cmapOffset

                 << "glyphMapOffset" << glyphMapOffset << "glyphDataOffset" << glyphDataOffset

                 << "fd" << fd << "glyphDataSize" << glyphDataSize;

#endif

#if defined(Q_WS_QWS)

    if (isValid() && renderingFontEngine)

        qt_fbdpy->sendFontCommand(QWSFontCommand::StartedUsingFont, encodedFileName);

#endif

}

QFontEngineQPF::~QFontEngineQPF()

{

#if defined(Q_WS_QWS)

    if (isValid() && renderingFontEngine) {

        QT_TRY {

            qt_fbdpy->sendFontCommand(QWSFontCommand::StoppedUsingFont, encodedFileName);

        } QT_CATCH(...) {

            qDebug("QFontEngineQPF::~QFontEngineQPF: Out of memory");

            // ignore.

        }

    }

#endif

    delete renderingFontEngine;

    if (fontData) {

        if (munmap((void *)fontData, dataSize) == -1) {