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 "handle.hpp"
#include "request.hpp"
#include "util.h"
 
namespace uvw {
 
struct SendEvent {};
 
struct UDPDataEvent {
    explicit UDPDataEvent(Addr sndr, std::unique_ptr<char[]> buf, std::size_t len, bool part) noexcept;
 
    std::unique_ptr<char[]> data; 
    std::size_t length;           
    Addr sender;                  
    bool partial;                 
};
 
namespace details {
 
enum class UVUDPFlags : 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
};
 
enum class UVMembership : std::underlying_type_t<uv_membership> {
    LEAVE_GROUP = UV_LEAVE_GROUP,
    JOIN_GROUP = UV_JOIN_GROUP
};
 
class SendReq final: public Request<SendReq, uv_udp_send_t> {
public:
    using Deleter = void (*)(char *);
 
    SendReq(ConstructorAccess ca, std::shared_ptr<Loop> loop, std::unique_ptr<char[], Deleter> dt, unsigned int len);
 
    void send(uv_udp_t *handle, const struct sockaddr *addr);
 
private:
    std::unique_ptr<char[], Deleter> data;
    uv_buf_t buf;
};
 
} // namespace details
 
class UDPHandle final: public Handle<UDPHandle, uv_udp_t> {
    template<typename I>
    static void recvCallback(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const sockaddr *addr, unsigned flags) {
        const typename details::IpTraits<I>::Type *aptr = reinterpret_cast<const typename details::IpTraits<I>::Type *>(addr);
 
        UDPHandle &udp = *(static_cast<UDPHandle *>(handle->data));
        // data will be destroyed no matter of what the value of nread is
        std::unique_ptr<char[]> data{buf->base};
 
        if(nread > 0) {
            // data available (can be truncated)
            udp.publish(UDPDataEvent{details::address<I>(aptr), std::move(data), static_cast<std::size_t>(nread), !(0 == (flags & UV_UDP_PARTIAL))});
        } else if(nread == 0 && addr == nullptr) {
            // no more data to be read, doing nothing is fine
        } else if(nread == 0 && addr != nullptr) {
            // empty udp packet
            udp.publish(UDPDataEvent{details::address<I>(aptr), std::move(data), static_cast<std::size_t>(nread), false});
        } else {
            // transmission error
            udp.publish(ErrorEvent(nread));
        }
    }
 
public:
    using Membership = details::UVMembership;
    using Bind = details::UVUDPFlags;
    using IPv4 = uvw::IPv4;
    using IPv6 = uvw::IPv6;
 
