tcp_listener.h

#pragma once
 
#include <memory>
#include <stdexcept>
#include <sys/socket.h>
#include <utility>
 
#include "uringpp/event_loop.h"
#include "uringpp/ip_address.h"
#include "uringpp/socket.h"
 
namespace uringpp {
 
static inline std::string get_in_addr_string(struct addrinfo *ai) {
  char s[INET6_ADDRSTRLEN];
  inet_ntop(ai->ai_family, get_in_addr(ai->ai_addr), s, sizeof(s));
  return s;
}
 
class tcp_listener : public noncopyable {
  std::shared_ptr<event_loop> loop_;
  int fd_;
  tcp_listener(std::shared_ptr<event_loop> loop, int fd)
      : loop_(loop), fd_(fd) {}
 
public:
  int fd() const { return fd_; }
 
  static tcp_listener listen(std::shared_ptr<event_loop> loop,
                             std::string const &hostname,
                             std::string const &port, int backlog = 128) {
    struct addrinfo hints, *servinfo, *p;
    ::bzero(&hints, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;
 
    if (auto rc = getaddrinfo(hostname.empty() ? nullptr : hostname.c_str(),
                              port.c_str(), &hints, &servinfo);
        rc != 0) {
      throw_with("getaddrinfo: %s", gai_strerror(rc));
    }
    for (p = servinfo; p != nullptr; p = p->ai_next) {
      try {
        int fd = ::socket(p->ai_family, p->ai_flags, p->ai_protocol);
        check_errno(fd, "failed to create socket");
        {
          int32_t yes = 1;
          check_rc(
              ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)),
              "failed to set reuse address");
        }
        auto const &ip = get_in_addr_string(p);
        check_errno(::bind(fd, p->ai_addr, p->ai_addrlen), "failed to bind");
        check_errno(::listen(fd, backlog), "failed to listen");
        URINGPP_LOG_DEBUG("binding %s:%s", ip.c_str(), port.c_str());
        ::freeaddrinfo(servinfo);
        return tcp_listener(loop, fd);
      } catch (std::runtime_error &e) {
        URINGPP_LOG_ERROR("%s", e.what());
        continue;
      }
      break;
    }
    throw std::runtime_error("try all addresses, failed to listen");
  }
 
  tcp_listener(tcp_listener &&other) noexcept
      : loop_(std::move(other.loop_)), fd_(std::exchange(other.fd_, -1)) {}
 
  task<std::pair<ip_address, socket>> accept() {
    ip_address addr;
    auto fd = co_await loop_->accept(
        fd_, reinterpret_cast<struct sockaddr *>(&addr.ss_), &addr.len_);
    check_nerrno(fd, "failed to accept connection");
    co_return std::make_pair(addr, socket(loop_, fd));
  }
 
  task<std::pair<ip_address, socket>> accept(std::shared_ptr<event_loop> loop) {
    ip_address addr;
    auto fd = co_await loop_->accept(
        fd_, reinterpret_cast<struct sockaddr *>(&addr.ss_), &addr.len_);
    check_nerrno(fd, "failed to accept connection");
    co_return std::make_pair(addr, socket(loop, fd));
  }
 
  task<void> close() {
    if (fd_ > 0) {
      co_await loop_->close(fd_);
      fd_ = -1;
    }
  }
 
  ~tcp_listener() {
    if (fd_ > 0) {
      loop_->close_detach(fd_);
    }
  }
};
 
} // namespace uringpp