diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_resource.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_resource.c | 274 |
1 files changed, 274 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_resource.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_resource.c new file mode 100644 index 0000000..b928e0c --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_resource.c @@ -0,0 +1,274 @@ +/** + * Copyright (c) 2014 - 2018, 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 <string.h> + +#include "coap_resource.h" +#include "coap_api.h" +#include "iot_common.h" +#include "sdk_config.h" + +#define COAP_RESOURCE_MAX_AGE_INIFINITE 0xFFFFFFFF + +static coap_resource_t * mp_root_resource = NULL; +static char m_scratch_buffer[(COAP_RESOURCE_MAX_NAME_LEN + 1) * COAP_RESOURCE_MAX_DEPTH + 6]; + +#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 + +#define NULL_PARAM_CHECK(PARAM) + +#endif // COAP_DISABLE_API_PARAM_CHECK + +uint32_t coap_resource_init(void) +{ + mp_root_resource = NULL; + return NRF_SUCCESS; +} + +uint32_t coap_resource_create(coap_resource_t * p_resource, const char * name) +{ + NULL_PARAM_CHECK(p_resource); + NULL_PARAM_CHECK(name); + + if (strlen(name) > COAP_RESOURCE_MAX_NAME_LEN) + { + return (NRF_ERROR_DATA_SIZE | IOT_COAP_ERR_BASE); + } + + memcpy(p_resource->name, name, strlen(name)); + + if (mp_root_resource == NULL) + { + mp_root_resource = p_resource; + } + + p_resource->max_age = COAP_RESOURCE_MAX_AGE_INIFINITE; + + return NRF_SUCCESS; +} + +uint32_t coap_resource_child_add(coap_resource_t * p_parent, coap_resource_t * p_child) +{ + NULL_PARAM_CHECK(p_parent); + NULL_PARAM_CHECK(p_child); + + if (p_parent->child_count == 0) + { + p_parent->p_front = p_child; + p_parent->p_tail = p_child; + } + else + { + coap_resource_t * p_last_sibling = p_parent->p_tail; + p_last_sibling->p_sibling = p_child; + p_parent->p_tail = p_child; + } + + p_parent->child_count++; + + return NRF_SUCCESS; +} + +static uint32_t generate_path(uint16_t buffer_pos, coap_resource_t * p_current_resource, char * parent_path, uint8_t * string, uint16_t * length) +{ + uint32_t err_code = NRF_SUCCESS; + + if (parent_path == NULL) + { + m_scratch_buffer[buffer_pos++] = '<'; + + if (p_current_resource->p_front != NULL) + { + coap_resource_t * next_child = p_current_resource->p_front; + do + { + err_code = generate_path(buffer_pos, next_child, m_scratch_buffer, string, length); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + next_child = next_child->p_sibling; + } while (next_child != NULL); + } + } + else + { + uint16_t size = strlen(p_current_resource->name); + m_scratch_buffer[buffer_pos++] = '/'; + + memcpy(&m_scratch_buffer[buffer_pos], p_current_resource->name, size); + buffer_pos += size; + + if (p_current_resource->p_front != NULL) + { + coap_resource_t * next_child = p_current_resource->p_front; + do + { + err_code = generate_path(buffer_pos, next_child, m_scratch_buffer, string, length); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + next_child = next_child->p_sibling; + } while (next_child != NULL); + } + + m_scratch_buffer[buffer_pos++] = '>'; + + // If the resource is observable, append 'obs;' token. + if ((p_current_resource->permission & COAP_PERM_OBSERVE) > 0) + { + memcpy(&m_scratch_buffer[buffer_pos], ";obs", 4); + buffer_pos += 4; + } + + m_scratch_buffer[buffer_pos++] = ','; + + if (buffer_pos <= (*length)) + { + *length -= buffer_pos; + memcpy(&string[strlen((char *)string)], m_scratch_buffer, buffer_pos); + } + else + { + return (NRF_ERROR_DATA_SIZE | IOT_COAP_ERR_BASE); + } + } + + return err_code; +} + +uint32_t coap_resource_well_known_generate(uint8_t * string, uint16_t * length) +{ + NULL_PARAM_CHECK(string); + NULL_PARAM_CHECK(length); + + if (mp_root_resource == NULL) + { + return (NRF_ERROR_INVALID_STATE | IOT_COAP_ERR_BASE); + } + + memset(string, 0, *length); + + uint32_t err_code = generate_path(0, mp_root_resource, NULL, string, length); + + string[strlen((char *)string) - 1] = '\0'; // remove the last comma + + return err_code; +} + +static coap_resource_t * coap_resource_child_resolve(coap_resource_t * p_parent, + char * p_path) +{ + coap_resource_t * result = NULL; + if (p_parent->p_front != NULL) + { + coap_resource_t * sibling_in_question = p_parent->p_front; + + do { + // Check if the sibling name match. + size_t size = strlen(sibling_in_question->name); + if (strncmp(sibling_in_question->name, p_path, size) == 0) + { + return sibling_in_question; + } + else + { + sibling_in_question = sibling_in_question->p_sibling; + } + } while (sibling_in_question != NULL); + } + return result; +} + +uint32_t coap_resource_get(coap_resource_t ** p_resource, uint8_t ** pp_uri_pointers, uint8_t num_of_uris) +{ + if (mp_root_resource == NULL) + { + // Make sure pointer is set to NULL before returning. + *p_resource = NULL; + return (NRF_ERROR_INVALID_STATE | IOT_COAP_ERR_BASE); + } + + coap_resource_t * p_current_resource = mp_root_resource; + + // Every node should start at root. + for (uint8_t i = 0; i < num_of_uris; i++) + { + p_current_resource = coap_resource_child_resolve(p_current_resource, (char *)pp_uri_pointers[i]); + + if (p_current_resource == NULL) + { + // Stop looping as this direction will not give anything more. + break; + } + } + + if (p_current_resource != NULL) + { + *p_resource = p_current_resource; + return NRF_SUCCESS; + } + + // If nothing has been found. + *p_resource = NULL; + return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE); +} + +uint32_t coap_resource_root_get(coap_resource_t ** pp_resource) +{ + NULL_PARAM_CHECK(pp_resource); + + if (mp_root_resource == NULL) + { + return (NRF_ERROR_NOT_FOUND | IOT_COAP_ERR_BASE); + } + + *pp_resource = mp_root_resource; + + return NRF_SUCCESS; +} |