204 lines
8.1 KiB
C
204 lines
8.1 KiB
C
/**
|
|
* Copyright (c) 2015 - 2019, Nordic Semiconductor ASA
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form, except as embedded into a Nordic
|
|
* Semiconductor ASA integrated circuit in a product or a software update for
|
|
* such product, must reproduce the above copyright notice, this list of
|
|
* conditions and the following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* 4. This software, with or without modification, must only be used with a
|
|
* Nordic Semiconductor ASA integrated circuit.
|
|
*
|
|
* 5. Any software provided in binary form under this license must not be reverse
|
|
* engineered, decompiled, modified and/or disassembled.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
|
|
#include "coap_block.h"
|
|
#include "nrf_error.h"
|
|
#include "iot_errors.h"
|
|
#include "sdk_config.h"
|
|
|
|
|
|
/**
|
|
* @defgroup api_param_check API Parameters check macros.
|
|
*
|
|
* @details Macros that verify parameters passed to the module in the APIs. These macros
|
|
* could be mapped to nothing in final versions of code to save execution and size.
|
|
* COAP_DISABLE_API_PARAM_CHECK should be defined to disable these checks.
|
|
*
|
|
* @{
|
|
*/
|
|
#if (COAP_DISABLE_API_PARAM_CHECK == 0)
|
|
|
|
/**@brief Verify NULL parameters are not passed to API by application. */
|
|
#define NULL_PARAM_CHECK(PARAM) \
|
|
if ((PARAM) == NULL) \
|
|
{ \
|
|
return (NRF_ERROR_NULL | IOT_COAP_ERR_BASE); \
|
|
}
|
|
#else // COAP_DISABLE_API_PARAM_CHECK
|
|
|
|
#define NULL_PARAM_CHECK(PARAM)
|
|
|
|
#endif // COAP_DISABLE_API_PARAM_CHECK
|
|
/** @} */
|
|
|
|
|
|
#define BLOCK_SIZE_BASE_CONSTANT 4 /**< Block size base exponent. 4 means a base block size of 2^4 = 16 bytes. */
|
|
|
|
#define BLOCK_SIZE_16 0 /**< Block size of 2^(4+0) = 16 bytes. */
|
|
#define BLOCK_SIZE_32 1 /**< Block size of 2^(4+1) = 32 bytes. */
|
|
#define BLOCK_SIZE_64 2 /**< Block size of 2^(4+2) = 64 bytes. */
|
|
#define BLOCK_SIZE_128 3 /**< Block size of 2^(4+3) = 128 bytes. */
|
|
#define BLOCK_SIZE_256 4 /**< Block size of 2^(4+4) = 256 bytes. */
|
|
#define BLOCK_SIZE_512 5 /**< Block size of 2^(4+5) = 512 bytes. */
|
|
#define BLOCK_SIZE_1024 6 /**< Block size of 2^(4+6) = 1024 bytes. */
|
|
#define BLOCK_SIZE_2048_RESERVED 7 /**< Reserved. */
|
|
|
|
#define BLOCK_MORE_BIT_UNSET 0 /**< Value when more flag is set. */
|
|
#define BLOCK_MORE_BIT_SET 1 /**< Value when more flag is not set. */
|
|
|
|
#define BLOCK_SIZE_POS 0 /**< Bit offset to the size. */
|
|
#define BLOCK_MORE_BIT_POS 3 /**< Bit offset to the more bit. */
|
|
#define BLOCK_NUMBER_POS 4 /**< Bit offset to the block number. */
|
|
|
|
#define BLOCK_SIZE_MASK 0x7 /**< Block size mask. */
|
|
#define BLOCK_MORE_BIT_MASK (1 << BLOCK_MORE_BIT_POS) /**< More bit mask. */
|
|
#define BLOCK_NUMBER_MASK (0xFFFFF << 4) /**< Block number mask. */
|
|
|
|
#define BLOCK_SIZE_MAX 0x7 /**< Maximum block size number. */
|
|
#define BLOCK_MORE_BIT_MAX BLOCK_MORE_BIT_SET /**< Maximum more bit value. */
|
|
#define BLOCK_NUMBER_MAX 0xFFFFF /**< Maximum block number. 20 bits max value is (1 << 20) - 1. */
|
|
|
|
static uint32_t block_opt_encode(uint8_t more,
|
|
uint16_t size,
|
|
uint32_t number,
|
|
uint32_t * p_encoded)
|
|
{
|
|
if ((number > BLOCK_NUMBER_MAX) || (more > BLOCK_MORE_BIT_MAX))
|
|
{
|
|
return (NRF_ERROR_INVALID_PARAM | IOT_COAP_ERR_BASE);
|
|
}
|
|
|
|
uint32_t val = 0;
|
|
|
|
switch (size)
|
|
{
|
|
case 16:
|
|
val = BLOCK_SIZE_16;
|
|
break;
|
|
|
|
case 32:
|
|
val = BLOCK_SIZE_32;
|
|
break;
|
|
|
|
case 64:
|
|
val = BLOCK_SIZE_64;
|
|
break;
|
|
|
|
case 128:
|
|
val = BLOCK_SIZE_128;
|
|
break;
|
|
|
|
case 256:
|
|
val = BLOCK_SIZE_256;
|
|
break;
|
|
|
|
case 512:
|
|
val = BLOCK_SIZE_512;
|
|
break;
|
|
|
|
case 1024:
|
|
val = BLOCK_SIZE_1024;
|
|
break;
|
|
|
|
case 2048:
|
|
// Falltrough.
|
|
default:
|
|
// Break omitted.
|
|
return (NRF_ERROR_INVALID_PARAM | IOT_COAP_ERR_BASE);
|
|
}
|
|
|
|
// Value has been initialized.
|
|
val |= (more) << BLOCK_MORE_BIT_POS;
|
|
val |= (number) << BLOCK_NUMBER_POS;
|
|
|
|
*p_encoded = val;
|
|
return NRF_SUCCESS;
|
|
}
|
|
|
|
static uint32_t block_opt_decode(uint32_t encoded,
|
|
uint8_t * p_more,
|
|
uint16_t * p_size,
|
|
uint32_t * p_number)
|
|
{
|
|
if ((encoded & BLOCK_SIZE_MASK) == BLOCK_SIZE_2048_RESERVED)
|
|
{
|
|
return (NRF_ERROR_INVALID_DATA | IOT_COAP_ERR_BASE);
|
|
}
|
|
|
|
if ((encoded >> BLOCK_NUMBER_POS) > BLOCK_NUMBER_MAX)
|
|
{
|
|
return (NRF_ERROR_INVALID_PARAM | IOT_COAP_ERR_BASE);
|
|
}
|
|
|
|
*p_size = (1 << ((BLOCK_SIZE_BASE_CONSTANT + (encoded & BLOCK_SIZE_MASK))));
|
|
*p_more = (encoded & BLOCK_MORE_BIT_MASK) >> BLOCK_MORE_BIT_POS;
|
|
*p_number = (encoded & BLOCK_NUMBER_MASK) >> BLOCK_NUMBER_POS;
|
|
|
|
return NRF_SUCCESS;
|
|
}
|
|
|
|
uint32_t coap_block_opt_block1_encode(uint32_t * p_encoded, coap_block_opt_block1_t * p_opt)
|
|
{
|
|
NULL_PARAM_CHECK(p_encoded);
|
|
NULL_PARAM_CHECK(p_opt);
|
|
return block_opt_encode(p_opt->more, p_opt->size, p_opt->number, p_encoded);
|
|
}
|
|
|
|
uint32_t coap_block_opt_block1_decode(coap_block_opt_block1_t * p_opt, uint32_t encoded)
|
|
{
|
|
NULL_PARAM_CHECK(p_opt);
|
|
return block_opt_decode(encoded, &p_opt->more, &p_opt->size, &p_opt->number);
|
|
}
|
|
|
|
uint32_t coap_block_opt_block2_encode(uint32_t * p_encoded, coap_block_opt_block2_t * p_opt)
|
|
{
|
|
NULL_PARAM_CHECK(p_encoded);
|
|
NULL_PARAM_CHECK(p_opt);
|
|
return block_opt_encode(p_opt->more, p_opt->size, p_opt->number, p_encoded);
|
|
}
|
|
|
|
uint32_t coap_block_opt_block2_decode(coap_block_opt_block2_t * p_opt, uint32_t encoded)
|
|
{
|
|
NULL_PARAM_CHECK(p_opt);
|
|
return block_opt_decode(encoded, &p_opt->more, &p_opt->size, &p_opt->number);
|
|
}
|