qiodevice_p.h - mozsearch

// 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:network-protocol

#ifndef QIODEVICE_P_H

#define QIODEVICE_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of QIODevice. This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "QtCore/qbytearray.h"

#include "QtCore/qiodevice.h"

#include "QtCore/qobjectdefs.h"

#include "QtCore/qstring.h"

#include "QtCore/qvarlengtharray.h"

#include "private/qringbuffer_p.h"

#ifndef QT_NO_QOBJECT

#include "private/qobject_p.h"

#else

static constexpr int QObjectPrivateVersion = QT_VERSION;

#endif

QT_BEGIN_NAMESPACE

#ifndef QIODEVICE_BUFFERSIZE

#define QIODEVICE_BUFFERSIZE 16384

#endif

Q_CORE_EXPORT int qt_subtract_from_timeout(int timeout, int elapsed);

class Q_CORE_EXPORT QIODevicePrivate

#ifndef QT_NO_QOBJECT

    : public QObjectPrivate

#endif

    Q_DECLARE_PUBLIC(QIODevice)

    Q_DISABLE_COPY_MOVE(QIODevicePrivate)

public:

    QIODevicePrivate(decltype(QObjectPrivateVersion) version = QObjectPrivateVersion);

    virtual ~QIODevicePrivate();

    enum class ReadLineOption {

        NotNullTerminated,

        NullTerminated,

};

    Q_DECLARE_FLAGS(ReadLineOptions, ReadLineOption)

    // The size of this class is a subject of the library hook data.

    // When adding a new member, do not make gaps and be aware

    // about the padding. Accordingly, adjust offsets in

    // tests/auto/other/toolsupport and bump the TypeInformationVersion

    // field in src/corelib/global/qhooks.cpp, to notify the developers.

    qint64 pos = 0;

    qint64 devicePos = 0;

    qint64 transactionPos = 0;

    class QRingBufferRef

        QRingBuffer *m_buf;

        inline QRingBufferRef() : m_buf(nullptr) { }

        friend class QIODevicePrivate;

    public:

        // wrap functions from QRingBuffer

        inline void setChunkSize(int size) { Q_ASSERT(m_buf); m_buf->setChunkSize(size); }

        inline int chunkSize() const { Q_ASSERT(m_buf); return m_buf->chunkSize(); }

        inline qint64 nextDataBlockSize() const { return (m_buf ? m_buf->nextDataBlockSize() : Q_INT64_C(0)); }

        inline const char *readPointer() const { return (m_buf ? m_buf->readPointer() : nullptr); }

        inline const char *readPointerAtPosition(qint64 pos, qint64 &length) const { Q_ASSERT(m_buf); return m_buf->readPointerAtPosition(pos, length); }

        inline void free(qint64 bytes) { Q_ASSERT(m_buf); m_buf->free(bytes); }

        inline char *reserve(qint64 bytes) { Q_ASSERT(m_buf); return m_buf->reserve(bytes); }

        inline char *reserveFront(qint64 bytes) { Q_ASSERT(m_buf); return m_buf->reserveFront(bytes); }

        inline void truncate(qint64 pos) { Q_ASSERT(m_buf); m_buf->truncate(pos); }

        inline void chop(qint64 bytes) { Q_ASSERT(m_buf); m_buf->chop(bytes); }

        inline bool isEmpty() const { return !m_buf || m_buf->isEmpty(); }

        inline int getChar() { return (m_buf ? m_buf->getChar() : -1); }

        inline void putChar(char c) { Q_ASSERT(m_buf); m_buf->putChar(c); }

        inline void ungetChar(char c) { Q_ASSERT(m_buf); m_buf->ungetChar(c); }

        inline qint64 size() const { return (m_buf ? m_buf->size() : Q_INT64_C(0)); }

        inline void clear() { if (m_buf) m_buf->clear(); }

        inline qint64 indexOf(char c) const { return (m_buf ? m_buf->indexOf(c, m_buf->size()) : Q_INT64_C(-1)); }

        inline qint64 indexOf(char c, qint64 maxLength, qint64 pos = 0) const { return (m_buf ? m_buf->indexOf(c, maxLength, pos) : Q_INT64_C(-1)); }

        inline qint64 read(char *data, qint64 maxLength) { return (m_buf ? m_buf->read(data, maxLength) : Q_INT64_C(0)); }

        inline QByteArray read() { return (m_buf ? m_buf->read() : QByteArray()); }

        inline qint64 peek(char *data, qint64 maxLength, qint64 pos = 0) const { return (m_buf ? m_buf->peek(data, maxLength, pos) : Q_INT64_C(0)); }

        inline void append(const char *data, qint64 size) { Q_ASSERT(m_buf); m_buf->append(data, size); }

        inline void append(const QByteArray &qba) { Q_ASSERT(m_buf); m_buf->append(qba); }

        inline qint64 skip(qint64 length) { return (m_buf ? m_buf->skip(length) : Q_INT64_C(0)); }

        qint64 readLine(char *data, qint64 maxLength,

                        ReadLineOptions option = ReadLineOption::NullTerminated)

            const auto appendNullByte = option & ReadLineOption::NullTerminated;

            return !m_buf         ? Q_INT64_C(-1)                    :

                   appendNullByte ? m_buf->readLine(data, maxLength) :

                                    m_buf->readLineWithoutTerminatingNull(data, maxLength);

        inline bool canReadLine() const { return m_buf && m_buf->canReadLine(); }

};

    QRingBufferRef buffer;

    QRingBufferRef writeBuffer;

    const QByteArray *currentWriteChunk = nullptr;

    int readChannelCount = 0;

    int writeChannelCount = 0;

    int currentReadChannel = 0;

    int currentWriteChannel = 0;

    int readBufferChunkSize = QIODEVICE_BUFFERSIZE;

    int writeBufferChunkSize = 0;

    QVarLengthArray<QRingBuffer, 2> readBuffers;

    QVarLengthArray<QRingBuffer, 1> writeBuffers;

    QString errorString;

    QIODevice::OpenMode openMode = QIODevice::NotOpen;

    bool transactionStarted = false;

    bool baseReadLineDataCalled = false;

    virtual bool putCharHelper(char c);

    enum AccessMode : quint8 {

        Unset,

        Sequential,

        RandomAccess

};

    mutable AccessMode accessMode = Unset;

    inline bool isSequential() const

        if (accessMode == Unset)

            accessMode = q_func()->isSequential() ? Sequential : RandomAccess;

        return accessMode == Sequential;

    inline bool isBufferEmpty() const

        return buffer.isEmpty() || (transactionStarted && isSequential()

                                    && transactionPos == buffer.size());

    bool allWriteBuffersEmpty() const;

    void seekBuffer(qint64 newPos);

    inline void setCurrentReadChannel(int channel)

        buffer.m_buf = (channel < readBuffers.size() ? &readBuffers[channel] : nullptr);

        currentReadChannel = channel;

    inline void setCurrentWriteChannel(int channel)

        writeBuffer.m_buf = (channel < writeBuffers.size() ? &writeBuffers[channel] : nullptr);

        currentWriteChannel = channel;

    void setReadChannelCount(int count);

    void setWriteChannelCount(int count);

    qint64 read(char *data, qint64 maxSize, bool peeking = false);

    qint64 readLine(char *data, qint64 maxSize,

                    ReadLineOption option = ReadLineOption::NullTerminated);

    virtual qint64 peek(char *data, qint64 maxSize);

    virtual QByteArray peek(qint64 maxSize);

    qint64 skipByReading(qint64 maxSize);

    qint64 skipLine();

    void write(const char *data, qint64 size);

    inline bool isWriteChunkCached(const char *data, qint64 size) const

        return currentWriteChunk != nullptr

               && currentWriteChunk->constData() == data

               && currentWriteChunk->size() == size;

#ifdef QT_NO_QOBJECT

    QIODevice *q_ptr = nullptr;

#endif

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QIODevicePrivate::ReadLineOptions)

QT_END_NAMESPACE

#endif // QIODEVICE_P_H

Revision control

Copy as Markdown