TCP sockets in C++: client and server on localhost

C++ header · net.hpp

// net.hpp: TCP sockets on the loopback address 127.0.0.1, each owned by a FileDescriptor (fd.hpp).
#pragma once
#include "fd.hpp"

#include <cstdint>
#include <string>
#include <string_view>

#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>

// The address 127.0.0.1:port. The loopback interface never leaves this machine.
inline sockaddr_in loopback(std::uint16_t port) {
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);                   // network byte order: most significant byte first
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // 127.0.0.1
    return addr;
}

// socket, bind and listen. Port 0 asks the system for any free port; local_port() says which one it chose.
inline std::expected<FileDescriptor, std::error_code> listen_on_loopback(std::uint16_t port = 0, int backlog = 16) {
    FileDescriptor s(::socket(AF_INET, SOCK_STREAM, 0));
    if (!s) return std::unexpected(last_error());
    int on = 1;
    ::setsockopt(s.get(), SOL_SOCKET, SO_REUSEADDR, &on, sizeof on);
    sockaddr_in addr = loopback(port);
    if (::bind(s.get(), reinterpret_cast<const sockaddr*>(&addr), sizeof addr) != 0) return std::unexpected(last_error());
    if (::listen(s.get(), backlog) != 0) return std::unexpected(last_error());
    return s;
}

inline std::uint16_t local_port(int fd) {
    sockaddr_in addr{};
    socklen_t len = sizeof addr;
    ::getsockname(fd, reinterpret_cast<sockaddr*>(&addr), &len);
    return ntohs(addr.sin_port);
}

inline std::expected<FileDescriptor, std::error_code> connect_to_loopback(std::uint16_t port) {
    FileDescriptor s(::socket(AF_INET, SOCK_STREAM, 0));
    if (!s) return std::unexpected(last_error());
    sockaddr_in addr = loopback(port);
    if (::connect(s.get(), reinterpret_cast<const sockaddr*>(&addr), sizeof addr) != 0) return std::unexpected(last_error());
    return s;
}

// send() may send only part of the data: keep going. MSG_NOSIGNAL turns a write to a closed connection into the
// error EPIPE instead of the signal SIGPIPE, which would end the program.
inline std::error_code send_all(int fd, std::string_view data) {
    while (!data.empty()) {
        ssize_t n = ::send(fd, data.data(), data.size(), MSG_NOSIGNAL);
        if (n < 0) {
            if (errno == EINTR) continue;
            return last_error();
        }
        data.remove_prefix(static_cast<std::size_t>(n));
    }
    return {};
}

// Reads exactly n bytes. Returns fewer only if the other side closed the connection first.
inline std::expected<std::string, std::error_code> recv_exactly(int fd, std::size_t n) {
    std::string data(n, '\0');
    std::size_t got = 0;
    while (got < n) {
        ssize_t r = ::recv(fd, data.data() + got, n - got, 0);
        if (r == 0) break; // the connection was closed
        if (r < 0) {
            if (errno == EINTR) continue;
            return std::unexpected(last_error());
        }
        got += static_cast<std::size_t>(r);
    }
    data.resize(got);
    return data;
}

C++ · echo.cpp

// echo.cpp: a TCP server and a client in one program, talking over 127.0.0.1.
#include "net.hpp"

#include <cctype>
#include <format>
#include <print>
#include <string>
#include <thread>
#include <vector>

int main() {
    auto listener = listen_on_loopback(); // socket, bind to 127.0.0.1 with port 0, listen
    if (!listener) {
        std::println("listen: {}", listener.error().message());
        return 1;
    }
    std::uint16_t port = local_port(listener->get());
    std::vector<std::string> log; // what the server saw, printed at the end

    std::jthread server([&] {
        // accept waits for a client and returns a new socket for that one connection.
        FileDescriptor conn(::accept(listener->get(), nullptr, nullptr));
        log.push_back("accepted a connection");
        std::size_t total = 0;
        char buffer[1024];
        for (ssize_t n; (n = ::recv(conn.get(), buffer, sizeof buffer, 0)) > 0;) {
            for (ssize_t i = 0; i < n; ++i) buffer[i] = static_cast<char>(std::toupper(static_cast<unsigned char>(buffer[i])));
            (void)send_all(conn.get(), std::string_view(buffer, static_cast<std::size_t>(n)));
            total += static_cast<std::size_t>(n);
        }
        log.push_back(std::format("recv() returned 0 after {} bytes, so the client has finished sending", total));
    }); // conn is closed when the thread's function returns

    auto client = connect_to_loopback(port); // the TCP handshake happens inside connect
    if (!client) {
        std::println("connect: {}", client.error().message());
        return 1;
    }
    for (std::string_view message : {"hello", "sockets on localhost"}) {
        (void)send_all(client->get(), message);
        auto reply = recv_exactly(client->get(), message.size());
        std::println("client sent {:?}, got back {:?}", message, reply.value_or("?"));
    }
    ::shutdown(client->get(), SHUT_WR); // no more data from the client: the server's recv() returns 0
    auto rest = recv_exactly(client->get(), 1);
    std::println("client: recv() returned {} bytes, so the server has closed the connection", rest.value_or("?").size());
    server.join();
    for (const std::string& line : log) std::println("server: {}", line);
    std::println("port chosen by the system: {}", port != 0 ? "a free one, different on every run" : "none");
}