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
/* lpk.c — LordOS native app packages (.lpk).
*
* An .lpk is a tar (ustar), gzip-compressed or not, with:
* manifest.json id, name, version, permissions… (see docs/NATIVE-APPS.md)
* app.js the already bundled app (tools/lpk.mjs), which uses React and the theme SDK
* icon.png optional
* locales/<language>.json, *.wasm, images… optional
*
* It is installed without root, in ~/.local/share/lordos/apps/<id>/ (user-only). The rules:
* only regular files and folders (no links or devices), relative paths with letters,
* digits, '.', '-' and '_' (no "..", no components starting with '.'), at most
* LPK_MAX_FILES files and LPK_MAX_TOTAL bytes. It is decompressed in memory with stb_image's
* inflate, written to a new folder and swapped with the previous one via rename. */
#include "lpk.h"
#include "stb_image.h"
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <ftw.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#define LPK_MAX_ARCHIVE (96u * 1024 * 1024) /* the compressed file */
static void seterr(char *err, size_t n, const char *msg) { if (err && n) snprintf(err, n, "%s", msg); }
int lpk_valid_id(const char *id) {
size_t n = strlen(id);
if (n < 2 || n > 40 || id[0] < 'a' || id[0] > 'z') return 0;
for (const char *p = id; *p; p++) if (!(*p >= 'a' && *p <= 'z') && !isdigit((unsigned char)*p) && *p != '-') return 0;
return 1;
}
int lpk_valid_path(const char *rel) {
size_t n = strlen(rel);
if (!n || n >= sizeof ((LpkFile *)0)->path || rel[0] == '/') return 0;
int start = 1;
for (const char *p = rel; *p; p++) {
if (*p == '/') { if (start) return 0; start = 1; continue; }
if (start && *p == '.') return 0; /* ".", "..", hidden */
if (!isalnum((unsigned char)*p) && !strchr("._-", *p)) return 0;
start = 0;
}
return !start;
}
static unsigned long octal(const char *s, size_t n) {
unsigned long v = 0;
for (size_t i = 0; i < n && s[i]; i++) {
if (s[i] == ' ') continue;
if (s[i] < '0' || s[i] > '7') break;
v = v * 8 + (unsigned long)(s[i] - '0');
}
return v;
}
/* gzip (RFC 1952) → raw bytes; NULL if not valid gzip. */
static unsigned char *gunzip(const unsigned char *in, size_t len, size_t *outlen) {
if (len < 18 || in[0] != 0x1f || in[1] != 0x8b || in[2] != 8) return NULL;
int flg = in[3];
size_t p = 10;
if (flg & 4) { if (p + 2 > len) return NULL; p += 2 + (size_t)(in[p] | in[p + 1] << 8); }
if (flg & 8) { while (p < len && in[p]) p++; p++; }
if (flg & 16) { while (p < len && in[p]) p++; p++; }
if (flg & 2) p += 2;
if (p >= len - 8) return NULL;
uint32_t isize = (uint32_t)in[len - 4] | (uint32_t)in[len - 3] << 8 | (uint32_t)in[len - 2] << 16 | (uint32_t)in[len - 1] << 24;
if (isize > LPK_MAX_TOTAL + (uint32_t)LPK_MAX_FILES * 1024u) return NULL;
int out = 0;
char *r = stbi_zlib_decode_malloc_guesssize_headerflag((const char *)in + p, (int)(len - 8 - p), (int)isize + 1, &out, 0);
if (!r) return NULL;
if ((uint32_t)out != isize) { free(r); return NULL; }
*outlen = (size_t)out;
return (unsigned char *)r;
}
int lpk_open(const char *path, Lpk *out, char *err, size_t errlen) {
memset(out, 0, sizeof *out);
int fd = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
struct stat st;
if (fd < 0 || fstat(fd, &st) || !S_ISREG(st.st_mode) || st.st_size <= 0 || (unsigned long long)st.st_size > LPK_MAX_ARCHIVE) {
if (fd >= 0) close(fd);
seterr(err, errlen, "lpk.readFailed");
return -1;
}
size_t len = (size_t)st.st_size;
unsigned char *buf = malloc(len);
size_t got = 0;
while (buf && got < len) {
ssize_t r = read(fd, buf + got, len - got);
if (r < 0 && errno == EINTR) continue;
if (r <= 0) break;
got += (size_t)r;
}
close(fd);
if (!buf || got != len) { free(buf); seterr(err, errlen, "lpk.readFailed"); return -1; }
if (buf[0] == 0x1f && buf[1] == 0x8b) {
size_t n = 0;
unsigned char *raw = gunzip(buf, len, &n);
free(buf);
if (!raw) { seterr(err, errlen, "lpk.corruptGzip"); return -1; }
buf = raw;
len = n;
}
out->raw = buf;
out->files = calloc(LPK_MAX_FILES, sizeof *out->files);
if (!out->files) { lpk_free(out); seterr(err, errlen, "sys.outOfMemory"); return -1; }
size_t total = 0;
for (size_t off = 0; off + 512 <= len;) {
const char *h = (const char *)buf + off;
int empty = 1;
for (int i = 0; i < 512 && empty; i++) if (h[i]) empty = 0;
if (empty) break; /* end of the tar */
unsigned long sum = octal(h + 148, 8), calc = 0;
for (int i = 0; i < 512; i++) calc += (i >= 148 && i < 156) ? ' ' : (unsigned char)h[i];
if (sum != calc) { lpk_free(out); seterr(err, errlen, "lpk.corruptTar"); return -1; }
unsigned long size = octal(h + 124, 12);
char type = h[156];
char name[260];
if (!memcmp(h + 257, "ustar", 5) && h[345])
snprintf(name, sizeof name, "%.155s/%.100s", h + 345, h);
else snprintf(name, sizeof name, "%.100s", h);
size_t data = off + 512;
size_t next = data + ((size + 511) & ~511ul);
if (next > len || size > LPK_MAX_TOTAL) { lpk_free(out); seterr(err, errlen, "lpk.corruptSize"); return -1; }
size_t nl = strlen(name);
while (nl && name[nl - 1] == '/') name[--nl] = 0;
if (nl > 2 && name[0] == '.' && name[1] == '/') memmove(name, name + 2, (nl -= 2) + 1);
if (type == '5' || (type == 0 && nl == 0)) { off = next; continue; } /* folders: created on their own */
if (type == 'x' || type == 'g') { off = next; continue; } /* pax headers: ignored */
if (type != '0' && type != 0) { lpk_free(out); seterr(err, errlen, "lpk.specialFiles"); return -1; }
if (!lpk_valid_path(name)) { lpk_free(out); seterr(err, errlen, "lpk.badPath"); return -1; }
if (out->nfiles >= LPK_MAX_FILES || (total += size) > LPK_MAX_TOTAL) { lpk_free(out); seterr(err, errlen, "lpk.tooLarge"); return -1; }
if (lpk_find(out, name)) { lpk_free(out); seterr(err, errlen, "lpk.duplicateFiles"); return -1; }
LpkFile *f = &out->files[out->nfiles++];
snprintf(f->path, sizeof f->path, "%s", name);
f->data = buf + data;
f->size = size;
off = next;
}
if (!out->nfiles) { lpk_free(out); seterr(err, errlen, "lpk.empty"); return -1; }
return 0;
}
const LpkFile *lpk_find(const Lpk *p, const char *path) {
for (int i = 0; i < p->nfiles; i++) if (!strcmp(p->files[i].path, path)) return &p->files[i];
return NULL;
}
void lpk_free(Lpk *p) {
free(p->raw);
free(p->files);
memset(p, 0, sizeof *p);
}
const char *lpk_root(void) {
static char root[PATH_MAX];
const char *home = getenv("HOME");
if (!home) return NULL;
char tmp[PATH_MAX];
static const char *const parts[] = { "/.local", "/.local/share", "/.local/share/lordos", "/.local/share/lordos/apps" };
for (size_t i = 0; i < sizeof parts / sizeof *parts; i++) {
snprintf(tmp, sizeof tmp, "%s%s", home, parts[i]);
if (mkdir(tmp, 0755) && errno != EEXIST) return NULL;
}
snprintf(root, sizeof root, "%s", tmp);
return root;
}
static int rm_entry(const char *path, const struct stat *st, int flag, struct FTW *ftw) {
(void)st; (void)ftw;
return flag == FTW_DP ? rmdir(path) : unlink(path);
}
static int rm_tree(const char *path) {
struct stat st;
if (lstat(path, &st)) return errno == ENOENT ? 0 : -1;
if (!S_ISDIR(st.st_mode)) return unlink(path);
return nftw(path, rm_entry, 16, FTW_DEPTH | FTW_PHYS);
}
/* Creates the intermediate folders of rel inside base. */
static int make_parents(const char *base, const char *rel) {
char path[PATH_MAX];
int n = snprintf(path, sizeof path, "%s/%s", base, rel);
if (n < 0 || (size_t)n >= sizeof path) return -1;
for (char *p = path + strlen(base) + 1; *p; p++) {
if (*p != '/') continue;
*p = 0;
if (mkdir(path, 0755) && errno != EEXIST) return -1;
struct stat st;
if (lstat(path, &st) || !S_ISDIR(st.st_mode)) return -1;
*p = '/';
}
return 0;
}
int lpk_install(const Lpk *p, const char *id, char *err, size_t errlen) {
const char *root = lpk_root();
if (!root || !lpk_valid_id(id)) { seterr(err, errlen, "lpk.installHome"); return -1; }
char dst[PATH_MAX], tmp[PATH_MAX], old[PATH_MAX];
snprintf(dst, sizeof dst, "%s/%s", root, id);
snprintf(tmp, sizeof tmp, "%s/.%s.new", root, id);
snprintf(old, sizeof old, "%s/.%s.old", root, id);
rm_tree(tmp);
rm_tree(old);
if (mkdir(tmp, 0755)) { seterr(err, errlen, "lpk.mkdirFailed"); return -1; }
for (int i = 0; i < p->nfiles; i++) {
const LpkFile *f = &p->files[i];
char path[PATH_MAX];
int n = snprintf(path, sizeof path, "%s/%s", tmp, f->path);
int fd = n > 0 && (size_t)n < sizeof path && !make_parents(tmp, f->path)
? open(path, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC, 0644) : -1;
size_t w = 0;
while (fd >= 0 && w < f->size) {
ssize_t r = write(fd, f->data + w, f->size - w);
if (r < 0 && errno == EINTR) continue;
if (r <= 0) break;
w += (size_t)r;
}
if (fd < 0 || close(fd) || w != f->size) { rm_tree(tmp); seterr(err, errlen, "lpk.writeFailed"); return -1; }
}
struct stat st;
int had = !lstat(dst, &st);
if (had && rename(dst, old)) { rm_tree(tmp); seterr(err, errlen, "lpk.replaceFailed"); return -1; }
if (rename(tmp, dst)) {
if (had) rename(old, dst);
rm_tree(tmp);
seterr(err, errlen, "lpk.installFailed");
return -1;
}
if (had) rm_tree(old);
return 0;
}
int lpk_remove(const char *id) {
const char *root = lpk_root();
if (!root || !lpk_valid_id(id)) return -1;
char dst[PATH_MAX];
snprintf(dst, sizeof dst, "%s/%s", root, id);
struct stat st;
if (lstat(dst, &st) || !S_ISDIR(st.st_mode)) return -1;
return rm_tree(dst);
}