qxbmhandler.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
 
#include <qplatformdefs.h>
#include "private/qxbmhandler_p.h"
 
#ifndef QT_NO_IMAGEFORMAT_XBM
 
#include <qimage.h>
#include <qiodevice.h>
#include <qloggingcategory.h>
#include <qvariant.h>
#include <private/qtools_p.h>
#include <private/qimage_p.h>
 
#include <cstdio>
 
#include <stdio.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QtMiscUtils;
 
/*****************************************************************************
  X bitmap image read/write functions
 *****************************************************************************/
 
static inline int hex2byte(char *p)
{
    return QtMiscUtils::fromHex(p[0]) * 16 | QtMiscUtils::fromHex(p[1]);
}
 
static bool read_xbm_header(QIODevice *device, int& w, int& h)
{
    const int buflen = 300;
    const int maxlen = 4096;
    char buf[buflen + 1];
 
    qint64 readBytes = 0;
    qint64 totalReadBytes = 0;
 
    buf[0] = '\0';
 
    // skip initial comment, if any
    while (buf[0] != '#') {
        readBytes = device->readLine(buf, buflen);
 
        // if readBytes >= buflen, it's very probably not a C file
        if (readBytes <= 0 || readBytes >= buflen -1)
            return false;
 
        // limit xbm headers to the first 4k in the file to prevent
        // excessive reads on non-xbm files
        totalReadBytes += readBytes;
        if (totalReadBytes >= maxlen)
            return false;
    }
 
    auto parseDefine = [] (const char *buf, int len) -> int {
        auto checkChar = [] (char ch) -> bool {
            return isAsciiLetterOrNumber(ch)
                || ch == '_' || ch == '.';
        };
        auto isAsciiSpace = [] (char ch) -> bool {
            return ch == ' ' || ch == '\t';
        };
        const char define[] = "#define";
        constexpr size_t defineLen = sizeof(define) - 1;
        if (strncmp(buf, define, defineLen) != 0)
            return 0;
        int index = defineLen;
        while (buf[index] && isAsciiSpace(buf[index]))
            ++index;
        while (buf[index] && checkChar(buf[index]))
            ++index;
        while (buf[index] && isAsciiSpace(buf[index]))
            ++index;
 
        return QByteArray(buf + index, len - index).toInt();
    };
 
 
    // "#define .._width <num>"
    w = parseDefine(buf, readBytes - 1);
 
    readBytes = device->readLine(buf, buflen);
    // "#define .._height <num>"
    h = parseDefine(buf, readBytes - 1);
 
    // format error
    if (w <= 0 || w > 32767 || h <= 0 || h > 32767)
        return false;
 
    return true;
}
 
static bool read_xbm_body(QIODevice *device, int w, int h, QImage *outImage)
{
    const int buflen = 300;
    char buf[buflen + 1];
 
    qint64 readBytes = 0;
 
    char *p;
 
    // scan for database
    do {
        if ((readBytes = device->readLine(buf, buflen)) <= 0) {
            // end of file
            return false;
        }
 
        buf[readBytes] = '\0';
        p = strstr(buf, "0x");
    } while (!p);
 
    if (!QImageIOHandler::allocateImage(QSize(w, h), QImage::Format_MonoLSB, outImage))
        return false;
 
    outImage->fill(Qt::color0);       // in case the image data does not cover the full image
 
    outImage->setColorCount(2);
    outImage->setColor(0, qRgb(255,255,255));        // white
    outImage->setColor(1, qRgb(0,0,0));                // black
 
    int           x = 0, y = 0;
    uchar *b = outImage->scanLine(0);
    w = (w+7)/8;                                // byte width
 
    while (y < h) {                                // for all encoded bytes...
        if (p && p < (buf + readBytes - 3)) {      // p = "0x.."
            const int byte = hex2byte(p + 2);
            if (byte < 0) // non-hex char encountered
                return false;
            *b++ = byte;
            p += 2;
            if (++x == w && ++y < h) {
                b = outImage->scanLine(y);
                x = 0;
            }
            p = strstr(p, "0x");
        } else {                                // read another line
            if ((readBytes = device->readLine(buf,buflen)) <= 0)        // EOF ==> truncated image
                break;
            buf[readBytes] = '\0';
            p = strstr(buf, "0x");
        }
    }
 
    return true;
}
 
static bool read_xbm_image(QIODevice *device, QImage *outImage)
{
    int w = 0, h = 0;
    if (!read_xbm_header(device, w, h))
        return false;
    return read_xbm_body(device, w, h, outImage);
}
 
