udp.h

#ifndef UVW_UDP_INCLUDE_H
#define UVW_UDP_INCLUDE_H
 
#include <cstddef>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <uv.h>
#include "config.h"
#include "enum.hpp"
#include "handle.hpp"
#include "request.hpp"
#include "util.h"
 
namespace uvw {
 
struct send_event {};
 
struct udp_data_event {
    explicit udp_data_event(socket_address sndr, std::unique_ptr<char[]> buf, std::size_t len, bool part) noexcept;
 
    std::unique_ptr<char[]> data; 
    std::size_t length;           
    socket_address sender;        
    bool partial;                 
};
 
namespace details {
 
enum class uvw_udp_flags : std::underlying_type_t<uv_udp_flags> {
    IPV6ONLY = UV_UDP_IPV6ONLY,
    UDP_PARTIAL = UV_UDP_PARTIAL,
    REUSEADDR = UV_UDP_REUSEADDR,
    UDP_MMSG_CHUNK = UV_UDP_MMSG_CHUNK,
    UDP_MMSG_FREE = UV_UDP_MMSG_FREE,
    UDP_LINUX_RECVERR = UV_UDP_LINUX_RECVERR,
    UDP_RECVMMSG = UV_UDP_RECVMMSG,
    _UVW_ENUM = 0
};
 
enum class uvw_membership : std::underlying_type_t<uv_membership> {
    LEAVE_GROUP = UV_LEAVE_GROUP,
    JOIN_GROUP = UV_JOIN_GROUP
};
 
class send_req final: public request<send_req, uv_udp_send_t, send_event> {
    static void udp_send_callback(uv_udp_send_t *req, int status);
 
public:
    using deleter = void (*)(char *);
 
    send_req(loop::token token, std::shared_ptr<loop> parent, std::unique_ptr<char[], deleter> dt, unsigned int len);
 
    int send(uv_udp_t *hndl, const struct sockaddr *addr);
 
private:
    std::unique_ptr<char[], deleter> data;
    uv_buf_t buf;
};
 
} // namespace details
 
class udp_handle final: public handle<udp_handle, uv_udp_t, send_event, udp_data_event> {
    static void recv_callback(uv_udp_t *hndl, ssize_t nread, const uv_buf_t *buf, const sockaddr *addr, unsigned flags);
 
public:
    using membership = details::uvw_membership;
    using udp_flags = details::uvw_udp_flags;
    using ipv4 = uvw::ipv4;
    using ipv6 = uvw::ipv6;
 
    explicit udp_handle(loop::token token, std::shared_ptr<loop> ref, unsigned int f = {});
 
    int init() final;
 
    int open(os_socket_handle socket);
 
    int connect(const sockaddr &addr);
 
    int connect(const std::string &ip, unsigned int port);
 
    int connect(socket_address addr);
 
    int disconnect();
 
    socket_address peer() const noexcept;
 
    int bind(const sockaddr &addr, udp_flags opts = udp_flags::_UVW_ENUM);
 
    int bind(const std::string &ip, unsigned int port, udp_flags opts = udp_flags::_UVW_ENUM);
 
    int bind(socket_address addr, udp_flags opts = udp_flags::_UVW_ENUM);
 
    socket_address sock() const noexcept;
 
    bool multicast_membership(const std::string &multicast, const std::string &iface, membership ms);
 
    bool multicast_loop(bool enable = true);
 
    bool multicast_ttl(int val);
 
    bool multicast_interface(const std::string &iface);
 
    bool broadcast(bool enable = false);
 
    bool ttl(int val);
 
    int send(const sockaddr &addr, std::unique_ptr<char[]> data, unsigned int len);
 
    int send(const std::string &ip, unsigned int port, std::unique_ptr<char[]> data, unsigned int len);
 
    int send(socket_address addr, std::unique_ptr<char[]> data, unsigned int len);
 
    int send(const sockaddr &addr, char *data, unsigned int len);
 
    int send(const std::string &ip, unsigned int port, char *data, unsigned int len);
 
    int send(socket_address addr, char *data, unsigned int len);
 
    int try_send(const sockaddr &addr, std::unique_ptr<char[]> data, unsigned int len);
 
    int try_send(const std::string &ip, unsigned int port, std::unique_ptr<char[]> data, unsigned int len);
 
    int try_send(socket_address addr, std::unique_ptr<char[]> data, unsigned int len);
 
    int try_send(const sockaddr &addr, char *data, unsigned int len);
 
    int try_send(const std::string &ip, unsigned int port, char *data, unsigned int len);
 
    int try_send(socket_address addr, char *data, unsigned int len);
 
    int recv();
 
    int stop();
 
    size_t send_queue_size() const noexcept;
 
    size_t send_queue_count() const noexcept;
 
private:
    enum {
        DEFAULT,
        FLAGS
    } tag{DEFAULT};
 
    unsigned int flags{};
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "udp.cpp"
#endif
 
#endif // UVW_UDP_INCLUDE_H