udp.h

Go to the documentation of this file.

// uvco (c) 2023 Lewin Bormann. See LICENSE for specific terms.
 
#pragma once
 
#include <uv.h>
#include <uv/unix.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 <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <utility>
 
namespace uvco {


class Udp {
  struct SendAwaiter_;
  struct RecvAwaiter_;
 
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<const 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;

  void close();
 
private:
  const Loop *loop_;
  std::unique_ptr<uv_udp_t> udp_;
  bool connected_ = false;
 
  int udpStartReceive();
  void udpStopReceive();
 
  static void onSendDone(uv_udp_send_t *req, uv_status status);
  static void onReceiveOne(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf,
                           const struct sockaddr *addr, unsigned int flags);
};

 
} // namespace uvco