udp.h

Go to the documentation of this file.

// uvco (c) 2023 Lewin Bormann. See LICENSE for specific terms.
 
#pragma once
 
#include <boost/assert.hpp>
#include <sys/socket.h>
#include <sys/types.h>
#include <uv.h>
#include <uv/unix.h>
 
#include "uvco/bounded_queue.h"
#include "uvco/internal/internal_utils.h"
#include "uvco/name_resolution.h"
#include "uvco/promise/multipromise.h"
#include "uvco/promise/promise.h"
#include "uvco/run.h"
 
#include <coroutine>
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
 
namespace uvco {
 
 
class Udp {
public:
  explicit Udp(const Loop &loop);
  Udp(Udp &&other) = default;
  Udp &operator=(Udp &&other) = default;
  Udp(const Udp &) = delete;
  Udp &operator=(const Udp &) = delete;
  ~Udp();
 
  Promise<void> bind(std::string_view address, uint16_t port,
                     unsigned int flag = 0);
  Promise<void> bind(const AddressHandle &address, unsigned int flag = 0);
 
  Promise<void> connect(std::string_view address, uint16_t port,
                        bool ipv6only = false);
  Promise<void> connect(const AddressHandle &address);
 
  Promise<void> send(std::span<char> buffer,
                     std::optional<AddressHandle> address = {});
 
  Promise<std::string> receiveOne();
 
  Promise<std::pair<std::string, AddressHandle>> receiveOneFrom();
 
  MultiPromise<std::pair<std::string, AddressHandle>> receiveMany();
 
  void
  stopReceiveMany(MultiPromise<std::pair<std::string, AddressHandle>> &packets);
 
  void setBroadcast(bool enabled);
  void setTtl(uint8_t ttl);
  void setMulticastInterface(const std::string &interfaceAddress);
  void setMulticastLoop(bool enabled);
  void joinMulticast(const std::string &address, const std::string &interface);
  void leaveMulticast(const std::string &address, const std::string &interface);
 
  [[nodiscard]] AddressHandle getSockname() const;
 
  [[nodiscard]] std::optional<AddressHandle> getPeername() const;
 
  Promise<void> close();
 
  [[nodiscard]] uv_udp_t *underlying() const;
 
private:
  const Loop *loop_;
  std::unique_ptr<uv_udp_t> udp_;
  bool connected_ = false;
 
  bool is_receiving_ = false;
 
  int udpStartReceive();
  void udpStopReceive();
 
  static void onReceiveOne(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf,
                           const struct sockaddr *addr, unsigned int flags);
 
  struct RecvAwaiter_ {
    static constexpr unsigned packetQueueSize = 128;
    using QueueItem_ =
        std::variant<std::pair<std::string, AddressHandle>, uv_status>;
 
    RecvAwaiter_();
    [[nodiscard]] bool await_ready() const;
    bool await_suspend(std::coroutine_handle<> handle);
    std::optional<std::pair<std::string, AddressHandle>> await_resume();
 
    BoundedQueue<QueueItem_> buffer_;
    std::optional<std::coroutine_handle<>> handle_;
    bool stop_receiving_ = true;
  };
 
  static void onSendDone(uv_udp_send_t *req, uv_status status);
 
  struct SendAwaiter_ {
    [[nodiscard]] bool await_ready() const;
    bool await_suspend(std::coroutine_handle<> h);
    int await_resume();
 
    std::optional<std::coroutine_handle<>> handle_;
    std::optional<int> status_;
  };
};
 
 
} // namespace uvco