qbuffer.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 "qbuffer.h"
#include <QtCore/qmetaobject.h>
#include "private/qiodevice_p.h"
 
#include <limits>
 
QT_BEGIN_NAMESPACE
 
/** QBufferPrivate **/
class QBufferPrivate : public QIODevicePrivate
{
    Q_DECLARE_PUBLIC(QBuffer)
 
public:
    QBufferPrivate() = default;
 
    QByteArray *buf = nullptr;
    QByteArray defaultBuf;
 
    qint64 peek(char *data, qint64 maxSize) override;
    QByteArray peek(qint64 maxSize) override;
 
#ifndef QT_NO_QOBJECT
    qint64 writtenSinceLastEmit = 0;
    int signalConnectionCount = 0;
    bool signalsEmitted = false;
#endif
};
 
qint64 QBufferPrivate::peek(char *data, qint64 maxSize)
{
    qint64 readBytes = qMin(maxSize, static_cast<qint64>(buf->size()) - pos);
    memcpy(data, buf->constData() + pos, readBytes);
    return readBytes;
}
 
QByteArray QBufferPrivate::peek(qint64 maxSize)
{
    qint64 readBytes = qMin(maxSize, static_cast<qint64>(buf->size()) - pos);
    if (pos == 0 && maxSize >= buf->size())
        return *buf;
    return QByteArray(buf->constData() + pos, readBytes);
}
 
/*!
    \class QBuffer
    \inmodule QtCore
    \reentrant
    \brief The QBuffer class provides a QIODevice interface for a QByteArray.
 
    \ingroup io
 
    QBuffer allows you to access a QByteArray using the QIODevice
    interface. The QByteArray is treated just as a standard random-accessed
    file. Example:
 
    \snippet buffer/buffer.cpp 0
 
    By default, an internal QByteArray buffer is created for you when
    you create a QBuffer. You can access this buffer directly by
    calling buffer(). You can also use QBuffer with an existing
    QByteArray by calling setBuffer(), or by passing your array to
    QBuffer's constructor.
 
    Call open() to open the buffer. Then call write() or
    putChar() to write to the buffer, and read(), readLine(),
    readAll(), or getChar() to read from it. size() returns the
    current size of the buffer, and you can seek to arbitrary
    positions in the buffer by calling seek(). When you are done with
    accessing the buffer, call close().
 
    The following code snippet shows how to write data to a
    QByteArray using QDataStream and QBuffer:
 
    \snippet buffer/buffer.cpp 1
 
    Effectively, we convert the application's QPalette into a byte
    array. Here's how to read the data from the QByteArray:
 
    \snippet buffer/buffer.cpp 2
 
    QTextStream and QDataStream also provide convenience constructors
    that take a QByteArray and that create a QBuffer behind the
    scenes.
 
    QBuffer emits readyRead() when new data has arrived in the
    buffer. By connecting to this signal, you can use QBuffer to
    store temporary data before processing it. QBuffer also emits
    bytesWritten() every time new data has been written to the buffer.
 
    \sa QFile, QDataStream, QTextStream, QByteArray
*/
 
#ifdef QT_NO_QOBJECT
QBuffer::QBuffer()
    : QIODevice(*new QBufferPrivate)
{
    Q_D(QBuffer);
    d->buf = &d->defaultBuf;
}
QBuffer::QBuffer(QByteArray *buf)
    : QIODevice(*new QBufferPrivate)
{
    Q_D(QBuffer);
    d->buf = buf ? buf : &d->defaultBuf;
    d->defaultBuf.clear();
}
#else
/*!
    Constructs an empty buffer with the given \a parent. You can call
    setData() to fill the buffer with data, or you can open it in
    write mode and use write().
 
    \sa open()
*/
QBuffer::QBuffer(QObject *parent)
    : QIODevice(*new QBufferPrivate, parent)
{
    Q_D(QBuffer);
    d->buf = &d->defaultBuf;
}
 
