diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_transport_socket.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_transport_socket.c | 292 |
1 files changed, 292 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_transport_socket.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_transport_socket.c new file mode 100644 index 0000000..d19737f --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/iot/coap/coap_transport_socket.c @@ -0,0 +1,292 @@ +/** + * 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 <sys/socket.h> +#include <sys/select.h> +#include <netinet/in.h> +#ifdef UNIX +#include <fcntl.h> +#endif +#include <errno.h> +#include <stdint.h> +#include "mem_manager.h" +#include "sdk_errors.h" +#include "sdk_config.h" +#include "iot_common.h" +#include "nordic_common.h" +#include "coap_transport.h" +#include "coap.h" + +/**@brief UDP port information. */ +typedef struct +{ + int socket_fd; /**< Socket information provided by UDP. */ + uint16_t port_number; /**< Associated port number. */ +} udp_port_t; + +static udp_port_t m_port_table[COAP_PORT_COUNT]; /**< Table maintaining association between CoAP ports and corresponding UDP socket identifiers. */ + +static fd_set m_readfds; +static int m_max_sd = 0; + +/**@brief Creates port as requested in p_port. + * + * @details Creates port as requested in p_port. + * + * @param[in] index Index to the m_port_table where entry of the port created is to be made. + * @param[in] p_port Port information to be created. + * + * @retval NRF_SUCCESS Indicates if port was created successfully, else an an error code + * indicating reason for failure. + */ +static uint32_t port_create(uint32_t index, coap_port_t * p_port) +{ + // Request new socket creation. + int socket_fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + + if (socket_fd != -1) + { + // Bind the socket to the local port. + struct sockaddr_in6 sin6; + + memset(&sin6, 0, sizeof(struct sockaddr_in6)); + sin6.sin6_family = AF_INET6; + sin6.sin6_port = htons(p_port->port_number); + sin6.sin6_addr = in6addr_any; + + int retval = bind(socket_fd, (struct sockaddr *)&sin6, sizeof(sin6)); + if (retval != -1) + { + m_port_table[index].port_number = p_port->port_number; + m_port_table[index].socket_fd = socket_fd; + } + else + { + // Not all procedures succeeded with allocated socket, hence free it. + UNUSED_VARIABLE(close(socket_fd)); + return NRF_ERROR_INVALID_PARAM; + } + } + + // Configure socket to be non-blocking. + int flags = fcntl(socket_fd, F_GETFL, 0); + flags |= O_NONBLOCK; + UNUSED_VARIABLE(fcntl(m_port_table[index].socket_fd, F_SETFL, flags)); + + // Add socket to file descriptor set. + FD_SET(m_port_table[index].socket_fd, &m_readfds); + + // If enumeration is having a gap, increase the max fd count. + if (socket_fd >= m_max_sd) + { + m_max_sd = (socket_fd + 1); + } + + return NRF_SUCCESS; +} + + +uint32_t coap_transport_init(const coap_transport_init_t * p_param) +{ + uint32_t err_code = NRF_SUCCESS; + uint32_t index; + + NULL_PARAM_CHECK(p_param); + NULL_PARAM_CHECK(p_param->p_port_table); + + FD_ZERO(&m_readfds); + + err_code = nrf_mem_init(); + + if (err_code == NRF_SUCCESS) { + for (index = 0; index < COAP_PORT_COUNT; index++) + { + // Create end point for each of the COAP ports. + err_code = port_create(index, &p_param->p_port_table[index]); + if (err_code != NRF_SUCCESS) + { + break; + } + } + } + + return err_code; +} + + +uint32_t coap_transport_write(const coap_port_t * p_port, + const coap_remote_t * p_remote, + const uint8_t * p_data, + uint16_t datalen) +{ + + uint32_t err_code = NRF_ERROR_NOT_FOUND; + uint32_t index; + + NULL_PARAM_CHECK(p_port); + NULL_PARAM_CHECK(p_remote); + NULL_PARAM_CHECK(p_data); + + // Search for the corresponding port. + for (index = 0; index < COAP_PORT_COUNT; index++) + { + if (m_port_table[index].port_number == p_port->port_number) + { + COAP_MUTEX_UNLOCK(); + + static struct sockaddr_in6 dest_address_in6; + + memset(&dest_address_in6, 0, sizeof(struct sockaddr_in6)); + dest_address_in6.sin6_family = AF_INET6; + dest_address_in6.sin6_port = htons(p_remote->port_number); + + memcpy(&dest_address_in6.sin6_addr, p_remote->addr, sizeof(struct in6_addr)); + + // Send on UDP port. + int retval = sendto(m_port_table[index].socket_fd, + p_data, + datalen, + 0, + (struct sockaddr *)&dest_address_in6, + sizeof(dest_address_in6)); + if (retval == -1) + { + // Error in sendto. + err_code = NRF_ERROR_INTERNAL; + } + else + { + err_code = NRF_SUCCESS; + } + + COAP_MUTEX_LOCK(); + break; + } + } + + return err_code; +} + + +void coap_transport_process(void) +{ + return; +} + + +uint32_t coap_security_setup(uint16_t local_port, + nrf_tls_role_t role, + coap_remote_t * const p_remote, + nrf_tls_key_settings_t * const p_settings) +{ + return SDK_ERR_API_NOT_IMPLEMENTED; +} + + +uint32_t coap_security_destroy(uint16_t local_port, + coap_remote_t * const p_remote) +{ + return SDK_ERR_API_NOT_IMPLEMENTED; +} + + +void coap_transport_input(void) +{ + int retval = select(m_max_sd, &m_readfds, NULL, NULL, NULL); + + if (retval == -1) + { + // Error in select(). + // Placeholder for debugging. + } + else if (retval >= 1) // Number of file descriptiors with activity. + { + uint32_t index = 0; + int socket_fd = m_port_table[index].socket_fd; + + // The descriptor has data. + if (FD_ISSET(socket_fd, &m_readfds)) // If socket_fd is set to read. + { + static uint8_t read_mem[COAP_MESSAGE_DATA_MAX_SIZE]; + static struct sockaddr_in6 client_address_in6; + socklen_t address_length = sizeof(struct sockaddr_in6); + + int bytes_read = recvfrom(socket_fd, + read_mem, + sizeof(read_mem), + 0, + (struct sockaddr *)&client_address_in6, + (socklen_t *)&address_length); // Blocking call, waiting for incoming transaction. + if (bytes_read >= 0) + { + coap_port_t port; + port.port_number = m_port_table[index].port_number; + + coap_remote_t remote_endpoint; + memcpy(remote_endpoint.addr, &client_address_in6.sin6_addr, sizeof(struct in6_addr)); + remote_endpoint.port_number = ntohs(client_address_in6.sin6_port); + + uint32_t result = NRF_SUCCESS; + + // Notify the CoAP module of received data. + retval = coap_transport_read(&port, + &remote_endpoint, + NULL, + result, + read_mem, + (uint16_t)bytes_read); + + // Nothing much to do if CoAP could not interpret the datagram. + UNUSED_VARIABLE(retval); + } + else + { + // Error in readfrom(). + // Placeholder for debugging. + // If select() indicated this socket file descriptor to have pending + // data, this case should not occur. + } + } + } + else + { + // In case of socket() returning 0, timeout. + // Not implemented. + } +} |