    explicit UDPHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref, unsigned int f = {});
 
    bool init();
 
    void open(OSSocketHandle socket);
 
    void bind(const sockaddr &addr, Flags<Bind> opts = Flags<Bind>{});
 
    void connect(const sockaddr &addr);
 
    template<typename I = IPv4>
    void connect(const std::string &ip, unsigned int port);
 
    template<typename I = IPv4>
    void connect(Addr addr);
 
    void disconnect();
 
    template<typename I = IPv4>
    Addr peer() const noexcept;
 
    template<typename I = IPv4>
    void bind(const std::string &ip, unsigned int port, Flags<Bind> opts = Flags<Bind>{});
 
    template<typename I = IPv4>
    void bind(Addr addr, Flags<Bind> opts = Flags<Bind>{});
 
    template<typename I = IPv4>
    Addr sock() const noexcept;
 
    template<typename I = IPv4>
    bool multicastMembership(const std::string &multicast, const std::string &iface, Membership membership);
 
    bool multicastLoop(bool enable = true);
 
    bool multicastTtl(int val);
 
    template<typename I = IPv4>
    bool multicastInterface(const std::string &iface);
 
    bool broadcast(bool enable = false);
 
    bool ttl(int val);
 
    void send(const sockaddr &addr, std::unique_ptr<char[]> data, unsigned int len);
 
    template<typename I = IPv4>
    void send(const std::string &ip, unsigned int port, std::unique_ptr<char[]> data, unsigned int len);
 
    template<typename I = IPv4>
    void send(Addr addr, std::unique_ptr<char[]> data, unsigned int len);
 
    void send(const sockaddr &addr, char *data, unsigned int len);
 
    template<typename I = IPv4>
    void send(const std::string &ip, unsigned int port, char *data, unsigned int len);
 
    template<typename I = IPv4>
    void send(Addr addr, char *data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(const sockaddr &addr, std::unique_ptr<char[]> data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(const std::string &ip, unsigned int port, std::unique_ptr<char[]> data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(Addr addr, std::unique_ptr<char[]> data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(const sockaddr &addr, char *data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(const std::string &ip, unsigned int port, char *data, unsigned int len);
 
    template<typename I = IPv4>
    int trySend(Addr addr, char *data, unsigned int len);
 
    template<typename I = IPv4>
    void recv();
 
    void stop();
 
    size_t sendQueueSize() const noexcept;
 
    size_t sendQueueCount() const noexcept;
 
private:
    enum {
        DEFAULT,
        FLAGS
    } tag{DEFAULT};
 
    unsigned int flags{};
};
 
// (extern) explicit instantiations
#ifdef UVW_AS_LIB
extern template void UDPHandle::connect<IPv4>(const std::string &, unsigned int);
extern template void UDPHandle::connect<IPv6>(const std::string &, unsigned int);
 
extern template void UDPHandle::connect<IPv4>(Addr);
extern template void UDPHandle::connect<IPv6>(Addr);
 
extern template Addr UDPHandle::peer<IPv4>() const noexcept;
extern template Addr UDPHandle::peer<IPv6>() const noexcept;
 
extern template void UDPHandle::bind<IPv4>(const std::string &, unsigned int, Flags<Bind>);
extern template void UDPHandle::bind<IPv6>(const std::string &, unsigned int, Flags<Bind>);
 
extern template void UDPHandle::bind<IPv4>(Addr, Flags<Bind>);
extern template void UDPHandle::bind<IPv6>(Addr, Flags<Bind>);
 
extern template Addr UDPHandle::sock<IPv4>() const noexcept;
extern template Addr UDPHandle::sock<IPv6>() const noexcept;
 
extern template bool UDPHandle::multicastMembership<IPv4>(const std::string &, const std::string &, Membership);
extern template bool UDPHandle::multicastMembership<IPv6>(const std::string &, const std::string &, Membership);
 
extern template bool UDPHandle::multicastInterface<IPv4>(const std::string &);
extern template bool UDPHandle::multicastInterface<IPv6>(const std::string &);
 
extern template void UDPHandle::send<IPv4>(const std::string &, unsigned int, std::unique_ptr<char[]>, unsigned int);
extern template void UDPHandle::send<IPv6>(const std::string &, unsigned int, std::unique_ptr<char[]>, unsigned int);
 
extern template void UDPHandle::send<IPv4>(Addr, std::unique_ptr<char[]>, unsigned int);
extern template void UDPHandle::send<IPv6>(Addr, std::unique_ptr<char[]>, unsigned int);
 
extern template void UDPHandle::send<IPv4>(const std::string &, unsigned int, char *, unsigned int);
extern template void UDPHandle::send<IPv6>(const std::string &, unsigned int, char *, unsigned int);
 
extern template void UDPHandle::send<IPv4>(Addr, char *, unsigned int);
extern template void UDPHandle::send<IPv6>(Addr, char *, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(const sockaddr &, std::unique_ptr<char[]>, unsigned int);
extern template int UDPHandle::trySend<IPv6>(const sockaddr &, std::unique_ptr<char[]>, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(const std::string &, unsigned int, std::unique_ptr<char[]>, unsigned int);
extern template int UDPHandle::trySend<IPv6>(const std::string &, unsigned int, std::unique_ptr<char[]>, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(Addr, std::unique_ptr<char[]>, unsigned int);
extern template int UDPHandle::trySend<IPv6>(Addr, std::unique_ptr<char[]>, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(const sockaddr &, char *, unsigned int);
extern template int UDPHandle::trySend<IPv6>(const sockaddr &, char *, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(const std::string &, unsigned int, char *, unsigned int);
extern template int UDPHandle::trySend<IPv6>(const std::string &, unsigned int, char *, unsigned int);
 
extern template int UDPHandle::trySend<IPv4>(Addr, char *, unsigned int);
extern template int UDPHandle::trySend<IPv6>(Addr, char *, unsigned int);
 
extern template void UDPHandle::recv<IPv4>();
extern template void UDPHandle::recv<IPv6>();
#endif // UVW_AS_LIB
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "udp.cpp"
#endif
 
#endif // UVW_UDP_INCLUDE_H