/*!
    Constructs a QBuffer that uses the QByteArray pointed to by \a
    byteArray as its internal buffer, and with the given \a parent.
    The caller is responsible for ensuring that \a byteArray remains
    valid until the QBuffer is destroyed, or until setBuffer() is
    called to change the buffer. QBuffer doesn't take ownership of
    the QByteArray.
 
    If you open the buffer in write-only mode or read-write mode and
    write something into the QBuffer, \a byteArray will be modified.
 
    Example:
 
    \snippet buffer/buffer.cpp 3
 
    \sa open(), setBuffer(), setData()
*/
QBuffer::QBuffer(QByteArray *byteArray, QObject *parent)
    : QIODevice(*new QBufferPrivate, parent)
{
    Q_D(QBuffer);
    d->buf = byteArray ? byteArray : &d->defaultBuf;
    d->defaultBuf.clear();
}
#endif
 
/*!
    Destroys the buffer.
*/
 
QBuffer::~QBuffer()
{
}
 
/*!
    Makes QBuffer use the QByteArray pointed to by \a
    byteArray as its internal buffer. The caller is responsible for
    ensuring that \a byteArray remains valid until the QBuffer is
    destroyed, or until setBuffer() is called to change the buffer.
    QBuffer doesn't take ownership of the QByteArray.
 
    Does nothing if isOpen() is true.
 
    If you open the buffer in write-only mode or read-write mode and
    write something into the QBuffer, \a byteArray will be modified.
 
    Example:
 
    \snippet buffer/buffer.cpp 4
 
    If \a byteArray is \nullptr, the buffer creates its own internal
    QByteArray to work on. This byte array is initially empty.
 
    \sa buffer(), setData(), open()
*/
 
void QBuffer::setBuffer(QByteArray *byteArray)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setBuffer: Buffer is open");
        return;
    }
    if (byteArray) {
        d->buf = byteArray;
    } else {
        d->buf = &d->defaultBuf;
    }
    d->defaultBuf.clear();
}
 
/*!
    Returns a reference to the QBuffer's internal buffer. You can use
    it to modify the QByteArray behind the QBuffer's back.
 
    \sa setBuffer(), data()
*/
 
QByteArray &QBuffer::buffer()
{
    Q_D(QBuffer);
    return *d->buf;
}
 
/*!
    \overload
 
    This is the same as data().
*/
 
const QByteArray &QBuffer::buffer() const
{
    Q_D(const QBuffer);
    return *d->buf;
}
 
 
/*!
    Returns the data contained in the buffer.
 
    This is the same as buffer().
 
    \sa setData(), setBuffer()
*/
 
const QByteArray &QBuffer::data() const
{
    Q_D(const QBuffer);
    return *d->buf;
}
 
/*!
    Sets the contents of the internal buffer to be \a data. This is
    the same as assigning \a data to buffer().
 
    Does nothing if isOpen() is true.
 
    \sa setBuffer()
*/
void QBuffer::setData(const QByteArray &data)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setData: Buffer is open");
        return;
    }
    *d->buf = data;
}
 
/*!
    \overload
 
    Sets the contents of the internal buffer to be the first \a size
    bytes of \a data.
 
    \note In Qt versions prior to 6.5, this function took the length as
    an \c{int} parameter, potentially truncating sizes.
*/
void QBuffer::setData(const char *data, qsizetype size)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setData: Buffer is open");
        return;
    }
    d->buf->assign(data, data + size);
}
 
/*!
    Opens the buffer using \a mode flags, returning \c true if successful;
    otherwise returns \c false.
 
    The flags for \a mode must include \l QIODeviceBase::ReadOnly,
    \l WriteOnly, or \l ReadWrite. If not, an error is printed and
    the method fails. In any other case, it succeeds.
 
    Unlike \l QFile::open(), opening a QBuffer with \l WriteOnly
    does not truncate it. However, \l pos() is set to \c{0}.
    Use \l Append or \l Truncate to change either behavior.
*/
bool QBuffer::open(OpenMode mode)
{
    Q_D(QBuffer);
 
    if ((mode & (Append | Truncate)) != 0)
        mode |= WriteOnly;
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QBuffer::open: Buffer access not specified");
        return false;
    }
 
    if ((mode & Truncate) == Truncate)
        d->buf->resize(0);
 
    return QIODevice::open(mode | QIODevice::Unbuffered);
}
 
/*!
    \reimp
*/
void QBuffer::close()
{
    QIODevice::close();
}
 
/*!
    \reimp
*/
qint64 QBuffer::pos() const
{
    return QIODevice::pos();
}
 
