Revision control
++ // 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