src/commons/sockets.h

#ifndef COMMONS_SOCKETS_H
#define COMMONS_SOCKETS_H

#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <strings.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>

#include <commons/check.h>
#include <commons/closing.h>
#include <commons/nullptr.h>

namespace commons
{

#undef  __FDMASK
#define __FDMASK(d) (static_cast<__fd_mask>(1) << ((d) % __NFDBITS))

  const in_addr_t inaddr_any = in_addr_t(0);

  int
  set_non_blocking(int fd)
  {
    checknnegerr(fcntl(fd, F_SETFL,
                       O_NONBLOCK | checknnegerr(fcntl(fd, F_GETFL, 0))));
    return fd;
  }

  int
  tcp_socket(bool nb)
  {
    int fd = checknnegerr(socket(PF_INET, SOCK_STREAM, 0));
    // Make our socket non-blocking if desired.
    if (nb) set_non_blocking(fd);
    return fd;
  }

  inline uint16_t
  safe_htons(uint16_t x)
  {
    return (x & 0x00ff << 8) | (x & 0xff00 >> 8);
  }

  void
  sockaddr_init(sockaddr_in &a, uint16_t port)
  {
    bzero(&a, sizeof a);
    a.sin_family = AF_INET;
    a.sin_port = safe_htons(port);
  }

  void
  sockaddr_init(sockaddr_in &a, const char *host, uint16_t port)
  {
    sockaddr_init(a, port);
    if (host == nullptr) {
      a.sin_addr.s_addr = htonl(inaddr_any);
    } else {
      // First try to interpret host as a dot-notation string.
      if (!inet_aton(host, reinterpret_cast<in_addr*>(&a.sin_addr.s_addr))) {
        // Now try to resolve the hostname.
        hostent *res = checkpass(gethostbyname(host));
        memcpy(&a.sin_addr, res->h_addr_list[0], res->h_length);
      }
    }
  }

  void
  sockaddr_init(sockaddr_in &a, in_addr host, uint16_t port)
  {
    sockaddr_init(a, port);
    a.sin_addr = host;
  }

  template <typename T>
  sockaddr_in
  make_sockaddr(T host, uint16_t port)
  {
    sockaddr_in a;
    sockaddr_init(a, host, port);
    return a;
  }

  int
  server_socket(uint16_t port, bool nb = false)
  {
    // Create the socket.
    closingfd c(tcp_socket(nb));
    int fd = c.get();

    // Configure the socket.
    int n = 1;
    check0x(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
                       reinterpret_cast<char*>(&n), sizeof(n)));

    // Create the local socket address.
    sockaddr_in sa = make_sockaddr(nullptr, port);

    // Bind the socket to the local socket address.
    check0x(::bind(fd, reinterpret_cast<sockaddr*>(&sa), sizeof sa));

    return c.release();
  }

  int
  tcp_listen(uint16_t port, bool nb = false)
  {
    int fd = server_socket(port, nb);
    try {
      // SOMAXCONN is the kernel's limit on the maximum number of socket
      // connections.
      check0x(listen(fd, SOMAXCONN));
      return fd;
    } catch (...) {
      close(fd);
      throw;
    }
  }

  int
  tcp_connect(const char *host, uint16_t port)
  {
    closingfd c(tcp_socket(false));
    sockaddr_in a = make_sockaddr(host, port);
    check0x(connect(c.get(), reinterpret_cast<sockaddr*>(&a), sizeof a));
    return c.release();
  }

}

#endif

---