Ticket #18653: 18653-test.cpp

#include <filesystem>
#include <iostream>
#include <cstring>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <vector>
#include <unistd.h>


namespace fs = std::filesystem;


class TemporaryDirectory
{
public:
    TemporaryDirectory();
    ~TemporaryDirectory();

    const fs::path& Path() const;
private:
    fs::path    fPath;
};


TemporaryDirectory::TemporaryDirectory()
{
    fPath = fs::temp_directory_path();
    auto subdir = std::string("haiku-test-");
    srand(time(NULL));
    subdir += std::to_string(rand());
    fPath = fPath / subdir;
    fs::create_directories(fPath);
    std::cout << "Temp directory is " << fPath << '\n';
}


TemporaryDirectory::~TemporaryDirectory()
{
    fs::remove_all(fPath);
}


const std::filesystem::path &
TemporaryDirectory::Path() const
{
    return fPath;
}


void
set_cloexec(int fd)
{
    auto previous = fcntl(fd, F_GETFD);
    auto newflags = previous | FD_CLOEXEC;
    if (previous != newflags) {
        if (auto status = fcntl(fd, F_SETFD, newflags); status != 0)
            throw std::runtime_error("unable to set FD_CLOEXEC on sock1");
    }
}

/*
 * fn test_unix_datagram_peek() {
    let dir = tmpdir();
    let path1 = dir.path().join("sock");

    let sock1 = or_panic!(UnixDatagram::bind(&path1));
    let sock2 = or_panic!(UnixDatagram::unbound());
    or_panic!(sock2.connect(&path1));

    let msg = b"hello world";
    or_panic!(sock2.send(msg));
    for _ in 0..2 {
        let mut buf = [0; 11];
        let size = or_panic!(sock1.peek(&mut buf));
        assert_eq!(size, 11);
        assert_eq!(msg, &buf[..]);
    }

    let mut buf = [0; 11];
    let size = or_panic!(sock1.recv(&mut buf));
    assert_eq!(size, 11);
    assert_eq!(msg, &buf[..]);
}
*/

void
test_unix_datagram_peek()
{
    // let dir = tmpdir();
    TemporaryDirectory dir;
    // let path1 = dir.path().join("sock");
    auto path1 = dir.Path() / "sock";

    // let sock1 = or_panic!(UnixDatagram::bind(&path1));
    auto sock1 = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sock1 == -1)
        throw std::runtime_error("Cannot create sock1");
    set_cloexec(sock1);

    sockaddr_un socketaddress = {};
    socketaddress.sun_family = AF_UNIX;
    std::strncpy(socketaddress.sun_path, path1.c_str(), std::strlen(path1.c_str()));
    if (auto status = bind(sock1, (const sockaddr *) &socketaddress, sizeof(socketaddress)); status == -1){
        std::cout << strerror(errno) << std::endl;
        throw std::runtime_error("unable to bind sock1 to path");
    }

    // let sock2 = or_panic!(UnixDatagram::unbound());
    auto sock2 = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sock2 == -1)
        throw std::runtime_error("Cannot create sock2");
    set_cloexec(sock2);

    // or_panic!(sock2.connect(&path1))
    if (auto status = connect(sock2, (const sockaddr *) &socketaddress, sizeof(socketaddress)); status != 0)
        throw std::runtime_error("Cannot connect sock2 to socket");

    // let msg = b"hello world"
    const char* msg = "hello world";

    // or_panic!(sock2.send(msg))
    if (auto status = write(sock2, msg, strlen(msg)); status == -1)
        throw std::runtime_error("Cannot write message to sock2");

    std::cout << "Message written to sock2" << std::endl;

    /*
        for _ in 0..2 {
            let mut buf = [0; 11];
            let size = or_panic!(sock1.peek(&mut buf));
            assert_eq!(size, 11);
            assert_eq!(msg, &buf[..]);
        }
    */

    for (int i = 0; i < 2; i++){
        std::vector<std::byte> buf;
        buf.reserve(11);
        if (auto ret = recv(sock1, buf.data(), buf.capacity(), MSG_PEEK); ret != 11)
            throw std::runtime_error("Could not peek 11 bytes from sock1");
        buf.resize(11);
        std::cout << "peek " << i + 1 << " complete" << std::endl;
    }

    // let mut buf = [0; 11];
    std::vector<std::byte> buf;
    buf.reserve(11);
    // let size = or_panic!(sock1.recv(&mut buf));
    // assert_eq!(size, 11);

    if (auto ret = recv(sock1, buf.data(), buf.capacity(), 0); ret != 11)
        throw std::runtime_error("Could not receive 11 bytes from sock1");
    std::cout << "recv complete" << std::endl;
}


int main()
{
    std::cout << "Running test_unix_datagram_peek!" << std::endl;
    test_unix_datagram_peek();
    return 0;
}