/*!
    \reimp
*/
qint64 QBuffer::size() const
{
    Q_D(const QBuffer);
    return qint64(d->buf->size());
}
 
/*!
    \reimp
*/
bool QBuffer::seek(qint64 pos)
{
    Q_D(QBuffer);
    const auto oldBufSize = d->buf->size();
    constexpr qint64 MaxSeekPos = (std::numeric_limits<decltype(oldBufSize)>::max)();
    if (pos <= MaxSeekPos && pos > oldBufSize && isWritable()) {
        QT_TRY {
            d->buf->resize(qsizetype(pos), '\0');
        } QT_CATCH(const std::bad_alloc &) {} // swallow, failure case is handled below
        if (d->buf->size() != pos) {
            qWarning("QBuffer::seek: Unable to fill gap");
            return false;
        }
    }
    if (pos > d->buf->size() || pos < 0) {
        qWarning("QBuffer::seek: Invalid pos: %lld", pos);
        return false;
    }
    return QIODevice::seek(pos);
}
 
/*!
    \reimp
*/
bool QBuffer::atEnd() const
{
    return QIODevice::atEnd();
}
 
/*!
   \reimp
*/
bool QBuffer::canReadLine() const
{
    Q_D(const QBuffer);
    if (!isOpen())
        return false;
 
    return d->buf->indexOf('\n', int(pos())) != -1 || QIODevice::canReadLine();
}
 
/*!
    \reimp
*/
qint64 QBuffer::readData(char *data, qint64 len)
{
    Q_D(QBuffer);
    if ((len = qMin(len, qint64(d->buf->size()) - pos())) <= 0)
        return qint64(0);
    memcpy(data, d->buf->constData() + pos(), len);
    return len;
}
 
/*!
    \reimp
*/
qint64 QBuffer::writeData(const char *data, qint64 len)
{
    Q_D(QBuffer);
    const quint64 required = quint64(pos()) + quint64(len); // cannot overflow (pos() ≥ 0, len ≥ 0)
 
    if (required > quint64(d->buf->size())) { // capacity exceeded
        // The following must hold, since qsizetype covers half the virtual address space:
        Q_ASSERT(required <= quint64((std::numeric_limits<qsizetype>::max)()));
        d->buf->resize(qsizetype(required));
        if (quint64(d->buf->size()) != required) { // could not resize
            qWarning("QBuffer::writeData: Memory allocation error");
            return -1;
        }
    }
 
    memcpy(d->buf->data() + pos(), data, size_t(len));
 
#ifndef QT_NO_QOBJECT
    d->writtenSinceLastEmit += len;
    if (d->signalConnectionCount && !d->signalsEmitted && !signalsBlocked()) {
        d->signalsEmitted = true;
        QMetaObject::invokeMethod(this, [](QBuffer *q) {
            auto d = q->d_func();
            emit q->bytesWritten(d->writtenSinceLastEmit);
            d->writtenSinceLastEmit = 0;
            emit q->readyRead();
            d->signalsEmitted = false;
        }, Qt::QueuedConnection, this);
    }
#endif
    return len;
}
 
#ifndef QT_NO_QOBJECT
static bool is_tracked_signal(const QMetaMethod &signal)
{
    // dynamic initialization: minimize the number of guard variables:
    static const struct {
        QMetaMethod readyReadSignal = QMetaMethod::fromSignal(&QBuffer::readyRead);
        QMetaMethod bytesWrittenSignal = QMetaMethod::fromSignal(&QBuffer::bytesWritten);
    } sigs;
    return signal == sigs.readyReadSignal || signal == sigs.bytesWrittenSignal;
}
/*!
    \reimp
    \internal
*/
void QBuffer::connectNotify(const QMetaMethod &signal)
{
    if (is_tracked_signal(signal))
        d_func()->signalConnectionCount++;
}
 
/*!
    \reimp
    \internal
*/
void QBuffer::disconnectNotify(const QMetaMethod &signal)
{
    if (signal.isValid()) {
        if (is_tracked_signal(signal))
            d_func()->signalConnectionCount--;
    } else {
        d_func()->signalConnectionCount = 0;
    }
}
#endif
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
# include "moc_qbuffer.cpp"
#endif