static bool write_xbm_image(const QImage &sourceImage, QIODevice *device, const QString &fileName)
{
    QImage image = sourceImage;
    int        w = image.width();
    int        h = image.height();
    int        i;
    const QByteArray s = fileName.toUtf8(); // get file base name
    const auto msize = s.size() + 100;
    char *buf = new char[msize];
 
    std::snprintf(buf, msize, "#define %s_width %d\n", s.data(), w);
    device->write(buf, qstrlen(buf));
    std::snprintf(buf, msize, "#define %s_height %d\n", s.data(), h);
    device->write(buf, qstrlen(buf));
    std::snprintf(buf, msize, "static char %s_bits[] = {\n ", s.data());
    device->write(buf, qstrlen(buf));
 
    if (image.format() != QImage::Format_MonoLSB)
        image = image.convertToFormat(QImage::Format_MonoLSB);
 
    bool invert = qGray(image.color(0)) < qGray(image.color(1));
    char hexrep[16];
    for (i=0; i<10; i++)
        hexrep[i] = '0' + i;
    for (i=10; i<16; i++)
        hexrep[i] = 'a' -10 + i;
    if (invert) {
        char t;
        for (i=0; i<8; i++) {
            t = hexrep[15-i];
            hexrep[15-i] = hexrep[i];
            hexrep[i] = t;
        }
    }
    int bcnt = 0;
    char *p = buf;
    int bpl = (w+7)/8;
    for (int y = 0; y < h; ++y) {
        const uchar *b = image.constScanLine(y);
        for (i = 0; i < bpl; ++i) {
            *p++ = '0'; *p++ = 'x';
            *p++ = hexrep[*b >> 4];
            *p++ = hexrep[*b++ & 0xf];
 
            if (i < bpl - 1 || y < h - 1) {
                *p++ = ',';
                if (++bcnt > 14) {
                    *p++ = '\n';
                    *p++ = ' ';
                    *p   = '\0';
                    if ((int)qstrlen(buf) != device->write(buf, qstrlen(buf))) {
                        delete [] buf;
                        return false;
                    }
                    p = buf;
                    bcnt = 0;
                }
            }
        }
    }
#ifdef Q_CC_MSVC
    strcpy_s(p, sizeof(" };\n"), " };\n");
#else
    strcpy(p, " };\n");
#endif
    if ((int)qstrlen(buf) != device->write(buf, qstrlen(buf))) {
        delete [] buf;
        return false;
    }
 
    delete [] buf;
    return true;
}
 
QXbmHandler::QXbmHandler()
    : state(Ready)
{
}
 
bool QXbmHandler::readHeader()
{
    state = Error;
    if (!read_xbm_header(device(), width, height))
        return false;
    state = ReadHeader;
    return true;
}
 
bool QXbmHandler::canRead() const
{
    if (state == Ready && !canRead(device()))
        return false;
 
    if (state != Error) {
        setFormat("xbm");
        return true;
    }
 
    return false;
}
 
bool QXbmHandler::canRead(QIODevice *device)
{
    if (!device) {
        qCWarning(lcImageIo, "QXbmHandler::canRead() called with no device");
        return false;
    }
 
    // it's impossible to tell whether we can load an XBM or not when
    // it's from a sequential device, as the only way to do it is to
    // attempt to parse the whole image.
    if (device->isSequential())
        return false;
 
    QImage image;
    qint64 oldPos = device->pos();
    bool success = read_xbm_image(device, &image);
    device->seek(oldPos);
 
    return success;
}
 
bool QXbmHandler::read(QImage *image)
{
    if (state == Error)
        return false;
 
    if (state == Ready && !readHeader()) {
        state = Error;
        return false;
    }
 
    if (!read_xbm_body(device(), width, height, image)) {
        state = Error;
        return false;
    }
 
    state = Ready;
    return true;
}
 
bool QXbmHandler::write(const QImage &image)
{
    return write_xbm_image(image, device(), fileName);
}
 
bool QXbmHandler::supportsOption(ImageOption option) const
{
    return option == Name
        || option == Size
        || option == ImageFormat;
}
 
QVariant QXbmHandler::option(ImageOption option) const
{
    if (option == Name) {
        return fileName;
    } else if (option == Size) {
        if (state == Error)
            return QVariant();
        if (state == Ready && !const_cast<QXbmHandler*>(this)->readHeader())
            return QVariant();
        return QSize(width, height);
    } else if (option == ImageFormat) {
        return QImage::Format_MonoLSB;
    }
    return QVariant();
}
 
void QXbmHandler::setOption(ImageOption option, const QVariant &value)
{
    if (option == Name)
        fileName = value.toString();
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_IMAGEFORMAT_XBM