core_mqtt_serializer_private.h

Go to the documentation of this file.

/*
 * coreMQTT
 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#ifndef CORE_MQTT_SERIALIZER_PRIVATE_H
#define CORE_MQTT_SERIALIZER_PRIVATE_H
 
#include <stdint.h>
 
#include "core_mqtt_serializer.h"
 
#define MQTT_SUBSCRIPTION_ID_POS                    ( 1 )
 
#define MQTT_SESSION_EXPIRY_INTERVAL_POS            ( 2 )
 
#define MQTT_RECEIVE_MAXIMUM_POS                    ( 3 )
 
#define MQTT_MAX_PACKET_SIZE_POS                    ( 4 )
 
#define MQTT_TOPIC_ALIAS_MAX_POS                    ( 5 )
 
#define MQTT_REQUEST_RESPONSE_INFO_POS              ( 6 )
 
#define MQTT_REQUEST_PROBLEM_INFO_POS               ( 7 )
 
#define MQTT_AUTHENTICATION_METHOD_POS              ( 9 )
 
#define MQTT_AUTHENTICATION_DATA_POS                ( 10 )
 
#define MQTT_PAYLOAD_FORMAT_INDICATOR_POS           ( 11 )
 
#define MQTT_MESSAGE_EXPIRY_INTERVAL_POS            ( 12 )
 
#define MQTT_TOPIC_ALIAS_POS                        ( 13 )
 
#define MQTT_RESPONSE_TOPIC_POS                     ( 14 )
 
#define MQTT_CORRELATION_DATA_POS                   ( 15 )
 
#define MQTT_CONTENT_TYPE_POS                       ( 16 )
 
#define MQTT_REASON_STRING_POS                      ( 17 )
 
#define MQTT_WILL_DELAY_POS                         ( 18 )
 
#define MQTT_ASSIGNED_CLIENT_ID_POS                 ( 19 )
 
#define MQTT_SERVER_KEEP_ALIVE_POS                  ( 20 )
 
#define MQTT_RESPONSE_INFORMATION_POS               ( 21 )
 
#define MQTT_SERVER_REFERENCE_POS                   ( 22 )
 
#define MQTT_MAX_QOS_POS                            ( 23 )
 
#define MQTT_RETAIN_AVAILABLE_POS                   ( 24 )
 
#define MQTT_WILDCARD_SUBSCRIPTION_AVAILABLE_POS    ( 25 )
 
#define MQTT_SUBSCRIPTION_ID_AVAILABLE_POS          ( 26 )
 
#define MQTT_SHARED_SUBSCRIPTION_AVAILABLE_POS      ( 27 )
 
#define MQTT_USER_PROP_POS                          ( 28 )
 
/* MQTT CONNECT flags. */
#define MQTT_CONNECT_FLAG_CLEAN                     ( 1 )     
#define MQTT_CONNECT_FLAG_WILL                      ( 2 )     
#define MQTT_CONNECT_FLAG_WILL_QOS1                 ( 3 )     
#define MQTT_CONNECT_FLAG_WILL_QOS2                 ( 4 )     
#define MQTT_CONNECT_FLAG_WILL_RETAIN               ( 5 )     
#define MQTT_CONNECT_FLAG_PASSWORD                  ( 6 )     
#define MQTT_CONNECT_FLAG_USERNAME                  ( 7 )     
#define UINT32_DECODE( ptr )                             \
    ( uint32_t ) ( ( ( ( uint32_t ) ptr[ 0 ] ) << 24 ) | \
                   ( ( ( uint32_t ) ptr[ 1 ] ) << 16 ) | \
                   ( ( ( uint32_t ) ptr[ 2 ] ) << 8 ) |  \
                   ( ( uint32_t ) ptr[ 3 ] ) )
 
#define WRITE_UINT32( addr, val )                                  \
    {                                                              \
        ( addr )[ 3 ] = ( uint8_t ) ( ( ( val ) >> 0 ) & 0xFFU );  \
        ( addr )[ 2 ] = ( uint8_t ) ( ( ( val ) >> 8 ) & 0xFFU );  \
        ( addr )[ 1 ] = ( uint8_t ) ( ( ( val ) >> 16 ) & 0xFFU ); \
        ( addr )[ 0 ] = ( uint8_t ) ( ( ( val ) >> 24 ) & 0xFFU ); \
    }
 
#define UINT8_SET_BIT( x, position )      ( ( x ) = ( uint8_t ) ( ( x ) | ( 0x01U << ( position ) ) ) )
 
#define UINT8_CLEAR_BIT( x, position )    ( ( x ) = ( uint8_t ) ( ( x ) & ( ~( 0x01U << ( position ) ) ) ) )
 
#define UINT8_CHECK_BIT( x, position )    ( ( ( x ) & ( 0x01U << ( position ) ) ) == ( 0x01U << ( position ) ) )
 
#define UINT16_HIGH_BYTE( x )             ( ( uint8_t ) ( ( x ) >> 8 ) )
 
#define UINT16_LOW_BYTE( x )              ( ( uint8_t ) ( ( x ) & 0x00ffU ) )
 
