LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.
C cdebiandesktop-environmentebpffirewalllandlocklinuxlinux-distributionopen-sourceprivacyquickjsraspberry-pi-5reactsecuritywaylandwayland-compositor
/* wire.c — see wire.h. */
#include "wire.h"
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <unistd.h>
#ifndef F_SEAL_FUTURE_WRITE
#define F_SEAL_FUTURE_WRITE 0x0010
#endif
int doc_memfd_new(const char *name, size_t len) {
int fd = memfd_create(name, MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (fd < 0) return -1;
if (ftruncate(fd, (off_t)len)) { close(fd); return -1; }
return fd;
}
int doc_seal(int fd) { return fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL); }
int doc_memfd(const char *name, const void *data, size_t len) {
int fd = doc_memfd_new(name, len);
if (fd < 0) return -1;
const char *p = data;
size_t off = 0;
while (off < len) {
ssize_t w = pwrite(fd, p + off, len - off, (off_t)off);
if (w <= 0) { if (w < 0 && errno == EINTR) continue; close(fd); return -1; }
off += (size_t)w;
}
if (doc_seal(fd)) { close(fd); return -1; }
return fd;
}
long doc_check_sealed(int fd, size_t min) {
int seals = fcntl(fd, F_GET_SEALS);
if (seals < 0 || !(seals & F_SEAL_SHRINK)) return -1;
struct stat st;
if (fstat(fd, &st) || !S_ISREG(st.st_mode) || st.st_size < 0 || (size_t)st.st_size < min) return -1;
return (long)st.st_size;
}
int doc_send(int sock, uint32_t op, uint32_t id, const char *json, size_t len, const int *fds, int nfds) {
if (nfds < 0 || nfds > DOC_MAX_FDS - 1) { errno = EINVAL; return -1; }
int all[DOC_MAX_FDS];
int n = 0, jfd = -1;
DocHdr h = { op, id, 0, 0 };
if (json && len > DOC_INLINE_MAX) {
jfd = doc_memfd("lord-doc-json", json, len);
if (jfd < 0) return -1;
all[n++] = jfd;
h.flags |= DOCF_JSON_FD;
} else if (json) h.len = (uint32_t)len;
for (int i = 0; i < nfds; i++) all[n++] = fds[i];
struct iovec iov[2] = { { &h, sizeof h }, { (void *)(json && !(h.flags & DOCF_JSON_FD) ? json : ""), h.len } };
union { char buf[CMSG_SPACE(sizeof(int) * DOC_MAX_FDS)]; struct cmsghdr align; } u;
struct msghdr msg = { .msg_iov = iov, .msg_iovlen = 2 };
if (n) {
memset(&u, 0, sizeof u);
msg.msg_control = u.buf;
msg.msg_controllen = CMSG_SPACE(sizeof(int) * (size_t)n);
struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
c->cmsg_level = SOL_SOCKET;
c->cmsg_type = SCM_RIGHTS;
c->cmsg_len = CMSG_LEN(sizeof(int) * (size_t)n);
memcpy(CMSG_DATA(c), all, sizeof(int) * (size_t)n);
}
ssize_t r;
do r = sendmsg(sock, &msg, MSG_NOSIGNAL); while (r < 0 && errno == EINTR);
if (jfd >= 0) close(jfd);
return r < 0 ? -1 : 0;
}
void doc_msg_free(DocMsg *m) {
free(m->json);
for (int i = 0; i < m->nfds; i++) if (m->fds[i] >= 0) close(m->fds[i]);
memset(m, 0, sizeof *m);
}
int doc_recv(int sock, DocMsg *m) {
memset(m, 0, sizeof *m);
char *buf = malloc(sizeof(DocHdr) + DOC_INLINE_MAX + 1);
if (!buf) return -1;
union { char buf[CMSG_SPACE(sizeof(int) * DOC_MAX_FDS)]; struct cmsghdr align; } u;
struct iovec iov = { buf, sizeof(DocHdr) + DOC_INLINE_MAX };
struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1, .msg_control = u.buf, .msg_controllen = sizeof u.buf };
ssize_t r;
do r = recvmsg(sock, &msg, MSG_CMSG_CLOEXEC); while (r < 0 && errno == EINTR);
/* fds first: if the message is invalid they still have to be closed */
for (struct cmsghdr *c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level != SOL_SOCKET || c->cmsg_type != SCM_RIGHTS) continue;
int k = (int)((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
int tmp[DOC_MAX_FDS];
if (k > DOC_MAX_FDS) k = DOC_MAX_FDS;
memcpy(tmp, CMSG_DATA(c), sizeof(int) * (size_t)k);
for (int i = 0; i < k; i++) { if (m->nfds < DOC_MAX_FDS) m->fds[m->nfds++] = tmp[i]; else close(tmp[i]); }
}
if (r == 0) { free(buf); doc_msg_free(m); return 1; }
if (r < 0 || (size_t)r < sizeof(DocHdr) || (msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC))) { free(buf); doc_msg_free(m); return -1; }
memcpy(&m->h, buf, sizeof m->h);
size_t body = (size_t)r - sizeof(DocHdr);
if (m->h.flags & DOCF_JSON_FD) {
free(buf);
if (m->nfds < 1) { doc_msg_free(m); return -1; }
int jfd = m->fds[0];
long sz = doc_check_sealed(jfd, 0);
if (sz < 0 || sz > DOC_JSON_MAX) { doc_msg_free(m); return -1; }
m->json = malloc((size_t)sz + 1);
if (!m->json) { doc_msg_free(m); return -1; }
size_t off = 0;
while (off < (size_t)sz) {
ssize_t g = pread(jfd, m->json + off, (size_t)sz - off, (off_t)off);
if (g <= 0) { if (g < 0 && errno == EINTR) continue; doc_msg_free(m); return -1; }
off += (size_t)g;
}
m->json[sz] = 0;
m->len = (size_t)sz;
close(jfd);
memmove(m->fds, m->fds + 1, sizeof(int) * (size_t)(m->nfds - 1));
m->nfds--;
return 0;
}
if (m->h.len != body) { free(buf); doc_msg_free(m); return -1; }
if (body) {
memmove(buf, buf + sizeof(DocHdr), body);
buf[body] = 0;
m->json = buf;
m->len = body;
} else free(buf);
return 0;
}
/* ---- JSON ---- */
void jb_init(JBuf *b) { memset(b, 0, sizeof *b); }
void jb_free(JBuf *b) { free(b->p); memset(b, 0, sizeof *b); }
static int jb_grow(JBuf *b, size_t extra) {
if (b->oom) return -1;
if (b->n + extra + 1 <= b->cap) return 0;
size_t cap = b->cap ? b->cap : 256;
while (cap < b->n + extra + 1) cap *= 2;
if (cap > DOC_JSON_MAX + 1024) { b->oom = 1; return -1; }
char *p = realloc(b->p, cap);
if (!p) { b->oom = 1; return -1; }
b->p = p;
b->cap = cap;
return 0;
}
static void jb_put(JBuf *b, const char *s, size_t n) {
if (jb_grow(b, n)) return;
memcpy(b->p + b->n, s, n);
b->n += n;
b->p[b->n] = 0;
}
void jb_raw(JBuf *b, const char *s) { jb_put(b, s, strlen(s)); }
void jb_printf(JBuf *b, const char *fmt, ...) {
char tmp[512];
va_list ap;
va_start(ap, fmt);
int k = vsnprintf(tmp, sizeof tmp, fmt, ap);
va_end(ap);
if (k < 0) return;
if ((size_t)k < sizeof tmp) { jb_put(b, tmp, (size_t)k); return; }
if (jb_grow(b, (size_t)k)) return;
va_start(ap, fmt);
vsnprintf(b->p + b->n, (size_t)k + 1, fmt, ap);
va_end(ap);
b->n += (size_t)k;
}
void jb_num(JBuf *b, double v) {
if (!isfinite(v)) v = 0;
if (v == (double)(long long)v && fabs(v) < 1e15) jb_printf(b, "%lld", (long long)v);
else jb_printf(b, "%.4f", v);
}
/* Length of a valid UTF-8 sequence in s (0 if it isn't one). */
static int utf8_len(const unsigned char *s, size_t n) {
if (s[0] < 0x80) return 1;
int k = s[0] >= 0xf0 && s[0] <= 0xf4 ? 4 : s[0] >= 0xe0 ? 3 : s[0] >= 0xc2 && s[0] < 0xe0 ? 2 : 0;
if (!k || (size_t)k > n) return 0;
for (int i = 1; i < k; i++) if ((s[i] & 0xc0) != 0x80) return 0;
if (k == 3 && s[0] == 0xe0 && s[1] < 0xa0) return 0;
if (k == 3 && s[0] == 0xed && s[1] >= 0xa0) return 0; /* surrogates */
if (k == 4 && s[0] == 0xf0 && s[1] < 0x90) return 0;
if (k == 4 && s[0] == 0xf4 && s[1] >= 0x90) return 0;
return k;
}
void jb_strn(JBuf *b, const char *str, size_t n) {
const unsigned char *s = (const unsigned char *)str;
jb_put(b, "\"", 1);
for (size_t i = 0; i < n;) {
unsigned char ch = s[i];
if (ch == '"' || ch == '\\') { char e[2] = { '\\', (char)ch }; jb_put(b, e, 2); i++; continue; }
if (ch < 0x20) {
if (ch == '\n') jb_put(b, "\\n", 2);
else if (ch == '\t') jb_put(b, "\\t", 2);
else if (ch == '\r') jb_put(b, "\\r", 2);
else jb_printf(b, "\\u%04x", ch);
i++;
continue;
}
int k = utf8_len(s + i, n - i);
if (!k) { jb_put(b, "\xef\xbf\xbd", 3); i++; continue; }
jb_put(b, (const char *)s + i, (size_t)k);
i += (size_t)k;
}
jb_put(b, "\"", 1);
}
void jb_str(JBuf *b, const char *s) { jb_strn(b, s ? s : "", s ? strlen(s) : 0); }