/**************************************************************************** ** ** Copyright (C) 2018 Intel Corporation. ** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtCore module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 3 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL3 included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 3 requirements ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 2.0 or (at your option) the GNU General ** Public license version 3 or any later version approved by the KDE Free ** Qt Foundation. The licenses are as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-2.0.html and ** https://www.gnu.org/licenses/gpl-3.0.html. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #define CBOR_NO_ENCODER_API #define CBOR_NO_PARSER_API #include "qcborcommon_p.h" #include QT_BEGIN_NAMESPACE #include /*! \headerfile \brief The header contains definitions common to both the streaming classes (QCborStreamReader and QCborStreamWriter) and to QCborValue. */ /*! \enum QCborSimpleType \relates This enum contains the possible "Simple Types" for CBOR. Simple Types range from 0 to 255 and are types that carry no further value. The following values are currently known: \value False A "false" boolean. \value True A "true" boolean. \value Null Absence of value (null). \value Undefined Missing or deleted value, usually an error. Qt CBOR API supports encoding and decoding any Simple Type, whether one of those above or any other value. Applications should only use further values if a corresponding specification has been published, otherwise interpretation and validation by the remote may fail. Values 24 to 31 are reserved and must not be used. The current authoritative list is maintained by IANA in the \l{https://www.iana.org/assignments/cbor-simple-values/cbor-simple-values.xml}{Simple Values registry}. \sa QCborStreamWriter::append(QCborSimpleType), QCborStreamReader::isSimpleType(), QCborStreamReader::toSimpleType(), QCborValue::isSimpleType(), QCborValue::toSimpleType() */ #if !defined(QT_NO_DATASTREAM) QDataStream &operator<<(QDataStream &ds, QCborSimpleType st) { return ds << quint8(st); } QDataStream &operator>>(QDataStream &ds, QCborSimpleType &st) { quint8 v; ds >> v; st = QCborSimpleType(v); return ds; } #endif /*! \enum QCborTag \relates This enum contains no enumeration and is used only to provide type-safe access to a CBOR tag. CBOR tags are 64-bit numbers that are attached to generic CBOR types to provide further semantic meaning. QCborTag may be constructed from an enumeration found in QCborKnownTags or directly by providing the numeric representation. For example, the following creates a QCborValue containing a byte array tagged with a tag 2. \snippet code/src_corelib_serialization_qcborstream.cpp 0 \sa QCborKnownTags, QCborStreamWriter::append(QCborTag), QCborStreamReader::isTag(), QCborStreamReader::toTag(), QCborValue::isTag(), QCborValue::tag() */ /*! \enum QCborKnownTags \relates This enum contains a list of CBOR tags, known at the time of the Qt implementation. This list is not meant to be complete and contains only tags that are either backed by an RFC or specifically used by the Qt implementation. The authoritative list is maintained by IANA in the \l{https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml}{CBOR tag registry}. \value DateTimeString A date and time string, formatted according to RFC 3339, as refined by RFC 4287. It is the same format as Qt::ISODate and Qt::ISODateWithMs. \value UnixTime_t A numerical representation of seconds elapsed since 1970-01-01T00:00Z. \value PositiveBignum A positive number of arbitrary length, encoded as a byte array in network byte order. For example, the number 2\sup{64} is represented by a byte array containing the byte value 0x01 followed by 8 zero bytes. \value NegativeBignum A negative number of arbirary length, encoded as the absolute value of that number, minus one. For example, a byte array containing byte value 0x02 followed by 8 zero bytes represents the number -2\sup{65} - 1. \value Decimal A decimal fraction, encoded as an array of two integers: the first is the exponent of the power of 10, the second the integral mantissa. The value 273.15 would be encoded as array \c{[-2, 27315]}. \value Bigfloat Similar to Decimal, but the exponent is a power of 2 instead. \value COSE_Encrypt0 An \c Encrypt0 map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value COSE_Mac0 A \c Mac0 map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value COSE_Sign1 A \c Sign1 map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value ExpectedBase64url Indicates that the byte array should be encoded using Base64url if the stream is converted to JSON. \value ExpectedBase64 Indicates that the byte array should be encoded using Base64 if the stream is converted to JSON. \value ExpectedBase16 Indicates that the byte array should be encoded using Base16 (hex) if the stream is converted to JSON. \value EncodedCbor Indicates that the byte array contains a CBOR stream. \value Url Indicates that the string contains a URL. \value Base64url Indicates that the string contains data encoded using Base64url. \value Base64 Indicates that the string contains data encoded using Base64. \value RegularExpression Indicates that the string contains a Perl-Compatible Regular Expression pattern. \value MimeMessage Indicates that the string contains a MIME message (according to \l{https://tools.ietf.org/html/rfc2045}){RFC 2045}. \value Uuid Indicates that the byte array contains a UUID. \value COSE_Encrypt An \c Encrypt map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value COSE_Mac A \c Mac map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value COSE_Sign A \c Sign map as specified by \l{https://tools.ietf.org/html/rfc8152}{RFC 8152} (CBOR Object Signing and Encryption). \value Signature No change in interpretation; this tag can be used as the outermost tag in a CBOR stream as the file header. The following tags are interpreted by QCborValue during decoding and will produce objects with extended Qt types, and it will use those tags when encoding the same extended types. \value DateTimeString \l QDateTime \value UnixTime_t \l QDateTime (only in decoding) \value Url \l QUrl \value Uuid \l QUuid Additionally, if a QCborValue containing a QByteArray is tagged using one of \c ExpectedBase64url, \c ExpectedBase64 or \c ExpectedBase16, QCborValue will use the expected encoding when converting to JSON (see QCborValue::toJsonValue). \sa QCborTag, QCborStreamWriter::append(QCborTag), QCborStreamReader::isTag(), QCborStreamReader::toTag(), QCborValue::isTag(), QCborValue::tag() */ /*! \class QCborError \inmodule QtCore \relates \reentrant \since 5.12 \brief The QCborError class holds the error condition found while parsing or validating a CBOR stream. \sa QCborStreamReader, QCborValue, QCborParserError */ /*! \enum QCborError::Code This enum contains the possible error condition codes. \value NoError No error was detected. \value UnknownError An unknown error occurred and no further details are available. \value AdvancePastEnd QCborStreamReader::next() was called but there are no more elements in the current context. \value InputOutputError An I/O error with the QIODevice occurred. \value GarbageAtEnd Data was found in the input stream after the last element. \value EndOfFile The end of the input stream was unexpectedly reached while processing an element. \value UnexpectedBreak The CBOR stream contains a Break where it is not allowed (data is corrupt and the error is not recoverable). \value UnknownType The CBOR stream contains an unknown/unparseable Type (data is corrupt and the and the error is not recoverable). \value IllegalType The CBOR stream contains a known type in a position it is not allowed to exist (data is corrupt and the error is not recoverable). \value IllegalNumber The CBOR stream appears to be encoding a number larger than 64-bit (data is corrupt and the error is not recoverable). \value IllegalSimpleType The CBOR stream contains a Simple Type encoded incorrectly (data is corrupt and the error is not recoverable). \value InvalidUtf8String The CBOR stream contains a text string that does not decode properly as UTF-8 (data is corrupt and the error is not recoverable). \value DataTooLarge CBOR string, map or array is too big and cannot be parsed by Qt (internal limitation, but the error is not recoverable). \value NestingTooDeep Too many levels of arrays or maps encountered while processing the input (internal limitation, but the error is not recoverable). \value UnsupportedType The CBOR stream contains a known type that the implementation does not support (internal limitation, but the error is not recoverable). */ /*! \variable QCborError::c \internal */ /*! \fn QCborError::operator Code() const Returns the error code that this QCborError object stores. */ /*! Returns a text string that matches the error code in this QCborError object. Note: the string is not translated. Applications whose interface allow users to parse CBOR streams need to provide their own, translated strings. \sa QCborError::Code */ QString QCborError::toString() const { switch (c) { case NoError: Q_STATIC_ASSERT(int(NoError) == int(CborNoError)); return QString(); case UnknownError: Q_STATIC_ASSERT(int(UnknownError) == int(CborUnknownError)); return QStringLiteral("Unknown error"); case AdvancePastEnd: Q_STATIC_ASSERT(int(AdvancePastEnd) == int(CborErrorAdvancePastEOF)); return QStringLiteral("Read past end of buffer (more bytes needed)"); case InputOutputError: Q_STATIC_ASSERT(int(InputOutputError) == int(CborErrorIO)); return QStringLiteral("Input/Output error"); case GarbageAtEnd: Q_STATIC_ASSERT(int(GarbageAtEnd) == int(CborErrorGarbageAtEnd)); return QStringLiteral("Data found after the end of the stream"); case EndOfFile: Q_STATIC_ASSERT(int(EndOfFile) == int(CborErrorUnexpectedEOF)); return QStringLiteral("Unexpected end of input data (more bytes needed)"); case UnexpectedBreak: Q_STATIC_ASSERT(int(UnexpectedBreak) == int(CborErrorUnexpectedBreak)); return QStringLiteral("Invalid CBOR stream: unexpected 'break' byte"); case UnknownType: Q_STATIC_ASSERT(int(UnknownType) == int(CborErrorUnknownType)); return QStringLiteral("Invalid CBOR stream: unknown type"); case IllegalType: Q_STATIC_ASSERT(int(IllegalType) == int(CborErrorIllegalType)); return QStringLiteral("Invalid CBOR stream: illegal type found"); case IllegalNumber: Q_STATIC_ASSERT(int(IllegalNumber) == int(CborErrorIllegalNumber)); return QStringLiteral("Invalid CBOR stream: illegal number encoding (future extension)"); case IllegalSimpleType: Q_STATIC_ASSERT(int(IllegalSimpleType) == int(CborErrorIllegalSimpleType)); return QStringLiteral("Invalid CBOR stream: illegal simple type"); case InvalidUtf8String: Q_STATIC_ASSERT(int(InvalidUtf8String) == int(CborErrorInvalidUtf8TextString)); return QStringLiteral("Invalid CBOR stream: invalid UTF-8 text string"); case DataTooLarge: Q_STATIC_ASSERT(int(DataTooLarge) == int(CborErrorDataTooLarge)); return QStringLiteral("Internal limitation: data set too large"); case NestingTooDeep: Q_STATIC_ASSERT(int(NestingTooDeep) == int(CborErrorNestingTooDeep)); return QStringLiteral("Internal limitation: data nesting too deep"); case UnsupportedType: Q_STATIC_ASSERT(int(UnsupportedType) == int(CborErrorUnsupportedType)); return QStringLiteral("Internal limitation: unsupported type"); } // get the error string from TinyCBOR CborError err = CborError(int(c)); return QString::fromLatin1(cbor_error_string(err)); } QT_END_NAMESPACE #ifndef QT_BOOTSTRAPPED #include "moc_qcborcommon.cpp" #endif