#define UINT16_DECODE( ptr )                            \
    ( uint16_t ) ( ( ( ( uint16_t ) ptr[ 0 ] ) << 8 ) | \
                   ( ( uint16_t ) ptr[ 1 ] ) )
 
#define UINT32_SET_BIT( x, position ) \
    ( ( x ) = ( uint32_t ) ( ( x ) | ( ( uint32_t ) 0x01U << ( position ) ) ) )
 
#define UINT32_CHECK_BIT( x, position ) \
    ( ( ( uint32_t ) ( x ) & ( ( uint32_t ) 0x01U << ( position ) ) ) == ( ( uint32_t ) 0x01U << ( position ) ) )
 
#define MQTT_MAX_REMAINING_LENGTH        ( 268435455U )
 
#define MQTT_REMAINING_LENGTH_INVALID    ( ( uint32_t ) MQTT_MAX_REMAINING_LENGTH + 1U )
 
#define MQTT_MAX_PACKET_SIZE             ( MQTT_MAX_REMAINING_LENGTH + 5U )
 
#define MQTT_MAX_UTF8_STR_LENGTH         ( ( uint32_t ) 65535 )
 
#define MAX_VARIABLE_LENGTH_INT_VALUE    ( ( uint32_t ) 268435455U )
 
#if ( SIZE_MAX >= UINT32_MAX )
    #define CHECK_U32T_OVERFLOWS_SIZE_T( x )    false
#else
    #define CHECK_U32T_OVERFLOWS_SIZE_T( x )    ( ( x ) > SIZE_MAX )
#endif
 
#if ( 65535U >= SIZE_MAX )
    #define CHECK_SIZE_T_OVERFLOWS_16BIT( x )    false
#else
    #define CHECK_SIZE_T_OVERFLOWS_16BIT( x )    ( ( x ) > 65535U )
#endif
 
#if ( 0xFFFFFFFFU >= SIZE_MAX )
    #define CHECK_SIZE_T_OVERFLOWS_32BIT( x )    false
#else
    #define CHECK_SIZE_T_OVERFLOWS_32BIT( x )    ( ( x ) > 0xFFFFFFFFU )
#endif
 
#define ADDITION_WILL_OVERFLOW_U32( x, y ) \
    ( ( x ) > ( UINT32_MAX - ( y ) ) )
 
#define ADDITION_WILL_OVERFLOW_SIZE_T( x, y ) \
    ( ( x ) > ( SIZE_MAX - ( y ) ) )
 
uint32_t variableLengthEncodedSize( uint32_t length );
uint8_t * encodeString( uint8_t * pDestination,
                        const char * pSource,
                        uint16_t sourceLength );
MQTTStatus_t decodeUserProp( const char ** pPropertyKey,
                             size_t * pPropertyKeyLen,
                             const char ** pPropertyValue,
                             size_t * pPropertyValueLen,
                             uint32_t * pPropertyLength,
                             uint8_t ** pIndex );
MQTTStatus_t decodeUint32t( uint32_t * pProperty,
                            uint32_t * pPropertyLength,
                            bool * pUsed,
                            uint8_t ** pIndex );
MQTTStatus_t decodeUint16t( uint16_t * pProperty,
                            uint32_t * pPropertyLength,
                            bool * pUsed,
                            uint8_t ** pIndex );
MQTTStatus_t decodeUint8t( uint8_t * pProperty,
                           uint32_t * pPropertyLength,
                           bool * pUsed,
                           uint8_t ** pIndex );
uint8_t * encodeVariableLength( uint8_t * pDestination,
                                uint32_t length );
MQTTStatus_t decodeUtf8( const char ** pProperty,
                         size_t * pLength,
                         uint32_t * pPropertyLength,
                         bool * pUsed,
                         uint8_t ** pIndex );
MQTTStatus_t decodeVariableLength( const uint8_t * pBuffer,
                                   size_t bufferLength,
                                   uint32_t * pLength );
uint8_t * serializeAckFixed( uint8_t * pIndex,
                             uint8_t packetType,
                             uint16_t packetId,
                             uint32_t remainingLength,
                             MQTTSuccessFailReasonCode_t reasonCode );
MQTTStatus_t decodeSubackPropertyLength( const uint8_t * pIndex,
                                         uint32_t remainingLength,
                                         uint32_t * subackPropertyLength );
uint8_t * serializeDisconnectFixed( uint8_t * pIndex,
                                    const MQTTSuccessFailReasonCode_t * pReasonCode,
                                    uint32_t remainingLength );
uint8_t * serializeConnectFixedHeader( uint8_t * pIndex,
                                       const MQTTConnectInfo_t * pConnectInfo,
                                       const MQTTPublishInfo_t * pWillInfo,
                                       uint32_t remainingLength );
uint8_t * serializeSubscribeHeader( uint32_t remainingLength,
                                    uint8_t * pIndex,
                                    uint16_t packetId );
uint8_t * serializeUnsubscribeHeader( uint32_t remainingLength,
                                      uint8_t * pIndex,
                                      uint16_t packetId );
#endif /* ifndef CORE_MQTT_SERIALIZER_PRIVATE_H */