Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.2

0.7.2 / tests / net_transfer / reference.c

/* Independent POSIX peers verify every byte across simultaneous TCP streams. */
#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <poll.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdint.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

#define CLIENTS 4
#define TRANSFER_BYTES (2u * 1024u * 1024u)
static int listener;
static pthread_t server;
static atomic_uint identities;

static ssize_t receive(int fd, void *data, size_t length) {
    ssize_t count;
    do { count = recv(fd, data, length, 0); } while (count < 0 && errno == EINTR);
    return count;
}

static void *serve_client(void *raw) {
    int fd = (int)(intptr_t)raw;
    unsigned char identity;
    assert(receive(fd, &identity, 1) == 1 && identity < CLIENTS);
    assert(!(atomic_fetch_or(&identities, 1u << identity) & (1u << identity)));
    unsigned char data[4093];
    size_t offset = 0;
    while (offset < TRANSFER_BYTES) {
        ssize_t count = receive(fd, data, sizeof data);
        assert(count > 0 && (size_t)count <= TRANSFER_BYTES - offset);
        for (ssize_t i = 0; i < count; ++i) {
            size_t position = offset + (size_t)i;
            unsigned char expected = (unsigned char)(position * 17 + (position >> 8) + identity * 31);
            assert(data[i] == expected);
            data[i] ^= 0xa5;
        }
        size_t written = 0;
        while (written < (size_t)count) {
            size_t length = (size_t)count - written;
            if (length > 977) length = 977;
            ssize_t sent = send(fd, data + written, length, 0);
            if (sent < 0 && errno == EINTR) continue;
            assert(sent > 0);
            written += (size_t)sent;
        }
        offset += (size_t)count;
    }
    assert(receive(fd, data, 1) == 0);
    assert(close(fd) == 0);
    return NULL;
}

static void *serve(void *unused) {
    (void)unused;
    pthread_t clients[CLIENTS];
    for (unsigned i = 0; i < CLIENTS; ++i) {
        struct pollfd watched = {.fd = listener, .events = POLLIN};
        int ready;
        do { ready = poll(&watched, 1, 45000); } while (ready < 0 && errno == EINTR);
        assert(ready == 1);
        int fd;
        do { fd = accept(listener, NULL, NULL); } while (fd < 0 && errno == EINTR);
        assert(fd >= 0);
        int enabled = 1;
        struct timeval timeout = {.tv_sec = 45};
        assert(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &enabled, sizeof enabled) == 0);
        assert(setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout) == 0);
        assert(setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof timeout) == 0);
        assert(pthread_create(&clients[i], NULL, serve_client, (void *)(intptr_t)fd) == 0);
    }
    for (unsigned i = 0; i < CLIENTS; ++i) assert(pthread_join(clients[i], NULL) == 0);
    assert(close(listener) == 0);
    return NULL;
}

uint16_t transfer_start(int32_t version) {
    assert(version == 4 || version == 6);
    atomic_store(&identities, 0);
    listener = socket(version == 4 ? AF_INET : AF_INET6, SOCK_STREAM, 0);
    assert(listener >= 0);
    uint16_t port;
    if (version == 4) {
        struct sockaddr_in address = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)};
        assert(bind(listener, (struct sockaddr *)&address, sizeof address) == 0);
        socklen_t length = sizeof address;
        assert(getsockname(listener, (struct sockaddr *)&address, &length) == 0);
        port = ntohs(address.sin_port);
    } else {
        struct sockaddr_in6 address = {.sin6_family = AF_INET6, .sin6_addr = IN6ADDR_LOOPBACK_INIT};
        assert(bind(listener, (struct sockaddr *)&address, sizeof address) == 0);
        socklen_t length = sizeof address;
        assert(getsockname(listener, (struct sockaddr *)&address, &length) == 0);
        port = ntohs(address.sin6_port);
    }
    assert(listen(listener, CLIENTS) == 0);
    assert(pthread_create(&server, NULL, serve, NULL) == 0);
    return port;
}

void transfer_finish(void) {
    assert(pthread_join(server, NULL) == 0);
    assert(atomic_load(&identities) == (1u << CLIENTS) - 1);
}