RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity
63ac792b8b
RIOT/sys/net/sock/sock_util.c
Benjamin Valentin 46764727ab sys/net/sock_util: add sock_dtls_establish_session()
2023-02-08 15:57:22 +01:00

436 lines
11 KiB
C
Raw Blame History

/*
* Copyright (C) 2017 Kaspar Schleiser <kaspar@schleiser.de>
* 2018 Freie Universität Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @ingroup net_sock_util
* @{
*
* @file
* @brief sock utility functions implementation
*
* @author Kaspar Schleiser <kaspar@schleiser.de>
* @author Hauke Petersen <hauke.petersen@fu-berlin.de>
* @}
*/
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "net/sock/udp.h"
#include "net/sock/util.h"
#include "net/iana/portrange.h"
#if defined(MODULE_DNS)
#include "net/dns.h"
#endif
#ifdef MODULE_RANDOM
#include "random.h"
#endif
#ifdef MODULE_FMT
#include "fmt.h"
#endif
#define ENABLE_DEBUG 0
#include "debug.h"
#define PORT_STR_LEN (5)
#define NETIF_STR_LEN (5)
int sock_tl_ep_fmt(const struct _sock_tl_ep *endpoint,
char *addr_str, uint16_t *port)
{
const void *addr_ptr;
*addr_str = '\0';
switch (endpoint->family) {
#ifdef SOCK_HAS_IPV4
case AF_INET:
addr_ptr = &endpoint->addr.ipv4;
break;
#endif
#ifdef SOCK_HAS_IPV6
case AF_INET6:
addr_ptr = &endpoint->addr.ipv6;
break;
#endif
default:
return -ENOTSUP;
}
if (!inet_ntop(endpoint->family, addr_ptr, addr_str, INET6_ADDRSTRLEN)) {
return 0;
}
if (IS_ACTIVE(SOCK_HAS_IPV6) && (endpoint->family == AF_INET6) && endpoint->netif) {
#ifdef MODULE_FMT
char *tmp = addr_str + strlen(addr_str);
*tmp++ = '%';
tmp += fmt_u16_dec(tmp, endpoint->netif);
*tmp = '\0';
#else
sprintf(addr_str + strlen(addr_str), "%%%4u", endpoint->netif);
#endif
}
if (port) {
*port = endpoint->port;
}
return strlen(addr_str);
}
static char* _find_hoststart(const char *url)
{
/* Increment CONFIG_SOCK_SCHEME_MAXLEN due to comparison with the colon after the
* scheme part
*/
size_t remaining = CONFIG_SOCK_SCHEME_MAXLEN + 1;
char *urlpos = (char*)url;
while (*urlpos && remaining) {
remaining--;
if (*urlpos++ == ':') {
if (strncmp(urlpos, "//", 2) == 0) {
return urlpos + 2;
}
break;
}
}
return NULL;
}
static char* _find_pathstart(const char *url)
{
size_t remaining = CONFIG_SOCK_HOSTPORT_MAXLEN;
char *urlpos = (char*)url;
while (*urlpos && remaining) {
remaining--;
if (*urlpos == '/') {
return urlpos;
}
urlpos++;
}
return urlpos;
}
int sock_urlsplit(const char *url, char *hostport, char *urlpath)
{
assert(url);
char *hoststart = _find_hoststart(url);
if (!hoststart) {
return -EINVAL;
}
char *pathstart = _find_pathstart(hoststart);
if (hostport) {
size_t hostlen = pathstart - hoststart;
/* hostlen must be smaller CONFIG_SOCK_HOSTPORT_MAXLEN to have space for the null
* terminator */
if (hostlen > CONFIG_SOCK_HOSTPORT_MAXLEN - 1) {
return -EOVERFLOW;
}
memcpy(hostport, hoststart, hostlen);
hostport[hostlen] = '\0';
}
if (urlpath) {
size_t pathlen = strlen(pathstart);
if (pathlen > CONFIG_SOCK_URLPATH_MAXLEN - 1) {
return -EOVERFLOW;
}
memcpy(urlpath, pathstart, pathlen);
urlpath[pathlen] = '\0';
}
return 0;
}
const char *sock_urlpath(const char *url)
{
assert(url);
char *hoststart = _find_hoststart(url);
if (!hoststart) {
return NULL;
}
return _find_pathstart(hoststart);
}
int _parse_port(sock_udp_ep_t *ep_out, const char *portstart)
{
int port_len = strlen(portstart);
/* Checks here verify that the supplied port number is up to 5 (random)
* chars in size and result is smaller or equal to UINT16_MAX. */
if (port_len > PORT_STR_LEN) {
return -EINVAL;
}
uint32_t port = atol(portstart);
if (port > UINT16_MAX) {
return -EINVAL;
}
ep_out->port = (uint16_t)port;
return port_len;
}
int _parse_netif(sock_udp_ep_t *ep_out, char *netifstart)
{
char *netifend;
size_t netiflen;
char netifbuf[NETIF_STR_LEN + 1] = {0};
for (netifend = netifstart; *netifend && *netifend != ']';
netifend++) {}
netiflen = netifend - netifstart;
if (!*netifend || (netiflen >= NETIF_STR_LEN) || (netiflen == 0)) {
/* no netif found, bail out */
return -EINVAL;
}
strncpy(netifbuf, netifstart, netiflen);
int netif = strtol(netifbuf, NULL, 10);
if ((netif < 0) || (((unsigned)netif) > UINT16_MAX)) {
return -EINVAL;
}
ep_out->netif = (uint16_t)netif;
return (netifend - netifstart);
}
int sock_tl_str2ep(struct _sock_tl_ep *ep_out, const char *str)
{
unsigned brackets_flag;
char *hoststart = (char*)str;
char *hostend;
char hostbuf[CONFIG_SOCK_HOSTPORT_MAXLEN];
memset(ep_out, 0, sizeof(sock_udp_ep_t));
if (*hoststart == '[') {
brackets_flag = 1;
for (hostend = ++hoststart;
*hostend && *hostend != ']' && *hostend != '%';
hostend++) {}
if (! *hostend || ((size_t)(hostend - hoststart) >= sizeof(hostbuf))) {
/* none found, bail out */
return -EINVAL;
}
}
else {
brackets_flag = 0;
for (hostend = hoststart; *hostend && (*hostend != ':') && \
((size_t)(hostend - hoststart) < sizeof(hostbuf)); hostend++) {}
}
size_t hostlen = hostend - hoststart;
if (*(hostend + brackets_flag) == ':') {
int res = _parse_port(ep_out, hostend + brackets_flag + 1);
if (res < 0) {
return res;
}
}
else if (brackets_flag && (*hostend == '%')) {
int res = _parse_netif(ep_out, hostend + 1);
if (res < 0) {
return res;
}
char *colon_ptr = hostend + res + brackets_flag + 1;
if ((*colon_ptr == ':') &&
((res = _parse_port(ep_out, colon_ptr + 1)) < 0)) {
return res;
}
}
if (hostlen >= sizeof(hostbuf)) {
return -EINVAL;
}
memcpy(hostbuf, hoststart, hostlen);
hostbuf[hostlen] = '\0';
if (!brackets_flag) {
#ifdef SOCK_HAS_IPV4
if (inet_pton(AF_INET, hostbuf, &ep_out->addr.ipv4) == 1) {
ep_out->family = AF_INET;
return 0;
}
#endif
}
#ifdef SOCK_HAS_IPV6
if (inet_pton(AF_INET6, hostbuf, ep_out->addr.ipv6) == 1) {
ep_out->family = AF_INET6;
return 0;
}
#endif
return -EINVAL;
}
int sock_tl_name2ep(struct _sock_tl_ep *ep_out, const char *str)
{
int res = sock_tl_str2ep(ep_out, str);
if (res == 0) {
return 0;
}
#if defined(MODULE_SOCK_DNS) || defined(MODULE_SOCK_DNS_MOCK)
int family;
char hostbuf[CONFIG_SOCK_HOSTPORT_MAXLEN];
const char *host;
char *hostend = strchr(str, ':');
if (hostend == NULL) {
host = str;
ep_out->port = 0;
} else {
size_t host_len = hostend - str;
if (host_len >= sizeof(hostbuf)) {
return -EINVAL;
}
memcpy(hostbuf, str, host_len);
hostbuf[host_len] = 0;
host = hostbuf;
ep_out->port = atoi(hostend + 1);;
}
if (IS_ACTIVE(SOCK_HAS_IPV4) && IS_ACTIVE(SOCK_HAS_IPV6)) {
family = AF_UNSPEC;
} else if (IS_ACTIVE(SOCK_HAS_IPV4)) {
family = AF_INET;
} else if (IS_ACTIVE(SOCK_HAS_IPV6)) {
family = AF_INET6;
} else {
assert(0);
return -EINVAL;
}
switch (dns_query(host, &ep_out->addr, family)) {
#ifdef SOCK_HAS_IPV4
case 4:
ep_out->family = AF_INET;
return 0;
#endif
#ifdef SOCK_HAS_IPV6
case 16:
ep_out->family = AF_INET6;
return 0;
#endif
default:
return -EINVAL;
}
#endif
return res;
}
bool sock_tl_ep_equal(const struct _sock_tl_ep *a,
const struct _sock_tl_ep *b)
{
assert(a && b);
/* compare family and port */
if ((a->family != b->family) || (a->port != b->port)) {
return false;
}
/* compare addresses */
switch (a->family) {
#ifdef SOCK_HAS_IPV4
case AF_INET:
return memcmp(a->addr.ipv4, b->addr.ipv4, 4) == 0;
#endif
#ifdef SOCK_HAS_IPV6
case AF_INET6:
return memcmp(a->addr.ipv6, b->addr.ipv6, 16) == 0;
#endif
default:
return false;
}
}
#if defined(MODULE_SOCK_DTLS)
int sock_dtls_establish_session(sock_udp_t *sock_udp, sock_dtls_t *sock_dtls,
sock_dtls_session_t *session, credman_tag_t tag,
sock_udp_ep_t *local, const sock_udp_ep_t *remote,
void *work_buf, size_t work_buf_len)
{
int res;
uint32_t timeout_ms = CONFIG_SOCK_DTLS_TIMEOUT_MS;
uint8_t retries = CONFIG_SOCK_DTLS_RETRIES;
bool auto_port = local->port == 0;
do {
if (auto_port) {
/* choose random ephemeral port, since DTLS requires a local port */
local->port = random_uint32_range(IANA_DYNAMIC_PORTRANGE_MIN,
IANA_DYNAMIC_PORTRANGE_MAX);
}
/* connect UDP socket */
res = sock_udp_create(sock_udp, local, remote, 0);
} while (auto_port && (res == -EADDRINUSE));
if (res < 0) {
return res;
}
/* create DTLS socket on to of UDP socket */
res = sock_dtls_create(sock_dtls, sock_udp, tag,
SOCK_DTLS_1_2, SOCK_DTLS_CLIENT);
if (res < 0) {
DEBUG("Unable to create DTLS sock: %s\n", strerror(-res));
sock_udp_close(sock_udp);
return res;
}
while (1) {
mutex_t lock = MUTEX_INIT_LOCKED;
ztimer_t timeout;
/* unlock lock after timeout */
ztimer_mutex_unlock(ZTIMER_MSEC, &timeout, timeout_ms, &lock);
/* create DTLS session */
res = sock_dtls_session_init(sock_dtls, remote, session);
if (res >= 0) {
/* handle handshake */
res = sock_dtls_recv(sock_dtls, session, work_buf,
work_buf_len, timeout_ms * US_PER_MS);
if (res == -SOCK_DTLS_HANDSHAKE) {
DEBUG("DTLS handshake successful\n");
ztimer_remove(ZTIMER_MSEC, &timeout);
return 0;
}
DEBUG("Unable to establish DTLS handshake: %s\n", strerror(-res));
} else {
DEBUG("Unable to initialize DTLS session: %s\n", strerror(-res));
}
sock_dtls_session_destroy(sock_dtls, session);
if (retries--) {
/* wait for timeout to expire */
mutex_lock(&lock);
} else {
ztimer_remove(ZTIMER_MSEC, &timeout);
break;
}
/* see https://datatracker.ietf.org/doc/html/rfc6347#section-4.2.4.1 */
timeout_ms *= 2U;
}
sock_dtls_close(sock_dtls);
sock_udp_close(sock_udp);
return res;
}
#endif
View Git Blame Copy Permalink