udp.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2016 Alexander Aring <aar@pengutronix.de>
 * SPDX-FileCopyrightText: 2016 Freie Universität Berlin
 * SPDX-FileCopyrightText: 2016 HAW Hamburg
 * SPDX-FileCopyrightText: 2016 Kaspar Schleiser <kaspar@schleiser.de>
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#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_ip_t` to prevent cyclic includes */
#if defined (__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wtypedef-redefinition"
#endif
 
#include "net/af.h"
#include "net/sock.h"
#include "net/ipv4/addr.h"
#include "net/ipv6/addr.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct _sock_tl_ep sock_udp_ep_t;   

typedef struct sock_udp sock_udp_t;
 
#if defined (__clang__)
# pragma clang diagnostic pop
#endif

typedef struct {
#if defined(MODULE_SOCK_AUX_LOCAL) || defined(DOXYGEN)
    sock_udp_ep_t local;
#endif /* MODULE_SOCK_AUX_ENDPOINT */
#if defined(MODULE_SOCK_AUX_TIMESTAMP) || defined(DOXYGEN)
    uint64_t timestamp;
#endif /* MODULE_SOCK_AUX_TIMESTAP */
#if defined(MODULE_SOCK_AUX_RSSI) || defined(DOXYGEN)
    int16_t rssi;
#endif /* MODULE_SOCK_AUX_RSSI */
#if defined(MODULE_SOCK_AUX_TTL) || defined(DOXYGEN)
    uint8_t ttl;
#endif /* MODULE_SOCK_AUX_TTL */
    sock_aux_flags_t flags; 
} sock_udp_aux_rx_t;

typedef struct {
#if defined(MODULE_SOCK_AUX_LOCAL) || defined(DOXYGEN)
    sock_udp_ep_t local;
#endif /* MODULE_SOCK_AUX_ENDPOINT */
#if defined(MODULE_SOCK_AUX_TIMESTAMP) || defined(DOXYGEN)
    uint64_t timestamp;
#endif /* MODULE_SOCK_AUX_TIMESTAP*/
    sock_aux_flags_t flags; 
} sock_udp_aux_tx_t;

int sock_udp_create(sock_udp_t *sock, const sock_udp_ep_t *local,
                    const sock_udp_ep_t *remote, uint16_t flags);

void sock_udp_close(sock_udp_t *sock);

int sock_udp_get_local(sock_udp_t *sock, sock_udp_ep_t *ep);

int sock_udp_get_remote(sock_udp_t *sock, sock_udp_ep_t *ep);

ssize_t sock_udp_recv_aux(sock_udp_t *sock, void *data, size_t max_len,
                          uint32_t timeout, sock_udp_ep_t *remote,
                          sock_udp_aux_rx_t *aux);

static inline ssize_t sock_udp_recv(sock_udp_t *sock,
                                    void *data, size_t max_len,
                                    uint32_t timeout, sock_udp_ep_t *remote)
{
    return sock_udp_recv_aux(sock, data, max_len, timeout, remote, NULL);
}

ssize_t sock_udp_recv_buf_aux(sock_udp_t *sock, void **data, void **buf_ctx,
                              uint32_t timeout, sock_udp_ep_t *remote,
                              sock_udp_aux_rx_t *aux);

static inline ssize_t sock_udp_recv_buf(sock_udp_t *sock,
                                        void **data, void **buf_ctx,
                                        uint32_t timeout,
                                        sock_udp_ep_t *remote)
{
    return sock_udp_recv_buf_aux(sock, data, buf_ctx, timeout, remote, NULL);
}

ssize_t sock_udp_sendv_aux(sock_udp_t *sock, const iolist_t *snips,
                           const sock_udp_ep_t *remote, sock_udp_aux_tx_t *aux);

static inline ssize_t sock_udp_send_aux(sock_udp_t *sock,
                                        const void *data, size_t len,
                                        const sock_udp_ep_t *remote,
                                        sock_udp_aux_tx_t *aux)
{
    const iolist_t snip = {
        NULL,
        (void *)data,
        len,
    };
 
    return sock_udp_sendv_aux(sock, &snip, remote, aux);
}

static inline ssize_t sock_udp_send(sock_udp_t *sock,
                                    const void *data, size_t len,
                                    const sock_udp_ep_t *remote)
{
    return sock_udp_send_aux(sock, data, len, remote, NULL);
}

static inline ssize_t sock_udp_sendv(sock_udp_t *sock,
                                     const iolist_t *snips,
                                     const sock_udp_ep_t *remote)
{
    return sock_udp_sendv_aux(sock, snips, remote, NULL);
}

static inline bool sock_udp_ep_is_multicast(const sock_udp_ep_t *ep)
{
    switch (ep->family) {
#ifdef SOCK_HAS_IPV6
    case AF_INET6:
        return ipv6_addr_is_multicast((const ipv6_addr_t *)&ep->addr.ipv6);
#endif
#ifdef SOCK_HAS_IPV4
    case AF_INET:
        return ipv4_addr_is_multicast((const ipv4_addr_t *)&ep->addr.ipv4);
#endif
    default:
        assert(0);
    }
 
    return false;
}

static inline bool sock_udp_ep_is_v6(const sock_udp_ep_t *ep)
{
#if !defined(SOCK_HAS_IPV6)
    (void)ep;
    return false;
#elif !defined(SOCK_HAS_IPV4)
    (void)ep;
    return true;
#else
    return ep->family == AF_INET6;
#endif
}
 
#if defined(MODULE_SOCK) || defined(MODULE_SOCK_UDP)
#include "sock_types.h"
#endif
 
#ifdef __cplusplus
}
#endif