dtls.h

Go to the documentation of this file.

/*
 * Copyright (C) 2019 HAW Hamburg
 *                    Freie Universität Berlin
 *                    Inria
 *                    Daniele Lacamera
 *                    Ken Bannister
 *
 * 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.
 */
 
#pragma once

 
#include <assert.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
 
/* net/sock/async/types.h included by net/sock.h needs to re-typedef the
 * `sock_dtls_t` to prevent cyclic includes */
#if defined (__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wtypedef-redefinition"
#endif
 
#include "net/sock.h"
#include "net/sock/udp.h"
#include "net/credman.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONFIG_DTLS_HANDSHAKE_BUFSIZE_EXP
#define CONFIG_DTLS_HANDSHAKE_BUFSIZE_EXP  8
#endif

#ifndef DTLS_HANDSHAKE_BUFSIZE
#define DTLS_HANDSHAKE_BUFSIZE  (1 << CONFIG_DTLS_HANDSHAKE_BUFSIZE_EXP)
#endif

#define SOCK_DTLS_HANDSHAKE     (EXDEV)

#ifndef CONFIG_DTLS_FORCE_EXTENDED_MASTER_SECRET
#define CONFIG_DTLS_FORCE_EXTENDED_MASTER_SECRET 1
#endif

#ifndef CONFIG_DTLS_FORCE_RENEGOTIATION_INFO
#define CONFIG_DTLS_FORCE_RENEGOTIATION_INFO 1
#endif

enum {
    SOCK_DTLS_1_0 = 1,  
    SOCK_DTLS_1_2 = 2,  
    SOCK_DTLS_1_3 = 3,  
};

enum {
    SOCK_DTLS_CLIENT = 1,   
    SOCK_DTLS_SERVER = 2,   
};

typedef struct sock_dtls sock_dtls_t;
 
#if defined (__clang__)
# pragma clang diagnostic pop
#endif

typedef struct sock_dtls_session sock_dtls_session_t;

typedef sock_udp_aux_rx_t sock_dtls_aux_rx_t;

typedef sock_udp_aux_tx_t sock_dtls_aux_tx_t;

void sock_dtls_init(void);

int sock_dtls_create(sock_dtls_t *sock, sock_udp_t *udp_sock,
                     credman_tag_t tag, unsigned version, unsigned role);

sock_udp_t *sock_dtls_get_udp_sock(sock_dtls_t *sock);

int sock_dtls_session_init(sock_dtls_t *sock, const sock_udp_ep_t *ep,
                           sock_dtls_session_t *remote);

void sock_dtls_session_destroy(sock_dtls_t *sock, sock_dtls_session_t *remote);

void sock_dtls_session_get_udp_ep(const sock_dtls_session_t *session,
                                  sock_udp_ep_t *ep);

void sock_dtls_session_set_udp_ep(sock_dtls_session_t *session,
                                  const sock_udp_ep_t *ep);

ssize_t sock_dtls_recv_aux(sock_dtls_t *sock, sock_dtls_session_t *remote,
                           void *data, size_t maxlen, uint32_t timeout,
                           sock_dtls_aux_rx_t *aux);

static inline ssize_t sock_dtls_recv(sock_dtls_t *sock,
                                     sock_dtls_session_t *remote,
                                     void *data, size_t maxlen,
                                     uint32_t timeout)
{
    return sock_dtls_recv_aux(sock, remote, data, maxlen, timeout, NULL);
}

ssize_t sock_dtls_recv_buf_aux(sock_dtls_t *sock, sock_dtls_session_t *remote,
                               void **data, void **buf_ctx, uint32_t timeout,
                               sock_dtls_aux_rx_t *aux);

static inline ssize_t sock_dtls_recv_buf(sock_dtls_t *sock,
                                         sock_dtls_session_t *remote,
                                         void **data, void **buf_ctx,
                                         uint32_t timeout)
{
    return sock_dtls_recv_buf_aux(sock, remote, data, buf_ctx, timeout, NULL);
}

ssize_t sock_dtls_sendv_aux(sock_dtls_t *sock, sock_dtls_session_t *remote,
                            const iolist_t *snips, uint32_t timeout,
                            sock_dtls_aux_tx_t *aux);

static inline ssize_t sock_dtls_send_aux(sock_dtls_t *sock,
                                         sock_dtls_session_t *remote,
                                         const void *data, size_t len,
                                         uint32_t timeout,
                                         sock_dtls_aux_tx_t *aux)
{
    const iolist_t snip = {
        .iol_base = (void *)data,
        .iol_len  = len,
    };
 
    return sock_dtls_sendv_aux(sock, remote, &snip, timeout, aux);
}

static inline ssize_t sock_dtls_send(sock_dtls_t *sock,
                                     sock_dtls_session_t *remote,
                                     const void *data, size_t len,
                                     uint32_t timeout)
{
    return sock_dtls_send_aux(sock, remote, data, len, timeout, NULL);
}

static inline ssize_t sock_dtls_sendv(sock_dtls_t *sock,
                                      sock_dtls_session_t *remote,
                                      const iolist_t *snips,
                                      uint32_t timeout)
{
    return sock_dtls_sendv_aux(sock, remote, snips, timeout, NULL);
}

void sock_dtls_close(sock_dtls_t *sock);
 
#ifdef MODULE_SOCK_DTLS
#include "sock_dtls_types.h"
#endif
 
#ifdef __cplusplus
}
#endif