Add the remchild PoC: client, server, naming, and plan

2026-09-22 09:34:43 +02:00
parent 10143c87a4
commit 9a776fefd3
7 changed files with 1228 additions and 0 deletions
@@ -0,0 +1,313 @@
+/*
+ * remchild — proof-of-concept remote child client.
+ *
+ * Self-contained Linux client: no runtime dependencies beyond libc. It finds
+ * the server, identifies itself, sends heartbeats on the documented schedule,
+ * and answers ping tests. Audio, STT, and video come later; see plan.md.
+ *
+ * Build:  cc -O2 -o remchild remchild/client/main.c
+ * Run:    ./remchild --server 192.168.1.10:8799
+ */
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ifaddrs.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+
+#if defined(__linux__)
+#include <netpacket/packet.h>
+#endif
+
+#include "words.h"
+
+#define HEARTBEAT_FAST_MS 10000
+#define HEARTBEAT_MID_MS 30000
+#define HEARTBEAT_SLOW_MS 300000
+#define FAST_UNTIL_MS 60000
+#define MID_UNTIL_MS 360000
+#define LINE_MAX 4096
+
+static long now_ms(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
+}
+
+/* FNV-1a over the machine bytes: stable across restarts. */
+static unsigned long long fnv1a(const unsigned char *data, size_t len) {
+    unsigned long long hash = 1469598103934665603ULL;
+    for (size_t i = 0; i < len; i++) {
+        hash ^= data[i];
+        hash *= 1099511628211ULL;
+    }
+    return hash;
+}
+
+/* First non-loopback MAC. Returns 0 when no usable interface exists. */
+static int machine_mac(unsigned char *out6) {
+    struct ifaddrs *list = NULL;
+    int found = 0;
+
+    if (getifaddrs(&list) != 0) return 0;
+
+    for (struct ifaddrs *it = list; it && !found; it = it->ifa_next) {
+#if defined(__linux__)
+        if (!it->ifa_addr || it->ifa_addr->sa_family != AF_PACKET) continue;
+        if (it->ifa_flags & IFF_LOOPBACK) continue;
+
+        struct sockaddr_ll *addr = (struct sockaddr_ll *)it->ifa_addr;
+        if (addr->sll_halen != 6) continue;
+
+        int all_zero = 1;
+        for (int i = 0; i < 6; i++) {
+            out6[i] = addr->sll_addr[i];
+            if (out6[i]) all_zero = 0;
+        }
+        if (!all_zero) found = 1;
+#endif
+    }
+
+    freeifaddrs(list);
+    return found;
+}
+
+/* Fallback identity: /etc/machine-id. */
+static int machine_id(unsigned char *out, size_t cap) {
+    FILE *file = fopen("/etc/machine-id", "r");
+    if (!file) return 0;
+
+    size_t len = fread(out, 1, cap, file);
+    fclose(file);
+
+    while (len && (out[len - 1] == '\n' || out[len - 1] == '\r')) len--;
+    return (int)len;
+}
+
+/* Two words from the two lists. Same word on both sides bumps the second. */
+static void name_for_id(const unsigned char *id, size_t len, char *out, size_t cap) {
+    unsigned long long hash = fnv1a(id, len);
+    int first = (int)(hash % REMCHILD_WORD_COUNT);
+    int second = (int)((hash / REMCHILD_WORD_COUNT) % REMCHILD_WORD_COUNT);
+
+    if (second == first) second = (second + 1) % REMCHILD_WORD_COUNT;
+    snprintf(out, cap, "%s %s", REMCHILD_FIRST[first], REMCHILD_SECOND[second]);
+}
+
+static int connect_to(const char *host, int port) {
+    struct sockaddr_in addr = {0};
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons((unsigned short)port);
+
+    if (inet_pton(AF_INET, host, &addr.sin_addr) != 1) return -1;
+
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd < 0) return -1;
+
+    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
+        close(fd);
+        return -1;
+    }
+
+    int one = 1;
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
+    return fd;
+}
+
+static void send_line(int fd, const char *line) {
+    char frame[1024];
+    int len = snprintf(frame, sizeof(frame), "%s\n", line);
+
+    if (len <= 0 || send(fd, frame, (size_t)len, MSG_NOSIGNAL) != len) {
+        fprintf(stderr, "[remchild] send failed: %s\n", strerror(errno));
+    }
+}
+
+int main(int argc, char **argv) {
+    char host[128] = "";
+    int port = 8799;
+    int once = 0;
+
+    for (int i = 1; i < argc; i++) {
+        if (!strcmp(argv[i], "--server") && i + 1 < argc) {
+            char *value = argv[++i];
+            char *colon = strrchr(value, ':');
+            if (colon) {
+                *colon = 0;
+                port = atoi(colon + 1);
+            }
+            snprintf(host, sizeof(host), "%s", value);
+        } else if (!strcmp(argv[i], "--once")) {
+            once = 1;
+        } else if (!strcmp(argv[i], "--help")) {
+            printf("usage: remchild [--server host:port] [--once]\n");
+            return 0;
+        }
+    }
+
+    signal(SIGPIPE, SIG_IGN);
+    int interactive = isatty(STDIN_FILENO);
+
+    if (!host[0]) {
+        printf("Server address (host:port): ");
+        fflush(stdout);
+        char line[128];
+        if (!fgets(line, sizeof(line), stdin)) return 1;
+        line[strcspn(line, "\n")] = 0;
+        char *colon = strrchr(line, ':');
+        if (colon) {
+            *colon = 0;
+            port = atoi(colon + 1);
+        }
+        snprintf(host, sizeof(host), "%s", line);
+    }
+
+    unsigned char id[32];
+    size_t id_len = 0;
+    unsigned char mac[6];
+
+    if (machine_mac(mac)) {
+        memcpy(id, mac, 6);
+        id_len = 6;
+    } else {
+        int got = machine_id(id, sizeof(id));
+        if (got <= 0) {
+            fprintf(stderr, "[remchild] no MAC and no /etc/machine-id; cannot identify this host\n");
+            return 1;
+        }
+        id_len = (size_t)got;
+    }
+
+    char name[64];
+    name_for_id(id, id_len, name, sizeof(name));
+
+    char id_hex[17];
+    snprintf(id_hex, sizeof(id_hex), "%016llx", fnv1a(id, id_len));
+
+    printf("[remchild] identity %s  (name: %s)\n", id_len == 6 ? "MAC" : "machine-id", name);
+    printf("[remchild] connecting to %s:%d\n", host, port);
+
+    int fd = connect_to(host, port);
+    if (fd < 0) {
+        if (errno == ECONNREFUSED) {
+            fprintf(stderr, "[remchild] could not reach %s:%d: no server is listening there.\n", host, port);
+        } else {
+            fprintf(stderr,
+                    "[remchild] could not reach %s:%d (%s).\n"
+                    "[remchild] A firewall may block TCP %d on the server or on this host.\n",
+                    host, port, strerror(errno), port);
+        }
+        return 1;
+    }
+
+    printf("[remchild] connected. type p + Enter for a ping test, q + Enter to quit.\n");
+
+    char hello[512];
+    snprintf(hello, sizeof(hello),
+             "{\"type\":\"hello\",\"id\":\"%s\",\"name\":\"%s\",\"platform\":\"linux\",\"version\":\"0.1\"}",
+             id_hex, name);
+    send_line(fd, hello);
+
+    long started = now_ms();
+    long last_beat = started;
+    int ping_seq = 0;
+    long ping_sent_at = 0;
+    char buffer[LINE_MAX];
+    size_t used = 0;
+    int answered_ping = 0;
+
+    if (once) {
+        ping_seq = 1;
+        ping_sent_at = now_ms();
+        send_line(fd, "{\"type\":\"ping\",\"seq\":1}");
+    }
+
+    for (;;) {
+        long now = now_ms();
+        long interval = now - started < FAST_UNTIL_MS  ? HEARTBEAT_FAST_MS
+                        : now - started < MID_UNTIL_MS ? HEARTBEAT_MID_MS
+                                                       : HEARTBEAT_SLOW_MS;
+
+        if (now - last_beat >= interval) {
+            char beat[128];
+            snprintf(beat, sizeof(beat), "{\"type\":\"heartbeat\",\"ts\":%ld}", (long)time(NULL));
+            send_line(fd, beat);
+            last_beat = now;
+        }
+
+        struct pollfd fds[2] = {{fd, POLLIN, 0}, {STDIN_FILENO, interactive ? POLLIN : 0, 0}};
+        int ready = poll(fds, interactive ? 2 : 1, 500);
+        if (ready < 0 && errno != EINTR) break;
+
+        if (ready > 0 && (fds[0].revents & (POLLERR | POLLHUP))) {
+            printf("[remchild] server closed the connection\n");
+            break;
+        }
+
+        if (ready > 0 && (fds[0].revents & POLLIN)) {
+            ssize_t got = recv(fd, buffer + used, sizeof(buffer) - used - 1, 0);
+            if (got <= 0) {
+                printf("[remchild] server closed the connection\n");
+                break;
+            }
+            used += (size_t)got;
+            buffer[used] = 0;
+
+            char *line = buffer;
+            char *newline;
+            while ((newline = strchr(line, '\n'))) {
+                *newline = 0;
+                if (strstr(line, "\"type\":\"welcome\"")) {
+                    printf("[remchild] welcome: %s\n", line);
+                } else if (strstr(line, "\"type\":\"pong\"")) {
+                    if (ping_sent_at) printf("[remchild] pong seq=%d rtt=%ldms\n", ping_seq, now_ms() - ping_sent_at);
+                    answered_ping = 1;
+                } else if (strstr(line, "\"type\":\"ping\"")) {
+                    int seq = 0;
+                    sscanf(line, "%*[^\"]\"seq\":%d", &seq);
+                    char pong[64];
+                    snprintf(pong, sizeof(pong), "{\"type\":\"pong\",\"seq\":%d}", seq);
+                    send_line(fd, pong);
+                } else {
+                    printf("[remchild] server: %s\n", line);
+                }
+                line = newline + 1;
+            }
+
+            used = strlen(line);
+            memmove(buffer, line, used + 1);
+        }
+
+        if (ready > 0 && (fds[1].revents & POLLIN)) {
+            char input[128];
+            if (!fgets(input, sizeof(input), stdin)) break;
+            input[strcspn(input, "\n")] = 0;
+
+            if (!strcmp(input, "q")) break;
+            if (!strcmp(input, "p")) {
+                ping_seq++;
+                ping_sent_at = now_ms();
+                char ping[64];
+                snprintf(ping, sizeof(ping), "{\"type\":\"ping\",\"seq\":%d}", ping_seq);
+                send_line(fd, ping);
+            } else if (strcmp(input, "")) {
+                printf("[remchild] commands: p = ping test, q = quit\n");
+            }
+        }
+
+        if (once && (answered_ping || now - started > 5000)) break;
+    }
+
+    close(fd);
+    return 0;
+}