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.
 */
 
#ifndef NET_SOCK_DTLS_H
#define NET_SOCK_DTLS_H
 
#include <assert.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)
 
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;
 
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);
 
ssize_t sock_dtls_recv(sock_dtls_t *sock, sock_dtls_session_t *remote,
                       void *data, size_t maxlen, uint32_t timeout);
 
ssize_t sock_dtls_recv_buf(sock_dtls_t *sock, sock_dtls_session_t *remote,
                           void **data, void **buf_ctx, uint32_t timeout);
 
ssize_t sock_dtls_send(sock_dtls_t *sock, sock_dtls_session_t *remote,
                       const void *data, size_t len, uint32_t timeout);
 
void sock_dtls_close(sock_dtls_t *sock);
 
static inline int sock_dtls_session_create(sock_dtls_t *sock,
                                           const sock_udp_ep_t *ep,
                                           sock_dtls_session_t *remote,
                                           unsigned timeout)
{
    int res;
    uint8_t buf[DTLS_HANDSHAKE_BUFSIZE];
 
    assert(sock);
    assert(remote);
 
    res = sock_dtls_session_init(sock, ep, remote);
    if (res <= 0) {
        return res;
    }
 
    res = sock_dtls_recv(sock, remote, buf, sizeof(buf), timeout);
    return res == -SOCK_DTLS_HANDSHAKE ? 0 : res;
}
 
#include "sock_dtls_types.h"
 
#ifdef __cplusplus
}
#endif
 
#endif /* NET_SOCK_DTLS_H */