/* * coreMQTT v1.0.1 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * 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. */ /** * @file core_mqtt_serializer.c * @brief Implements the user-facing functions in core_mqtt_serializer.h. */ #include #include #include "core_mqtt_serializer.h" /** * @brief MQTT protocol version 3.1.1. */ #define MQTT_VERSION_3_1_1 ( ( uint8_t ) 4U ) /** * @brief Size of the fixed and variable header of a CONNECT packet. */ #define MQTT_PACKET_CONNECT_HEADER_SIZE ( 10UL ) /* MQTT CONNECT flags. */ #define MQTT_CONNECT_FLAG_CLEAN ( 1 ) /**< @brief Clean session. */ #define MQTT_CONNECT_FLAG_WILL ( 2 ) /**< @brief Will present. */ #define MQTT_CONNECT_FLAG_WILL_QOS1 ( 3 ) /**< @brief Will QoS 1. */ #define MQTT_CONNECT_FLAG_WILL_QOS2 ( 4 ) /**< @brief Will QoS 2. */ #define MQTT_CONNECT_FLAG_WILL_RETAIN ( 5 ) /**< @brief Will retain. */ #define MQTT_CONNECT_FLAG_PASSWORD ( 6 ) /**< @brief Password present. */ #define MQTT_CONNECT_FLAG_USERNAME ( 7 ) /**< @brief User name present. */ /* * Positions of each flag in the first byte of an MQTT PUBLISH packet's * fixed header. */ #define MQTT_PUBLISH_FLAG_RETAIN ( 0 ) /**< @brief MQTT PUBLISH retain flag. */ #define MQTT_PUBLISH_FLAG_QOS1 ( 1 ) /**< @brief MQTT PUBLISH QoS1 flag. */ #define MQTT_PUBLISH_FLAG_QOS2 ( 2 ) /**< @brief MQTT PUBLISH QoS2 flag. */ #define MQTT_PUBLISH_FLAG_DUP ( 3 ) /**< @brief MQTT PUBLISH duplicate flag. */ /** * @brief The size of MQTT DISCONNECT packets, per MQTT spec. */ #define MQTT_DISCONNECT_PACKET_SIZE ( 2UL ) /** * @brief A PINGREQ packet is always 2 bytes in size, defined by MQTT 3.1.1 spec. */ #define MQTT_PACKET_PINGREQ_SIZE ( 2U ) /** * @brief The Remaining Length field of MQTT disconnect packets, per MQTT spec. */ #define MQTT_DISCONNECT_REMAINING_LENGTH ( ( uint8_t ) 0 ) /* * Constants relating to CONNACK packets, defined by MQTT 3.1.1 spec. */ #define MQTT_PACKET_CONNACK_REMAINING_LENGTH ( ( uint8_t ) 2U ) /**< @brief A CONNACK packet always has a "Remaining length" of 2. */ #define MQTT_PACKET_CONNACK_SESSION_PRESENT_MASK ( ( uint8_t ) 0x01U ) /**< @brief The "Session Present" bit is always the lowest bit. */ /* * UNSUBACK, PUBACK, PUBREC, PUBREL, and PUBCOMP always have a remaining length * of 2. */ #define MQTT_PACKET_SIMPLE_ACK_REMAINING_LENGTH ( ( uint8_t ) 2 ) /**< @brief PUBACK, PUBREC, PUBREl, PUBCOMP, UNSUBACK Remaining length. */ #define MQTT_PACKET_PINGRESP_REMAINING_LENGTH ( 0U ) /**< @brief A PINGRESP packet always has a "Remaining length" of 0. */ /** * @brief Per the MQTT 3.1.1 spec, the largest "Remaining Length" of an MQTT * packet is this value, 256 MB. */ #define MQTT_MAX_REMAINING_LENGTH ( 268435455UL ) /** * @brief Set a bit in an 8-bit unsigned integer. */ #define UINT8_SET_BIT( x, position ) ( ( x ) = ( uint8_t ) ( ( x ) | ( 0x01U << ( position ) ) ) ) /** * @brief Macro for checking if a bit is set in a 1-byte unsigned int. * * @param[in] x The unsigned int to check. * @param[in] position Which bit to check. */ #define UINT8_CHECK_BIT( x, position ) ( ( ( x ) & ( 0x01U << ( position ) ) ) == ( 0x01U << ( position ) ) ) /** * @brief Get the high byte of a 16-bit unsigned integer. */ #define UINT16_HIGH_BYTE( x ) ( ( uint8_t ) ( ( x ) >> 8 ) ) /** * @brief Get the low byte of a 16-bit unsigned integer. */ #define UINT16_LOW_BYTE( x ) ( ( uint8_t ) ( ( x ) & 0x00ffU ) ) /** * @brief Macro for decoding a 2-byte unsigned int from a sequence of bytes. * * @param[in] ptr A uint8_t* that points to the high byte. */ #define UINT16_DECODE( ptr ) \ ( uint16_t ) ( ( ( ( uint16_t ) ( *( ptr ) ) ) << 8 ) | \ ( ( uint16_t ) ( *( ( ptr ) + 1 ) ) ) ) /** * @brief A value that represents an invalid remaining length. * * This value is greater than what is allowed by the MQTT specification. */ #define MQTT_REMAINING_LENGTH_INVALID ( ( size_t ) 268435456 ) /** * @brief The minimum remaining length for a QoS 0 PUBLISH. * * Includes two bytes for topic name length and one byte for topic name. */ #define MQTT_MIN_PUBLISH_REMAINING_LENGTH_QOS0 ( 3U ) /*-----------------------------------------------------------*/ /** * @brief MQTT Subscription packet types. */ typedef enum MQTTSubscriptionType { MQTT_SUBSCRIBE, /**< @brief The type is a SUBSCRIBE packet. */ MQTT_UNSUBSCRIBE /**< @brief The type is a UNSUBSCRIBE packet. */ } MQTTSubscriptionType_t; /*-----------------------------------------------------------*/ /** * @brief Serializes MQTT PUBLISH packet into the buffer provided. * * This function serializes MQTT PUBLISH packet into #MQTTFixedBuffer_t.pBuffer. * Copy of the payload into the buffer is done as part of the serialization * only if @p serializePayload is true. * * @brief param[in] pPublishInfo Publish information. * @brief param[in] remainingLength Remaining length of the PUBLISH packet. * @brief param[in] packetIdentifier Packet identifier of PUBLISH packet. * @brief param[in, out] pFixedBuffer Buffer to which PUBLISH packet will be * serialized. * @brief param[in] serializePayload Copy payload to the serialized buffer * only if true. Only PUBLISH header will be serialized if false. * * @return Total number of bytes sent; -1 if there is an error. */ static void serializePublishCommon( const MQTTPublishInfo_t * pPublishInfo, size_t remainingLength, uint16_t packetIdentifier, const MQTTFixedBuffer_t * pFixedBuffer, bool serializePayload ); /** * @brief Calculates the packet size and remaining length of an MQTT * PUBLISH packet. * * @param[in] pPublishInfo MQTT PUBLISH packet parameters. * @param[out] pRemainingLength The Remaining Length of the MQTT PUBLISH packet. * @param[out] pPacketSize The total size of the MQTT PUBLISH packet. * * @return false if the packet would exceed the size allowed by the * MQTT spec; true otherwise. */ static bool calculatePublishPacketSize( const MQTTPublishInfo_t * pPublishInfo, size_t * pRemainingLength, size_t * pPacketSize ); /** * @brief Calculates the packet size and remaining length of an MQTT * SUBSCRIBE or UNSUBSCRIBE packet. * * @param[in] pSubscriptionList List of MQTT subscription info. * @param[in] subscriptionCount The number of elements in pSubscriptionList. * @param[out] pRemainingLength The Remaining Length of the MQTT SUBSCRIBE or * UNSUBSCRIBE packet. * @param[out] pPacketSize The total size of the MQTT MQTT SUBSCRIBE or * UNSUBSCRIBE packet. * @param[in] subscriptionType #MQTT_SUBSCRIBE or #MQTT_UNSUBSCRIBE. * * #MQTTBadParameter if the packet would exceed the size allowed by the * MQTT spec; #MQTTSuccess otherwise. */ static MQTTStatus_t calculateSubscriptionPacketSize( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, size_t * pRemainingLength, size_t * pPacketSize, MQTTSubscriptionType_t subscriptionType ); /** * @brief Validates parameters of #MQTT_SerializeSubscribe or * #MQTT_SerializeUnsubscribe. * * @param[in] pSubscriptionList List of MQTT subscription info. * @param[in] subscriptionCount The number of elements in pSubscriptionList. * @param[in] packetId Packet identifier. * @param[in] remainingLength Remaining length of the packet. * @param[in] pFixedBuffer Buffer for packet serialization. * * @return #MQTTNoMemory if pBuffer is too small to hold the MQTT packet; * #MQTTBadParameter if invalid parameters are passed; * #MQTTSuccess otherwise. */ static MQTTStatus_t validateSubscriptionSerializeParams( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ); /** * @brief Serialize an MQTT CONNECT packet in the given buffer. * * @param[in] pConnectInfo MQTT CONNECT packet parameters. * @param[in] pWillInfo Last Will and Testament. Pass NULL if not used. * @param[in] remainingLength Remaining Length of MQTT CONNECT packet. * @param[out] pFixedBuffer Buffer for packet serialization. */ static void serializeConnectPacket( const MQTTConnectInfo_t * pConnectInfo, const MQTTPublishInfo_t * pWillInfo, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ); /** * @brief Prints the appropriate message for the CONNACK response code if logs * are enabled. * * @param[in] responseCode MQTT standard CONNACK response code. */ static void logConnackResponse( uint8_t responseCode ); /** * @brief Encodes the remaining length of the packet using the variable length * encoding scheme provided in the MQTT v3.1.1 specification. * * @param[out] pDestination The destination buffer to store the encoded remaining * length. * @param[in] length The remaining length to encode. * * @return The location of the byte following the encoded value. */ static uint8_t * encodeRemainingLength( uint8_t * pDestination, size_t length ); /** * @brief Retrieve the size of the remaining length if it were to be encoded. * * @param[in] length The remaining length to be encoded. * * @return The size of the remaining length if it were to be encoded. */ static size_t remainingLengthEncodedSize( size_t length ); /** * @brief Encode a string whose size is at maximum 16 bits in length. * * @param[out] pDestination Destination buffer for the encoding. * @param[in] pSource The source string to encode. * @param[in] sourceLength The length of the source string to encode. * * @return A pointer to the end of the encoded string. */ static uint8_t * encodeString( uint8_t * pDestination, const char * pSource, uint16_t sourceLength ); /** * @brief Retrieves and decodes the Remaining Length from the network interface * by reading a single byte at a time. * * @param[in] recvFunc Network interface receive function. * @param[in] pNetworkContext Network interface context to the receive function. * * @return The Remaining Length of the incoming packet. */ static size_t getRemainingLength( TransportRecv_t recvFunc, NetworkContext_t * pNetworkContext ); /** * @brief Check if an incoming packet type is valid. * * @param[in] packetType The packet type to check. * * @return `true` if the packet type is valid; `false` otherwise. */ static bool incomingPacketValid( uint8_t packetType ); /** * @brief Check the remaining length of an incoming PUBLISH packet against some * value for QoS 0, or for QoS 1 and 2. * * The remaining length for a QoS 1 and 2 packet will always be two greater than * for a QoS 0. * * @param[in] remainingLength Remaining length of the PUBLISH packet. * @param[in] qos The QoS of the PUBLISH. * @param[in] qos0Minimum Minimum possible remaining length for a QoS 0 PUBLISH. * * @return #MQTTSuccess or #MQTTBadResponse. */ static MQTTStatus_t checkPublishRemainingLength( size_t remainingLength, MQTTQoS_t qos, size_t qos0Minimum ); /** * @brief Process the flags of an incoming PUBLISH packet. * * @param[in] publishFlags Flags of an incoming PUBLISH. * @param[in, out] pPublishInfo Pointer to #MQTTPublishInfo_t struct where * output will be written. * * @return #MQTTSuccess or #MQTTBadResponse. */ static MQTTStatus_t processPublishFlags( uint8_t publishFlags, MQTTPublishInfo_t * pPublishInfo ); /** * @brief Deserialize a CONNACK packet. * * Converts the packet from a stream of bytes to an #MQTTStatus_t. * * @param[in] pConnack Pointer to an MQTT packet struct representing a * CONNACK. * @param[out] pSessionPresent Whether a previous session was present. * * @return #MQTTSuccess if CONNACK specifies that CONNECT was accepted; * #MQTTServerRefused if CONNACK specifies that CONNECT was rejected; * #MQTTBadResponse if the CONNACK packet doesn't follow MQTT spec. */ static MQTTStatus_t deserializeConnack( const MQTTPacketInfo_t * pConnack, bool * pSessionPresent ); /** * @brief Decode the status bytes of a SUBACK packet to a #MQTTStatus_t. * * @param[in] statusCount Number of status bytes in the SUBACK. * @param[in] pStatusStart The first status byte in the SUBACK. * * @return #MQTTSuccess, #MQTTServerRefused, or #MQTTBadResponse. */ static MQTTStatus_t readSubackStatus( size_t statusCount, const uint8_t * pStatusStart ); /** * @brief Deserialize a SUBACK packet. * * Converts the packet from a stream of bytes to an #MQTTStatus_t and extracts * the packet identifier. * * @param[in] pSuback Pointer to an MQTT packet struct representing a SUBACK. * @param[out] pPacketIdentifier Packet ID of the SUBACK. * * @return #MQTTSuccess if SUBACK is valid; #MQTTBadResponse if SUBACK packet * doesn't follow the MQTT spec. */ static MQTTStatus_t deserializeSuback( const MQTTPacketInfo_t * pSuback, uint16_t * pPacketIdentifier ); /** * @brief Deserialize a PUBLISH packet received from the server. * * Converts the packet from a stream of bytes to an #MQTTPublishInfo_t and * extracts the packet identifier. Also prints out debug log messages about the * packet. * * @param[in] pIncomingPacket Pointer to an MQTT packet struct representing a * PUBLISH. * @param[out] pPacketId Packet identifier of the PUBLISH. * @param[out] pPublishInfo Pointer to #MQTTPublishInfo_t where output is * written. * * @return #MQTTSuccess if PUBLISH is valid; #MQTTBadResponse * if the PUBLISH packet doesn't follow MQTT spec. */ static MQTTStatus_t deserializePublish( const MQTTPacketInfo_t * pIncomingPacket, uint16_t * pPacketId, MQTTPublishInfo_t * pPublishInfo ); /** * @brief Deserialize an UNSUBACK, PUBACK, PUBREC, PUBREL, or PUBCOMP packet. * * Converts the packet from a stream of bytes to an #MQTTStatus_t and extracts * the packet identifier. * * @param[in] pAck Pointer to the MQTT packet structure representing the packet. * @param[out] pPacketIdentifier Packet ID of the ack type packet. * * @return #MQTTSuccess if UNSUBACK, PUBACK, PUBREC, PUBREL, or PUBCOMP is valid; * #MQTTBadResponse if the packet doesn't follow the MQTT spec. */ static MQTTStatus_t deserializeSimpleAck( const MQTTPacketInfo_t * pAck, uint16_t * pPacketIdentifier ); /** * @brief Deserialize a PINGRESP packet. * * Converts the packet from a stream of bytes to an #MQTTStatus_t. * * @param[in] pPingresp Pointer to an MQTT packet struct representing a PINGRESP. * * @return #MQTTSuccess if PINGRESP is valid; #MQTTBadResponse if the PINGRESP * packet doesn't follow MQTT spec. */ static MQTTStatus_t deserializePingresp( const MQTTPacketInfo_t * pPingresp ); /*-----------------------------------------------------------*/ static size_t remainingLengthEncodedSize( size_t length ) { size_t encodedSize; /* Determine how many bytes are needed to encode length. * The values below are taken from the MQTT 3.1.1 spec. */ /* 1 byte is needed to encode lengths between 0 and 127. */ if( length < 128U ) { encodedSize = 1U; } /* 2 bytes are needed to encode lengths between 128 and 16,383. */ else if( length < 16384U ) { encodedSize = 2U; } /* 3 bytes are needed to encode lengths between 16,384 and 2,097,151. */ else if( length < 2097152U ) { encodedSize = 3U; } /* 4 bytes are needed to encode lengths between 2,097,152 and 268,435,455. */ else { encodedSize = 4U; } LogDebug( ( "Encoded size for length %lu is %lu bytes.", ( unsigned long ) length, ( unsigned long ) encodedSize ) ); return encodedSize; } /*-----------------------------------------------------------*/ static uint8_t * encodeRemainingLength( uint8_t * pDestination, size_t length ) { uint8_t lengthByte; uint8_t * pLengthEnd = NULL; size_t remainingLength = length; assert( pDestination != NULL ); pLengthEnd = pDestination; /* This algorithm is copied from the MQTT v3.1.1 spec. */ do { lengthByte = ( uint8_t ) ( remainingLength % 128U ); remainingLength = remainingLength / 128U; /* Set the high bit of this byte, indicating that there's more data. */ if( remainingLength > 0U ) { UINT8_SET_BIT( lengthByte, 7 ); } /* Output a single encoded byte. */ *pLengthEnd = lengthByte; pLengthEnd++; } while( remainingLength > 0U ); return pLengthEnd; } /*-----------------------------------------------------------*/ static uint8_t * encodeString( uint8_t * pDestination, const char * pSource, uint16_t sourceLength ) { uint8_t * pBuffer = NULL; /* Typecast const char * typed source buffer to const uint8_t *. * This is to use same type buffers in memcpy. */ const uint8_t * pSourceBuffer = ( const uint8_t * ) pSource; assert( pDestination != NULL ); pBuffer = pDestination; /* The first byte of a UTF-8 string is the high byte of the string length. */ *pBuffer = UINT16_HIGH_BYTE( sourceLength ); pBuffer++; /* The second byte of a UTF-8 string is the low byte of the string length. */ *pBuffer = UINT16_LOW_BYTE( sourceLength ); pBuffer++; /* Copy the string into pBuffer. */ if( pSourceBuffer != NULL ) { ( void ) memcpy( pBuffer, pSourceBuffer, sourceLength ); } /* Return the pointer to the end of the encoded string. */ pBuffer += sourceLength; return pBuffer; } /*-----------------------------------------------------------*/ static bool calculatePublishPacketSize( const MQTTPublishInfo_t * pPublishInfo, size_t * pRemainingLength, size_t * pPacketSize ) { bool status = true; size_t packetSize = 0, payloadLimit = 0; assert( pPublishInfo != NULL ); assert( pRemainingLength != NULL ); assert( pPacketSize != NULL ); /* The variable header of a PUBLISH packet always contains the topic name. * The first 2 bytes of UTF-8 string contains length of the string. */ packetSize += pPublishInfo->topicNameLength + sizeof( uint16_t ); /* The variable header of a QoS 1 or 2 PUBLISH packet contains a 2-byte * packet identifier. */ if( pPublishInfo->qos > MQTTQoS0 ) { packetSize += sizeof( uint16_t ); } /* Calculate the maximum allowed size of the payload for the given parameters. * This calculation excludes the "Remaining length" encoding, whose size is not * yet known. */ payloadLimit = MQTT_MAX_REMAINING_LENGTH - packetSize - 1U; /* Ensure that the given payload fits within the calculated limit. */ if( pPublishInfo->payloadLength > payloadLimit ) { LogError( ( "PUBLISH payload length of %lu cannot exceed " "%lu so as not to exceed the maximum " "remaining length of MQTT 3.1.1 packet( %lu ).", ( unsigned long ) pPublishInfo->payloadLength, ( unsigned long ) payloadLimit, MQTT_MAX_REMAINING_LENGTH ) ); status = false; } else { /* Add the length of the PUBLISH payload. At this point, the "Remaining length" * has been calculated. */ packetSize += pPublishInfo->payloadLength; /* Now that the "Remaining length" is known, recalculate the payload limit * based on the size of its encoding. */ payloadLimit -= remainingLengthEncodedSize( packetSize ); /* Check that the given payload fits within the size allowed by MQTT spec. */ if( pPublishInfo->payloadLength > payloadLimit ) { LogError( ( "PUBLISH payload length of %lu cannot exceed " "%lu so as not to exceed the maximum " "remaining length of MQTT 3.1.1 packet( %lu ).", ( unsigned long ) pPublishInfo->payloadLength, ( unsigned long ) payloadLimit, MQTT_MAX_REMAINING_LENGTH ) ); status = false; } else { /* Set the "Remaining length" output parameter and calculate the full * size of the PUBLISH packet. */ *pRemainingLength = packetSize; packetSize += 1U + remainingLengthEncodedSize( packetSize ); *pPacketSize = packetSize; } } LogDebug( ( "PUBLISH packet remaining length=%lu and packet size=%lu.", ( unsigned long ) *pRemainingLength, ( unsigned long ) *pPacketSize ) ); return status; } /*-----------------------------------------------------------*/ static void serializePublishCommon( const MQTTPublishInfo_t * pPublishInfo, size_t remainingLength, uint16_t packetIdentifier, const MQTTFixedBuffer_t * pFixedBuffer, bool serializePayload ) { uint8_t * pIndex = NULL; const uint8_t * pPayloadBuffer = NULL; /* The first byte of a PUBLISH packet contains the packet type and flags. */ uint8_t publishFlags = MQTT_PACKET_TYPE_PUBLISH; assert( pPublishInfo != NULL ); assert( pFixedBuffer != NULL ); assert( pFixedBuffer->pBuffer != NULL ); /* Packet Id should be non zero for Qos 1 and Qos 2. */ assert( ( pPublishInfo->qos == MQTTQoS0 ) || ( packetIdentifier != 0U ) ); /* Duplicate flag should be set only for Qos 1 or Qos 2. */ assert( ( pPublishInfo->dup != true ) || ( pPublishInfo->qos != MQTTQoS0 ) ); /* Get the start address of the buffer. */ pIndex = pFixedBuffer->pBuffer; if( pPublishInfo->qos == MQTTQoS1 ) { LogDebug( ( "Adding QoS as QoS1 in PUBLISH flags." ) ); UINT8_SET_BIT( publishFlags, MQTT_PUBLISH_FLAG_QOS1 ); } else if( pPublishInfo->qos == MQTTQoS2 ) { LogDebug( ( "Adding QoS as QoS2 in PUBLISH flags." ) ); UINT8_SET_BIT( publishFlags, MQTT_PUBLISH_FLAG_QOS2 ); } else { /* Empty else MISRA 15.7 */ } if( pPublishInfo->retain == true ) { LogDebug( ( "Adding retain bit in PUBLISH flags." ) ); UINT8_SET_BIT( publishFlags, MQTT_PUBLISH_FLAG_RETAIN ); } if( pPublishInfo->dup == true ) { LogDebug( ( "Adding dup bit in PUBLISH flags." ) ); UINT8_SET_BIT( publishFlags, MQTT_PUBLISH_FLAG_DUP ); } *pIndex = publishFlags; pIndex++; /* The "Remaining length" is encoded from the second byte. */ pIndex = encodeRemainingLength( pIndex, remainingLength ); /* The topic name is placed after the "Remaining length". */ pIndex = encodeString( pIndex, pPublishInfo->pTopicName, pPublishInfo->topicNameLength ); /* A packet identifier is required for QoS 1 and 2 messages. */ if( pPublishInfo->qos > MQTTQoS0 ) { LogDebug( ( "Adding packet Id in PUBLISH packet." ) ); /* Place the packet identifier into the PUBLISH packet. */ *pIndex = UINT16_HIGH_BYTE( packetIdentifier ); *( pIndex + 1 ) = UINT16_LOW_BYTE( packetIdentifier ); pIndex += 2; } /* The payload is placed after the packet identifier. * Payload is copied over only if required by the flag serializePayload. * This will help reduce an unnecessary copy of the payload into the buffer. */ if( ( pPublishInfo->payloadLength > 0U ) && ( serializePayload == true ) ) { LogDebug( ( "Copying PUBLISH payload of length =%lu to buffer", ( unsigned long ) pPublishInfo->payloadLength ) ); /* Typecast const void * typed payload buffer to const uint8_t *. * This is to use same type buffers in memcpy. */ pPayloadBuffer = ( const uint8_t * ) pPublishInfo->pPayload; ( void ) memcpy( pIndex, pPayloadBuffer, pPublishInfo->payloadLength ); pIndex += pPublishInfo->payloadLength; } /* Ensure that the difference between the end and beginning of the buffer * is less than the buffer size. */ assert( ( ( size_t ) ( pIndex - pFixedBuffer->pBuffer ) ) <= pFixedBuffer->size ); } static size_t getRemainingLength( TransportRecv_t recvFunc, NetworkContext_t * pNetworkContext ) { size_t remainingLength = 0, multiplier = 1, bytesDecoded = 0, expectedSize = 0; uint8_t encodedByte = 0; int32_t bytesReceived = 0; /* This algorithm is copied from the MQTT v3.1.1 spec. */ do { if( multiplier > 2097152U ) /* 128 ^ 3 */ { remainingLength = MQTT_REMAINING_LENGTH_INVALID; } else { bytesReceived = recvFunc( pNetworkContext, &encodedByte, 1U ); if( bytesReceived == 1 ) { remainingLength += ( ( size_t ) encodedByte & 0x7FU ) * multiplier; multiplier *= 128U; bytesDecoded++; } else { remainingLength = MQTT_REMAINING_LENGTH_INVALID; } } if( remainingLength == MQTT_REMAINING_LENGTH_INVALID ) { break; } } while( ( encodedByte & 0x80U ) != 0U ); /* Check that the decoded remaining length conforms to the MQTT specification. */ if( remainingLength != MQTT_REMAINING_LENGTH_INVALID ) { expectedSize = remainingLengthEncodedSize( remainingLength ); if( bytesDecoded != expectedSize ) { remainingLength = MQTT_REMAINING_LENGTH_INVALID; } } return remainingLength; } /*-----------------------------------------------------------*/ static bool incomingPacketValid( uint8_t packetType ) { bool status = false; /* Check packet type. Mask out lower bits to ignore flags. */ switch( packetType & 0xF0U ) { /* Valid incoming packet types. */ case MQTT_PACKET_TYPE_CONNACK: case MQTT_PACKET_TYPE_PUBLISH: case MQTT_PACKET_TYPE_PUBACK: case MQTT_PACKET_TYPE_PUBREC: case MQTT_PACKET_TYPE_PUBCOMP: case MQTT_PACKET_TYPE_SUBACK: case MQTT_PACKET_TYPE_UNSUBACK: case MQTT_PACKET_TYPE_PINGRESP: status = true; break; case ( MQTT_PACKET_TYPE_PUBREL & 0xF0U ): /* The second bit of a PUBREL must be set. */ if( ( packetType & 0x02U ) > 0U ) { status = true; } break; /* Any other packet type is invalid. */ default: LogWarn( ( "Incoming packet invalid: Packet type=%u.", packetType ) ); break; } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t checkPublishRemainingLength( size_t remainingLength, MQTTQoS_t qos, size_t qos0Minimum ) { MQTTStatus_t status = MQTTSuccess; /* Sanity checks for "Remaining length". */ if( qos == MQTTQoS0 ) { /* Check that the "Remaining length" is greater than the minimum. */ if( remainingLength < qos0Minimum ) { LogDebug( ( "QoS 0 PUBLISH cannot have a remaining length less than %lu.", ( unsigned long ) qos0Minimum ) ); status = MQTTBadResponse; } } else { /* Check that the "Remaining length" is greater than the minimum. For * QoS 1 or 2, this will be two bytes greater than for QoS 0 due to the * packet identifier. */ if( remainingLength < ( qos0Minimum + 2U ) ) { LogDebug( ( "QoS 1 or 2 PUBLISH cannot have a remaining length less than %lu.", ( unsigned long ) ( qos0Minimum + 2U ) ) ); status = MQTTBadResponse; } } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t processPublishFlags( uint8_t publishFlags, MQTTPublishInfo_t * pPublishInfo ) { MQTTStatus_t status = MQTTSuccess; assert( pPublishInfo != NULL ); /* Check for QoS 2. */ if( UINT8_CHECK_BIT( publishFlags, MQTT_PUBLISH_FLAG_QOS2 ) ) { /* PUBLISH packet is invalid if both QoS 1 and QoS 2 bits are set. */ if( UINT8_CHECK_BIT( publishFlags, MQTT_PUBLISH_FLAG_QOS1 ) ) { LogDebug( ( "Bad QoS: 3." ) ); status = MQTTBadResponse; } else { pPublishInfo->qos = MQTTQoS2; } } /* Check for QoS 1. */ else if( UINT8_CHECK_BIT( publishFlags, MQTT_PUBLISH_FLAG_QOS1 ) ) { pPublishInfo->qos = MQTTQoS1; } /* If the PUBLISH isn't QoS 1 or 2, then it's QoS 0. */ else { pPublishInfo->qos = MQTTQoS0; } if( status == MQTTSuccess ) { LogDebug( ( "QoS is %d.", pPublishInfo->qos ) ); /* Parse the Retain bit. */ pPublishInfo->retain = ( UINT8_CHECK_BIT( publishFlags, MQTT_PUBLISH_FLAG_RETAIN ) ) ? true : false; LogDebug( ( "Retain bit is %d.", pPublishInfo->retain ) ); /* Parse the DUP bit. */ pPublishInfo->dup = ( UINT8_CHECK_BIT( publishFlags, MQTT_PUBLISH_FLAG_DUP ) ) ? true : false; LogDebug( ( "DUP bit is %d.", pPublishInfo->dup ) ); } return status; } /*-----------------------------------------------------------*/ static void logConnackResponse( uint8_t responseCode ) { const char * const pConnackResponses[ 6 ] = { "Connection accepted.", /* 0 */ "Connection refused: unacceptable protocol version.", /* 1 */ "Connection refused: identifier rejected.", /* 2 */ "Connection refused: server unavailable", /* 3 */ "Connection refused: bad user name or password.", /* 4 */ "Connection refused: not authorized." /* 5 */ }; /* Avoid unused parameter warning when assert and logs are disabled. */ ( void ) responseCode; ( void ) pConnackResponses; assert( responseCode <= 5 ); if( responseCode == 0u ) { /* Log at Info level for a success CONNACK response. */ LogInfo( ( "%s", pConnackResponses[ 0 ] ) ); } else { /* Log an error based on the CONNACK response code. */ LogError( ( "%s", pConnackResponses[ responseCode ] ) ); } } /*-----------------------------------------------------------*/ static MQTTStatus_t deserializeConnack( const MQTTPacketInfo_t * pConnack, bool * pSessionPresent ) { MQTTStatus_t status = MQTTSuccess; const uint8_t * pRemainingData = NULL; assert( pConnack != NULL ); assert( pSessionPresent != NULL ); pRemainingData = pConnack->pRemainingData; /* According to MQTT 3.1.1, the second byte of CONNACK must specify a * "Remaining length" of 2. */ if( pConnack->remainingLength != MQTT_PACKET_CONNACK_REMAINING_LENGTH ) { LogError( ( "CONNACK does not have remaining length of %d.", MQTT_PACKET_CONNACK_REMAINING_LENGTH ) ); status = MQTTBadResponse; } /* Check the reserved bits in CONNACK. The high 7 bits of the second byte * in CONNACK must be 0. */ else if( ( pRemainingData[ 0 ] | 0x01U ) != 0x01U ) { LogError( ( "Reserved bits in CONNACK incorrect." ) ); status = MQTTBadResponse; } else { /* Determine if the "Session Present" bit is set. This is the lowest bit of * the second byte in CONNACK. */ if( ( pRemainingData[ 0 ] & MQTT_PACKET_CONNACK_SESSION_PRESENT_MASK ) == MQTT_PACKET_CONNACK_SESSION_PRESENT_MASK ) { LogInfo( ( "CONNACK session present bit set." ) ); *pSessionPresent = true; /* MQTT 3.1.1 specifies that the fourth byte in CONNACK must be 0 if the * "Session Present" bit is set. */ if( pRemainingData[ 1 ] != 0U ) { status = MQTTBadResponse; } } else { LogInfo( ( "CONNACK session present bit not set." ) ); *pSessionPresent = false; } } if( status == MQTTSuccess ) { /* In MQTT 3.1.1, only values 0 through 5 are valid CONNACK response codes. */ if( pRemainingData[ 1 ] > 5U ) { LogError( ( "CONNACK response %u is invalid.", pRemainingData[ 1 ] ) ); status = MQTTBadResponse; } else { /* Print the appropriate message for the CONNACK response code if logs are * enabled. */ logConnackResponse( pRemainingData[ 1 ] ); /* A nonzero CONNACK response code means the connection was refused. */ if( pRemainingData[ 1 ] == 5U ) { status = MQTTNotAuthorized; } else if( pRemainingData[ 1 ] > 0U ) { status = MQTTServerRefused; } } } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t calculateSubscriptionPacketSize( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, size_t * pRemainingLength, size_t * pPacketSize, MQTTSubscriptionType_t subscriptionType ) { MQTTStatus_t status = MQTTSuccess; size_t i = 0, packetSize = 0; assert( pSubscriptionList != NULL ); assert( subscriptionCount != 0U ); assert( pRemainingLength != NULL ); assert( pPacketSize != NULL ); /* The variable header of a subscription packet consists of a 2-byte packet * identifier. */ packetSize += sizeof( uint16_t ); /* Sum the lengths of all subscription topic filters; add 1 byte for each * subscription's QoS if type is MQTT_SUBSCRIBE. */ for( i = 0; i < subscriptionCount; i++ ) { /* Add the length of the topic filter. MQTT strings are prepended * with 2 byte string length field. Hence 2 bytes are added to size. */ packetSize += pSubscriptionList[ i ].topicFilterLength + sizeof( uint16_t ); /* Only SUBSCRIBE packets include the QoS. */ if( subscriptionType == MQTT_SUBSCRIBE ) { packetSize += 1U; } } /* At this point, the "Remaining length" has been calculated. Return error * if the "Remaining length" exceeds what is allowed by MQTT 3.1.1. Otherwise, * set the output parameter.*/ if( packetSize > MQTT_MAX_REMAINING_LENGTH ) { LogError( ( "Subscription packet length of %lu exceeds" "the MQTT 3.1.1 maximum packet length of %lu.", ( unsigned long ) packetSize, MQTT_MAX_REMAINING_LENGTH ) ); status = MQTTBadParameter; } else { *pRemainingLength = packetSize; /* Calculate the full size of the subscription packet by adding * number of bytes required to encode the "Remaining length" field * plus 1 byte for the "Packet type" field. */ packetSize += 1U + remainingLengthEncodedSize( packetSize ); /*Set the pPacketSize output parameter. */ *pPacketSize = packetSize; } LogDebug( ( "Subscription packet remaining length=%lu and packet size=%lu.", ( unsigned long ) *pRemainingLength, ( unsigned long ) *pPacketSize ) ); return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t readSubackStatus( size_t statusCount, const uint8_t * pStatusStart ) { MQTTStatus_t status = MQTTSuccess; uint8_t subscriptionStatus = 0; size_t i = 0; assert( pStatusStart != NULL ); /* Iterate through each status byte in the SUBACK packet. */ for( i = 0; i < statusCount; i++ ) { /* Read a single status byte in SUBACK. */ subscriptionStatus = pStatusStart[ i ]; /* MQTT 3.1.1 defines the following values as status codes. */ switch( subscriptionStatus ) { case 0x00: case 0x01: case 0x02: LogDebug( ( "Topic filter %lu accepted, max QoS %u.", ( unsigned long ) i, subscriptionStatus ) ); break; case 0x80: LogWarn( ( "Topic filter %lu refused.", ( unsigned long ) i ) ); /* Application should remove subscription from the list */ status = MQTTServerRefused; break; default: LogDebug( ( "Bad SUBSCRIBE status %u.", subscriptionStatus ) ); status = MQTTBadResponse; break; } /* Stop parsing the subscription statuses if a bad response was received. */ if( status == MQTTBadResponse ) { break; } } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t deserializeSuback( const MQTTPacketInfo_t * pSuback, uint16_t * pPacketIdentifier ) { MQTTStatus_t status = MQTTSuccess; size_t remainingLength; const uint8_t * pVariableHeader = NULL; assert( pSuback != NULL ); assert( pPacketIdentifier != NULL ); remainingLength = pSuback->remainingLength; pVariableHeader = pSuback->pRemainingData; /* A SUBACK must have a remaining length of at least 3 to accommodate the * packet identifier and at least 1 return code. */ if( remainingLength < 3U ) { LogDebug( ( "SUBACK cannot have a remaining length less than 3." ) ); status = MQTTBadResponse; } else { /* Extract the packet identifier (first 2 bytes of variable header) from SUBACK. */ *pPacketIdentifier = UINT16_DECODE( pVariableHeader ); LogDebug( ( "Packet identifier %hu.", *pPacketIdentifier ) ); status = readSubackStatus( remainingLength - sizeof( uint16_t ), pVariableHeader + sizeof( uint16_t ) ); } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t validateSubscriptionSerializeParams( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; size_t packetSize = 0; /* Validate all the parameters. */ if( ( pFixedBuffer == NULL ) || ( pSubscriptionList == NULL ) ) { LogError( ( "Argument cannot be NULL: pFixedBuffer=%p, " "pSubscriptionList=%p.", ( void * ) pFixedBuffer, ( void * ) pSubscriptionList ) ); status = MQTTBadParameter; } /* A buffer must be configured for serialization. */ else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "Argument cannot be NULL: pFixedBuffer->pBuffer is NULL." ) ); status = MQTTBadParameter; } else if( subscriptionCount == 0U ) { LogError( ( "Subscription count is 0." ) ); status = MQTTBadParameter; } else if( packetId == 0U ) { LogError( ( "Packet Id for subscription packet is 0." ) ); status = MQTTBadParameter; } else { /* The serialized packet size = First byte * + length of encoded size of remaining length * + remaining length. */ packetSize = 1U + remainingLengthEncodedSize( remainingLength ) + remainingLength; if( packetSize > pFixedBuffer->size ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized packet of size of %lu.", ( unsigned long ) pFixedBuffer->size, ( unsigned long ) packetSize ) ); status = MQTTNoMemory; } } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t deserializePublish( const MQTTPacketInfo_t * pIncomingPacket, uint16_t * pPacketId, MQTTPublishInfo_t * pPublishInfo ) { MQTTStatus_t status = MQTTSuccess; const uint8_t * pVariableHeader, * pPacketIdentifierHigh = NULL; assert( pIncomingPacket != NULL ); assert( pPacketId != NULL ); assert( pPublishInfo != NULL ); assert( pIncomingPacket->pRemainingData != NULL ); pVariableHeader = pIncomingPacket->pRemainingData; /* The flags are the lower 4 bits of the first byte in PUBLISH. */ status = processPublishFlags( ( pIncomingPacket->type & 0x0FU ), pPublishInfo ); if( status == MQTTSuccess ) { /* Sanity checks for "Remaining length". A QoS 0 PUBLISH must have a remaining * length of at least 3 to accommodate topic name length (2 bytes) and topic * name (at least 1 byte). A QoS 1 or 2 PUBLISH must have a remaining length of * at least 5 for the packet identifier in addition to the topic name length and * topic name. */ status = checkPublishRemainingLength( pIncomingPacket->remainingLength, pPublishInfo->qos, MQTT_MIN_PUBLISH_REMAINING_LENGTH_QOS0 ); } if( status == MQTTSuccess ) { /* Extract the topic name starting from the first byte of the variable header. * The topic name string starts at byte 3 in the variable header. */ pPublishInfo->topicNameLength = UINT16_DECODE( pVariableHeader ); /* Sanity checks for topic name length and "Remaining length". The remaining * length must be at least as large as the variable length header. */ status = checkPublishRemainingLength( pIncomingPacket->remainingLength, pPublishInfo->qos, pPublishInfo->topicNameLength + sizeof( uint16_t ) ); } if( status == MQTTSuccess ) { /* Parse the topic. */ pPublishInfo->pTopicName = ( const char * ) ( pVariableHeader + sizeof( uint16_t ) ); LogDebug( ( "Topic name length %hu: %.*s", pPublishInfo->topicNameLength, pPublishInfo->topicNameLength, pPublishInfo->pTopicName ) ); /* Extract the packet identifier for QoS 1 or 2 PUBLISH packets. Packet * identifier starts immediately after the topic name. */ pPacketIdentifierHigh = ( const uint8_t * ) ( pPublishInfo->pTopicName + pPublishInfo->topicNameLength ); if( pPublishInfo->qos > MQTTQoS0 ) { *pPacketId = UINT16_DECODE( pPacketIdentifierHigh ); LogDebug( ( "Packet identifier %hu.", *pPacketId ) ); /* Advance pointer two bytes to start of payload as in the QoS 0 case. */ pPacketIdentifierHigh += sizeof( uint16_t ); /* Packet identifier cannot be 0. */ if( *pPacketId == 0U ) { status = MQTTBadResponse; } } } if( status == MQTTSuccess ) { /* Calculate the length of the payload. QoS 1 or 2 PUBLISH packets contain * a packet identifier, but QoS 0 PUBLISH packets do not. */ pPublishInfo->payloadLength = pIncomingPacket->remainingLength - pPublishInfo->topicNameLength - sizeof( uint16_t ); if( pPublishInfo->qos != MQTTQoS0 ) { /* Two more bytes for the packet identifier. */ pPublishInfo->payloadLength -= sizeof( uint16_t ); } /* Set payload if it exists. */ pPublishInfo->pPayload = ( pPublishInfo->payloadLength != 0U ) ? pPacketIdentifierHigh : NULL; LogDebug( ( "Payload length %lu.", ( unsigned long ) pPublishInfo->payloadLength ) ); } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t deserializeSimpleAck( const MQTTPacketInfo_t * pAck, uint16_t * pPacketIdentifier ) { MQTTStatus_t status = MQTTSuccess; assert( pAck != NULL ); assert( pPacketIdentifier != NULL ); /* Check that the "Remaining length" of the received ACK is 2. */ if( pAck->remainingLength != MQTT_PACKET_SIMPLE_ACK_REMAINING_LENGTH ) { LogError( ( "ACK does not have remaining length of %d.", MQTT_PACKET_SIMPLE_ACK_REMAINING_LENGTH ) ); status = MQTTBadResponse; } else { /* Extract the packet identifier (third and fourth bytes) from ACK. */ *pPacketIdentifier = UINT16_DECODE( pAck->pRemainingData ); LogDebug( ( "Packet identifier %hu.", *pPacketIdentifier ) ); /* Packet identifier cannot be 0. */ if( *pPacketIdentifier == 0U ) { status = MQTTBadResponse; } } return status; } /*-----------------------------------------------------------*/ static MQTTStatus_t deserializePingresp( const MQTTPacketInfo_t * pPingresp ) { MQTTStatus_t status = MQTTSuccess; assert( pPingresp != NULL ); /* Check the "Remaining length" (second byte) of the received PINGRESP is 0. */ if( pPingresp->remainingLength != MQTT_PACKET_PINGRESP_REMAINING_LENGTH ) { LogError( ( "PINGRESP does not have remaining length of %d.", MQTT_PACKET_PINGRESP_REMAINING_LENGTH ) ); status = MQTTBadResponse; } return status; } /*-----------------------------------------------------------*/ static void serializeConnectPacket( const MQTTConnectInfo_t * pConnectInfo, const MQTTPublishInfo_t * pWillInfo, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { uint8_t connectFlags = 0U; uint8_t * pIndex = NULL; assert( pConnectInfo != NULL ); assert( pFixedBuffer != NULL ); assert( pFixedBuffer->pBuffer != NULL ); pIndex = pFixedBuffer->pBuffer; /* The first byte in the CONNECT packet is the control packet type. */ *pIndex = MQTT_PACKET_TYPE_CONNECT; pIndex++; /* The remaining length of the CONNECT packet is encoded starting from the * second byte. The remaining length does not include the length of the fixed * header or the encoding of the remaining length. */ pIndex = encodeRemainingLength( pIndex, remainingLength ); /* The string "MQTT" is placed at the beginning of the CONNECT packet's variable * header. This string is 4 bytes long. */ pIndex = encodeString( pIndex, "MQTT", 4 ); /* The MQTT protocol version is the second field of the variable header. */ *pIndex = MQTT_VERSION_3_1_1; pIndex++; /* Set the clean session flag if needed. */ if( pConnectInfo->cleanSession == true ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_CLEAN ); } /* Set the flags for username and password if provided. */ if( pConnectInfo->pUserName != NULL ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_USERNAME ); } if( pConnectInfo->pPassword != NULL ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_PASSWORD ); } /* Set will flag if a Last Will and Testament is provided. */ if( pWillInfo != NULL ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_WILL ); /* Flags only need to be changed for Will QoS 1 or 2. */ if( pWillInfo->qos == MQTTQoS1 ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_WILL_QOS1 ); } else if( pWillInfo->qos == MQTTQoS2 ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_WILL_QOS2 ); } else { /* Empty else MISRA 15.7 */ } if( pWillInfo->retain == true ) { UINT8_SET_BIT( connectFlags, MQTT_CONNECT_FLAG_WILL_RETAIN ); } } *pIndex = connectFlags; pIndex++; /* Write the 2 bytes of the keep alive interval into the CONNECT packet. */ *pIndex = UINT16_HIGH_BYTE( pConnectInfo->keepAliveSeconds ); *( pIndex + 1 ) = UINT16_LOW_BYTE( pConnectInfo->keepAliveSeconds ); pIndex += 2; /* Write the client identifier into the CONNECT packet. */ pIndex = encodeString( pIndex, pConnectInfo->pClientIdentifier, pConnectInfo->clientIdentifierLength ); /* Write the will topic name and message into the CONNECT packet if provided. */ if( pWillInfo != NULL ) { pIndex = encodeString( pIndex, pWillInfo->pTopicName, pWillInfo->topicNameLength ); pIndex = encodeString( pIndex, pWillInfo->pPayload, ( uint16_t ) pWillInfo->payloadLength ); } /* Encode the user name if provided. */ if( pConnectInfo->pUserName != NULL ) { pIndex = encodeString( pIndex, pConnectInfo->pUserName, pConnectInfo->userNameLength ); } /* Encode the password if provided. */ if( pConnectInfo->pPassword != NULL ) { pIndex = encodeString( pIndex, pConnectInfo->pPassword, pConnectInfo->passwordLength ); } LogDebug( ( "Length of serialized CONNECT packet is %lu.", ( ( unsigned long ) ( pIndex - pFixedBuffer->pBuffer ) ) ) ); /* Ensure that the difference between the end and beginning of the buffer * is less than the buffer size. */ assert( ( ( size_t ) ( pIndex - pFixedBuffer->pBuffer ) ) <= pFixedBuffer->size ); } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetConnectPacketSize( const MQTTConnectInfo_t * pConnectInfo, const MQTTPublishInfo_t * pWillInfo, size_t * pRemainingLength, size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; size_t remainingLength; /* The CONNECT packet will always include a 10-byte variable header. */ size_t connectPacketSize = MQTT_PACKET_CONNECT_HEADER_SIZE; /* Validate arguments. */ if( ( pConnectInfo == NULL ) || ( pRemainingLength == NULL ) || ( pPacketSize == NULL ) ) { LogError( ( "Argument cannot be NULL: pConnectInfo=%p, " "pRemainingLength=%p, pPacketSize=%p.", ( void * ) pConnectInfo, ( void * ) pRemainingLength, ( void * ) pPacketSize ) ); status = MQTTBadParameter; } else if( ( pConnectInfo->clientIdentifierLength == 0U ) || ( pConnectInfo->pClientIdentifier == NULL ) ) { LogError( ( "Mqtt_GetConnectPacketSize() client identifier must be set." ) ); status = MQTTBadParameter; } else if( ( pWillInfo != NULL ) && ( pWillInfo->payloadLength > ( size_t ) UINT16_MAX ) ) { /* The MQTTPublishInfo_t is reused for the will message. The payload * length for any other message could be larger than 65,535, but * the will message length is required to be represented in 2 bytes. * By bounding the payloadLength of the will message, the CONNECT * packet will never be larger than 327699 bytes. */ LogError( ( "The Will Message length must not exceed %d. " "pWillInfo->payloadLength=%lu.", UINT16_MAX, ( unsigned long ) pWillInfo->payloadLength ) ); status = MQTTBadParameter; } else { /* Add the length of the client identifier. */ connectPacketSize += pConnectInfo->clientIdentifierLength + sizeof( uint16_t ); /* Add the lengths of the will message and topic name if provided. */ if( pWillInfo != NULL ) { connectPacketSize += pWillInfo->topicNameLength + sizeof( uint16_t ) + pWillInfo->payloadLength + sizeof( uint16_t ); } /* Add the lengths of the user name and password if provided. */ if( pConnectInfo->pUserName != NULL ) { connectPacketSize += pConnectInfo->userNameLength + sizeof( uint16_t ); } if( pConnectInfo->pPassword != NULL ) { connectPacketSize += pConnectInfo->passwordLength + sizeof( uint16_t ); } /* At this point, the "Remaining Length" field of the MQTT CONNECT packet has * been calculated. */ remainingLength = connectPacketSize; /* Calculate the full size of the MQTT CONNECT packet by adding the size of * the "Remaining Length" field plus 1 byte for the "Packet Type" field. */ connectPacketSize += 1U + remainingLengthEncodedSize( connectPacketSize ); /* The connectPacketSize calculated from this function's parameters is * guaranteed to be less than the maximum MQTT CONNECT packet size, which * is 327700. If the maximum client identifier length, the maximum will * message topic length, the maximum will topic payload length, the * maximum username length, and the maximum password length are all present * in the MQTT CONNECT packet, the total size will be calculated to be * 327699: * (variable length header)10 + * (maximum client identifier length) 65535 + (encoded length) 2 + * (maximum will message topic name length) 65535 + (encoded length)2 + * (maximum will message payload length) 65535 + 2 + * (maximum username length) 65535 + (encoded length) 2 + * (maximum password length) 65535 + (encoded length) 2 + * (packet type field length) 1 + * (CONNECT packet encoded length) 3 = 327699 */ *pRemainingLength = remainingLength; *pPacketSize = connectPacketSize; LogDebug( ( "CONNECT packet remaining length=%lu and packet size=%lu.", ( unsigned long ) *pRemainingLength, ( unsigned long ) *pPacketSize ) ); } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializeConnect( const MQTTConnectInfo_t * pConnectInfo, const MQTTPublishInfo_t * pWillInfo, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; size_t connectPacketSize = 0; /* Validate arguments. */ if( ( pConnectInfo == NULL ) || ( pFixedBuffer == NULL ) ) { LogError( ( "Argument cannot be NULL: pConnectInfo=%p, " "pFixedBuffer=%p.", ( void * ) pConnectInfo, ( void * ) pFixedBuffer ) ); status = MQTTBadParameter; } /* A buffer must be configured for serialization. */ else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "Argument cannot be NULL: pFixedBuffer->pBuffer is NULL." ) ); status = MQTTBadParameter; } else if( ( pWillInfo != NULL ) && ( pWillInfo->pTopicName == NULL ) ) { LogError( ( "pWillInfo->pTopicName cannot be NULL if Will is present." ) ); status = MQTTBadParameter; } else { /* Calculate CONNECT packet size. Overflow in in this addition is not checked * because it is part of the API contract to call Mqtt_GetConnectPacketSize() * before this function. */ connectPacketSize = remainingLength + remainingLengthEncodedSize( remainingLength ) + 1U; /* Check that the full packet size fits within the given buffer. */ if( connectPacketSize > pFixedBuffer->size ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized CONNECT packet of size of %lu.", ( unsigned long ) pFixedBuffer->size, ( unsigned long ) connectPacketSize ) ); status = MQTTNoMemory; } else { serializeConnectPacket( pConnectInfo, pWillInfo, remainingLength, pFixedBuffer ); } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetSubscribePacketSize( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, size_t * pRemainingLength, size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; /* Validate parameters. */ if( ( pSubscriptionList == NULL ) || ( pRemainingLength == NULL ) || ( pPacketSize == NULL ) ) { LogError( ( "Argument cannot be NULL: pSubscriptionList=%p, " "pRemainingLength=%p, pPacketSize=%p.", ( void * ) pSubscriptionList, ( void * ) pRemainingLength, ( void * ) pPacketSize ) ); status = MQTTBadParameter; } else if( subscriptionCount == 0U ) { LogError( ( "subscriptionCount is 0." ) ); status = MQTTBadParameter; } else { /* Calculate the MQTT UNSUBSCRIBE packet size. */ status = calculateSubscriptionPacketSize( pSubscriptionList, subscriptionCount, pRemainingLength, pPacketSize, MQTT_SUBSCRIBE ); if( status == MQTTBadParameter ) { LogError( ( "SUBSCRIBE packet remaining length exceeds %lu, which is the " "maximum size allowed by MQTT 3.1.1.", MQTT_MAX_REMAINING_LENGTH ) ); } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializeSubscribe( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { size_t i = 0; uint8_t * pIndex = NULL; /* Validate all the parameters. */ MQTTStatus_t status = validateSubscriptionSerializeParams( pSubscriptionList, subscriptionCount, packetId, remainingLength, pFixedBuffer ); if( status == MQTTSuccess ) { pIndex = pFixedBuffer->pBuffer; /* The first byte in SUBSCRIBE is the packet type. */ *pIndex = MQTT_PACKET_TYPE_SUBSCRIBE; pIndex++; /* Encode the "Remaining length" starting from the second byte. */ pIndex = encodeRemainingLength( pIndex, remainingLength ); /* Place the packet identifier into the SUBSCRIBE packet. */ *pIndex = UINT16_HIGH_BYTE( packetId ); *( pIndex + 1 ) = UINT16_LOW_BYTE( packetId ); pIndex += 2; /* Serialize each subscription topic filter and QoS. */ for( i = 0; i < subscriptionCount; i++ ) { pIndex = encodeString( pIndex, pSubscriptionList[ i ].pTopicFilter, pSubscriptionList[ i ].topicFilterLength ); /* Place the QoS in the SUBSCRIBE packet. */ *pIndex = ( uint8_t ) ( pSubscriptionList[ i ].qos ); pIndex++; } LogDebug( ( "Length of serialized SUBSCRIBE packet is %lu.", ( ( unsigned long ) ( pIndex - pFixedBuffer->pBuffer ) ) ) ); } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetUnsubscribePacketSize( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, size_t * pRemainingLength, size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; /* Validate parameters. */ if( ( pSubscriptionList == NULL ) || ( pRemainingLength == NULL ) || ( pPacketSize == NULL ) ) { LogError( ( "Argument cannot be NULL: pSubscriptionList=%p, " "pRemainingLength=%p, pPacketSize=%p.", ( void * ) pSubscriptionList, ( void * ) pRemainingLength, ( void * ) pPacketSize ) ); status = MQTTBadParameter; } else if( subscriptionCount == 0U ) { LogError( ( "Subscription count is 0." ) ); status = MQTTBadParameter; } else { /* Calculate the MQTT SUBSCRIBE packet size. */ status = calculateSubscriptionPacketSize( pSubscriptionList, subscriptionCount, pRemainingLength, pPacketSize, MQTT_UNSUBSCRIBE ); if( status == MQTTBadParameter ) { LogError( ( "UNSUBSCRIBE packet remaining length exceeds %lu, which is the " "maximum size allowed by MQTT 3.1.1.", MQTT_MAX_REMAINING_LENGTH ) ); } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializeUnsubscribe( const MQTTSubscribeInfo_t * pSubscriptionList, size_t subscriptionCount, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; size_t i = 0; uint8_t * pIndex = NULL; /* Validate all the parameters. */ status = validateSubscriptionSerializeParams( pSubscriptionList, subscriptionCount, packetId, remainingLength, pFixedBuffer ); if( status == MQTTSuccess ) { /* Get the start of the buffer to the iterator variable. */ pIndex = pFixedBuffer->pBuffer; /* The first byte in UNSUBSCRIBE is the packet type. */ *pIndex = MQTT_PACKET_TYPE_UNSUBSCRIBE; pIndex++; /* Encode the "Remaining length" starting from the second byte. */ pIndex = encodeRemainingLength( pIndex, remainingLength ); /* Place the packet identifier into the UNSUBSCRIBE packet. */ *pIndex = UINT16_HIGH_BYTE( packetId ); *( pIndex + 1 ) = UINT16_LOW_BYTE( packetId ); pIndex += 2; /* Serialize each subscription topic filter. */ for( i = 0; i < subscriptionCount; i++ ) { pIndex = encodeString( pIndex, pSubscriptionList[ i ].pTopicFilter, pSubscriptionList[ i ].topicFilterLength ); } LogDebug( ( "Length of serialized UNSUBSCRIBE packet is %lu.", ( ( unsigned long ) ( pIndex - pFixedBuffer->pBuffer ) ) ) ); } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetPublishPacketSize( const MQTTPublishInfo_t * pPublishInfo, size_t * pRemainingLength, size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; if( ( pPublishInfo == NULL ) || ( pRemainingLength == NULL ) || ( pPacketSize == NULL ) ) { LogError( ( "Argument cannot be NULL: pPublishInfo=%p, " "pRemainingLength=%p, pPacketSize=%p.", ( void * ) pPublishInfo, ( void * ) pRemainingLength, ( void * ) pPacketSize ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->pTopicName == NULL ) || ( pPublishInfo->topicNameLength == 0U ) ) { LogError( ( "Invalid topic name for PUBLISH: pTopicName=%p, " "topicNameLength=%u.", pPublishInfo->pTopicName, pPublishInfo->topicNameLength ) ); status = MQTTBadParameter; } else { /* Calculate the "Remaining length" field and total packet size. If it exceeds * what is allowed in the MQTT standard, return an error. */ if( calculatePublishPacketSize( pPublishInfo, pRemainingLength, pPacketSize ) == false ) { LogError( ( "PUBLISH packet remaining length exceeds %lu, which is the " "maximum size allowed by MQTT 3.1.1.", MQTT_MAX_REMAINING_LENGTH ) ); status = MQTTBadParameter; } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializePublish( const MQTTPublishInfo_t * pPublishInfo, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; size_t packetSize = 0; if( ( pFixedBuffer == NULL ) || ( pPublishInfo == NULL ) ) { LogError( ( "Argument cannot be NULL: pFixedBuffer=%p, " "pPublishInfo=%p.", ( void * ) pFixedBuffer, ( void * ) pPublishInfo ) ); status = MQTTBadParameter; } /* A buffer must be configured for serialization. */ else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "Argument cannot be NULL: pFixedBuffer->pBuffer is NULL." ) ); status = MQTTBadParameter; } /* For serializing a publish, if there exists a payload, then the buffer * cannot be NULL. */ else if( ( pPublishInfo->payloadLength > 0U ) && ( pPublishInfo->pPayload == NULL ) ) { LogError( ( "A nonzero payload length requires a non-NULL payload: " "payloadLength=%lu, pPayload=%p.", ( unsigned long ) pPublishInfo->payloadLength, pPublishInfo->pPayload ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->pTopicName == NULL ) || ( pPublishInfo->topicNameLength == 0U ) ) { LogError( ( "Invalid topic name for PUBLISH: pTopicName=%p, " "topicNameLength=%u.", pPublishInfo->pTopicName, pPublishInfo->topicNameLength ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->qos != MQTTQoS0 ) && ( packetId == 0U ) ) { LogError( ( "Packet ID is 0 for PUBLISH with QoS=%u.", pPublishInfo->qos ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->dup == true ) && ( pPublishInfo->qos == MQTTQoS0 ) ) { LogError( ( "Duplicate flag is set for PUBLISH with Qos 0," ) ); status = MQTTBadParameter; } else { /* Length of serialized packet = First byte * + Length of encoded remaining length * + Remaining length. */ packetSize = 1U + remainingLengthEncodedSize( remainingLength ) + remainingLength; } if( ( status == MQTTSuccess ) && ( packetSize > pFixedBuffer->size ) ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized PUBLISH packet of size of %lu.", ( unsigned long ) pFixedBuffer->size, ( unsigned long ) packetSize ) ); status = MQTTNoMemory; } if( status == MQTTSuccess ) { /* Serialize publish with header and payload. */ serializePublishCommon( pPublishInfo, remainingLength, packetId, pFixedBuffer, true ); } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializePublishHeader( const MQTTPublishInfo_t * pPublishInfo, uint16_t packetId, size_t remainingLength, const MQTTFixedBuffer_t * pFixedBuffer, size_t * pHeaderSize ) { MQTTStatus_t status = MQTTSuccess; size_t packetSize = 0; if( ( pFixedBuffer == NULL ) || ( pPublishInfo == NULL ) || ( pHeaderSize == NULL ) ) { LogError( ( "Argument cannot be NULL: pFixedBuffer=%p, " "pPublishInfo=%p, pHeaderSize=%p.", ( void * ) pFixedBuffer, ( void * ) pPublishInfo, ( void * ) pHeaderSize ) ); status = MQTTBadParameter; } /* A buffer must be configured for serialization. */ else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "Argument cannot be NULL: pFixedBuffer->pBuffer is NULL." ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->pTopicName == NULL ) || ( pPublishInfo->topicNameLength == 0U ) ) { LogError( ( "Invalid topic name for publish: pTopicName=%p, " "topicNameLength=%u.", pPublishInfo->pTopicName, pPublishInfo->topicNameLength ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->qos != MQTTQoS0 ) && ( packetId == 0U ) ) { LogError( ( "Packet Id is 0 for publish with QoS=%u.", pPublishInfo->qos ) ); status = MQTTBadParameter; } else if( ( pPublishInfo->dup == true ) && ( pPublishInfo->qos == MQTTQoS0 ) ) { LogError( ( "Duplicate flag is set for PUBLISH with Qos 0," ) ); status = MQTTBadParameter; } else { /* Length of serialized packet = First byte * + Length of encoded remaining length * + Remaining length * - Payload Length. */ packetSize = 1U + remainingLengthEncodedSize( remainingLength ) + remainingLength - pPublishInfo->payloadLength; } if( ( status == MQTTSuccess ) && ( packetSize > pFixedBuffer->size ) ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized PUBLISH header packet of size of %lu.", ( unsigned long ) pFixedBuffer->size, ( unsigned long ) ( packetSize - pPublishInfo->payloadLength ) ) ); status = MQTTNoMemory; } if( status == MQTTSuccess ) { /* Serialize publish without copying the payload. */ serializePublishCommon( pPublishInfo, remainingLength, packetId, pFixedBuffer, false ); /* Header size is the same as calculated packet size. */ *pHeaderSize = packetSize; } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializeAck( const MQTTFixedBuffer_t * pFixedBuffer, uint8_t packetType, uint16_t packetId ) { MQTTStatus_t status = MQTTSuccess; if( pFixedBuffer == NULL ) { LogError( ( "Provided buffer is NULL." ) ); status = MQTTBadParameter; } else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "pFixedBuffer->pBuffer cannot be NULL." ) ); status = MQTTBadParameter; } /* The buffer must be able to fit 4 bytes for the packet. */ else if( pFixedBuffer->size < MQTT_PUBLISH_ACK_PACKET_SIZE ) { LogError( ( "Insufficient memory for packet." ) ); status = MQTTNoMemory; } else if( packetId == 0U ) { LogError( ( "Packet ID cannot be 0." ) ); status = MQTTBadParameter; } else { switch( packetType ) { /* Only publish acks are serialized by the client. */ case MQTT_PACKET_TYPE_PUBACK: case MQTT_PACKET_TYPE_PUBREC: case MQTT_PACKET_TYPE_PUBREL: case MQTT_PACKET_TYPE_PUBCOMP: pFixedBuffer->pBuffer[ 0 ] = packetType; pFixedBuffer->pBuffer[ 1 ] = MQTT_PACKET_SIMPLE_ACK_REMAINING_LENGTH; pFixedBuffer->pBuffer[ 2 ] = UINT16_HIGH_BYTE( packetId ); pFixedBuffer->pBuffer[ 3 ] = UINT16_LOW_BYTE( packetId ); break; default: LogError( ( "Packet type is not a publish ACK: Packet type=%02x", packetType ) ); status = MQTTBadParameter; break; } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetDisconnectPacketSize( size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; if( pPacketSize == NULL ) { LogError( ( "pPacketSize is NULL." ) ); status = MQTTBadParameter; } else { /* MQTT DISCONNECT packets always have the same size. */ *pPacketSize = MQTT_DISCONNECT_PACKET_SIZE; } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializeDisconnect( const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; /* Validate arguments. */ if( pFixedBuffer == NULL ) { LogError( ( "pFixedBuffer cannot be NULL." ) ); status = MQTTBadParameter; } else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "pFixedBuffer->pBuffer cannot be NULL." ) ); status = MQTTBadParameter; } else { /* Empty else MISRA 15.7 */ } if( status == MQTTSuccess ) { if( pFixedBuffer->size < MQTT_DISCONNECT_PACKET_SIZE ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized DISCONNECT packet of size of %lu.", ( unsigned long ) pFixedBuffer->size, MQTT_DISCONNECT_PACKET_SIZE ) ); status = MQTTNoMemory; } } if( status == MQTTSuccess ) { pFixedBuffer->pBuffer[ 0 ] = MQTT_PACKET_TYPE_DISCONNECT; pFixedBuffer->pBuffer[ 1 ] = MQTT_DISCONNECT_REMAINING_LENGTH; } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetPingreqPacketSize( size_t * pPacketSize ) { MQTTStatus_t status = MQTTSuccess; if( pPacketSize == NULL ) { LogError( ( "pPacketSize is NULL." ) ); status = MQTTBadParameter; } else { /* MQTT PINGREQ packets always have the same size. */ *pPacketSize = MQTT_PACKET_PINGREQ_SIZE; } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_SerializePingreq( const MQTTFixedBuffer_t * pFixedBuffer ) { MQTTStatus_t status = MQTTSuccess; if( pFixedBuffer == NULL ) { LogError( ( "pFixedBuffer is NULL." ) ); status = MQTTBadParameter; } else if( pFixedBuffer->pBuffer == NULL ) { LogError( ( "pFixedBuffer->pBuffer cannot be NULL." ) ); status = MQTTBadParameter; } else { /* Empty else MISRA 15.7 */ } if( status == MQTTSuccess ) { if( pFixedBuffer->size < MQTT_PACKET_PINGREQ_SIZE ) { LogError( ( "Buffer size of %lu is not sufficient to hold " "serialized PINGREQ packet of size of %u.", ( unsigned long ) pFixedBuffer->size, MQTT_PACKET_PINGREQ_SIZE ) ); status = MQTTNoMemory; } } if( status == MQTTSuccess ) { /* Ping request packets are always the same. */ pFixedBuffer->pBuffer[ 0 ] = MQTT_PACKET_TYPE_PINGREQ; pFixedBuffer->pBuffer[ 1 ] = 0x00; } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_DeserializePublish( const MQTTPacketInfo_t * pIncomingPacket, uint16_t * pPacketId, MQTTPublishInfo_t * pPublishInfo ) { MQTTStatus_t status = MQTTSuccess; if( ( pIncomingPacket == NULL ) || ( pPacketId == NULL ) || ( pPublishInfo == NULL ) ) { LogError( ( "Argument cannot be NULL: pIncomingPacket=%p, " "pPacketId=%p, pPublishInfo=%p", ( void * ) pIncomingPacket, ( void * ) pPacketId, ( void * ) pPublishInfo ) ); status = MQTTBadParameter; } else if( ( pIncomingPacket->type & 0xF0U ) != MQTT_PACKET_TYPE_PUBLISH ) { LogError( ( "Packet is not publish. Packet type: %02x.", pIncomingPacket->type ) ); status = MQTTBadParameter; } else if( pIncomingPacket->pRemainingData == NULL ) { LogError( ( "Argument cannot be NULL: " "pIncomingPacket->pRemainingData is NULL." ) ); status = MQTTBadParameter; } else { status = deserializePublish( pIncomingPacket, pPacketId, pPublishInfo ); } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_DeserializeAck( const MQTTPacketInfo_t * pIncomingPacket, uint16_t * pPacketId, bool * pSessionPresent ) { MQTTStatus_t status = MQTTSuccess; if( pIncomingPacket == NULL ) { LogError( ( "pIncomingPacket cannot be NULL." ) ); status = MQTTBadParameter; } /* Pointer for packet identifier cannot be NULL for packets other than * CONNACK and PINGRESP. */ else if( ( pPacketId == NULL ) && ( ( pIncomingPacket->type != MQTT_PACKET_TYPE_CONNACK ) && ( pIncomingPacket->type != MQTT_PACKET_TYPE_PINGRESP ) ) ) { LogError( ( "pPacketId cannot be NULL for packet type %02x.", pIncomingPacket->type ) ); status = MQTTBadParameter; } /* Pointer for session present cannot be NULL for CONNACK. */ else if( ( pSessionPresent == NULL ) && ( pIncomingPacket->type == MQTT_PACKET_TYPE_CONNACK ) ) { LogError( ( "pSessionPresent cannot be NULL for CONNACK packet." ) ); status = MQTTBadParameter; } /* Pointer for remaining data cannot be NULL for packets other * than PINGRESP. */ else if( ( pIncomingPacket->pRemainingData == NULL ) && ( pIncomingPacket->type != MQTT_PACKET_TYPE_PINGRESP ) ) { LogError( ( "Remaining data of incoming packet is NULL." ) ); status = MQTTBadParameter; } else { /* Make sure response packet is a valid ack. */ switch( pIncomingPacket->type ) { case MQTT_PACKET_TYPE_CONNACK: status = deserializeConnack( pIncomingPacket, pSessionPresent ); break; case MQTT_PACKET_TYPE_SUBACK: status = deserializeSuback( pIncomingPacket, pPacketId ); break; case MQTT_PACKET_TYPE_PINGRESP: status = deserializePingresp( pIncomingPacket ); break; case MQTT_PACKET_TYPE_UNSUBACK: case MQTT_PACKET_TYPE_PUBACK: case MQTT_PACKET_TYPE_PUBREC: case MQTT_PACKET_TYPE_PUBREL: case MQTT_PACKET_TYPE_PUBCOMP: status = deserializeSimpleAck( pIncomingPacket, pPacketId ); break; /* Any other packet type is invalid. */ default: LogError( ( "IotMqtt_DeserializeResponse() called with unknown packet type:(%02x).", pIncomingPacket->type ) ); status = MQTTBadResponse; break; } } return status; } /*-----------------------------------------------------------*/ MQTTStatus_t MQTT_GetIncomingPacketTypeAndLength( TransportRecv_t readFunc, NetworkContext_t * pNetworkContext, MQTTPacketInfo_t * pIncomingPacket ) { MQTTStatus_t status = MQTTSuccess; int32_t bytesReceived = 0; if( pIncomingPacket == NULL ) { LogError( ( "Invalid parameter: pIncomingPacket is NULL." ) ); status = MQTTBadParameter; } else { /* Read a single byte. */ bytesReceived = readFunc( pNetworkContext, &( pIncomingPacket->type ), 1U ); } if( bytesReceived == 1 ) { /* Check validity. */ if( incomingPacketValid( pIncomingPacket->type ) == true ) { pIncomingPacket->remainingLength = getRemainingLength( readFunc, pNetworkContext ); if( pIncomingPacket->remainingLength == MQTT_REMAINING_LENGTH_INVALID ) { status = MQTTBadResponse; } } else { LogError( ( "Incoming packet invalid: Packet type=%u.", pIncomingPacket->type ) ); status = MQTTBadResponse; } } else if( ( status != MQTTBadParameter ) && ( bytesReceived == 0 ) ) { LogDebug( ( "No data was received from the transport." ) ); status = MQTTNoDataAvailable; } /* If the input packet was valid, then any other number of bytes received is * a failure. */ else if( status != MQTTBadParameter ) { LogError( ( "A single byte was not read from the transport: " "transportStatus=%d.", bytesReceived ) ); status = MQTTRecvFailed; } else { /* Empty else MISRA 15.7 */ } return status; } /*-----------------------------------------------------------*/