client.cpp

#include <iostream>
#include <memory>
#include <cstddef>
#include <thread>
#include <chrono>

#include <string.h>
#include <errno.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/un.h>
#include <sys/mman.h>

using namespace std;
using namespace std::chrono_literals;

int transfer_fd(int sock_fd, int fd) {
    struct alignas(struct cmsghdr) dummy {
        char buf[CMSG_SPACE(sizeof(fd))];
    } u;

    char iobuf[] = "hello";
    struct iovec io = {
        .iov_base = iobuf,
        .iov_len = sizeof(iobuf)
    };

	struct msghdr msg{};
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;
    msg.msg_control = reinterpret_cast<void*>(&u);
    msg.msg_controllen = sizeof(u);

    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
    memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
	return sendmsg(sock_fd, &msg, 0);
}

tuple<int, void*> allocate_shared_memory(size_t n) {
    const auto page_size = sysconf(_SC_PAGESIZE);
    n = (n + page_size - 1) & ~(page_size - 1);
    int fd = memfd_create("db", MFD_CLOEXEC);
    if (fd == -1) {
        cout << "memfd_create failed: " << strerror(errno) << endl;
        return {-1, nullptr};
    }
    if (ftruncate(fd, n) == -1) {
        cout << "ftruncate failed: " << strerror(errno) << endl;
        return {-1, nullptr};
    }
    auto addr = mmap(nullptr, n, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        cout << "mmap failed: " << strerror(errno) << endl;
        return {-1, nullptr};
    }
    return {fd, addr};
}

int main() {
    int sock = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock <= 0) {
        cout << "create socket failed: " << strerror(errno) << endl;
        return 1;
    }

    sockaddr_un server_addr{AF_UNIX};
    string sock_path = "/tmp/server.sock";
    memcpy(reinterpret_cast<void*>(server_addr.sun_path),
           reinterpret_cast<const void*>(sock_path.c_str()), sock_path.length() + 1);
    if (connect(sock, reinterpret_cast<sockaddr*>(&server_addr), sizeof(server_addr))) {
        cout << "connect failed: " << strerror(errno) << endl;
        return 1;
    }
    auto [fd, addr] = allocate_shared_memory(4096);
    transfer_fd(sock, fd);
    this_thread::sleep_for(1s);
    char *msg = reinterpret_cast<char*>(addr);
    cout << msg;
    return 0;
}