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
/* idx.c — building and reading the package index (see idx.h). */
#include "idx.h"
#include "../errcode.h"
#include "deb.h"
#include "crypto.h"
#include "pin.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
/* ---- reading ---- */
/* Each record's priority under apt's preferences (none: the index's source priorities). */
static void idx_pins(Idx *x) {
free(x->prio);
x->prio = NULL;
x->pin_stamp = pin_stamp();
PinSet *set = pin_load();
if (!set) return;
x->prio = malloc(sizeof *x->prio * (x->h->npkg ? x->h->npkg : 1));
if (x->prio)
for (long i = 0; i < (long)x->h->npkg; i++) x->prio[i] = (int16_t)pin_priority(set, x, i);
pin_free(set);
}
int idx_open(Idx *x, const char *dir) {
memset(x, 0, sizeof *x);
char path[512];
snprintf(path, sizeof path, "%s/index.bin", dir);
int fd = open(path, O_RDONLY | O_CLOEXEC);
if (fd < 0) return -1;
struct stat st;
if (fstat(fd, &st) || st.st_size < (off_t)sizeof(IdxHeader)) { close(fd); return -1; }
void *m = mmap(NULL, (size_t)st.st_size, PROT_READ, MAP_SHARED, fd, 0);
close(fd);
if (m == MAP_FAILED) return -1;
const IdxHeader *h = m;
size_t len = (size_t)st.st_size;
#define SEC_OK(off, n, sz) ((uint64_t)(off) + (uint64_t)(n) * (sz) <= len && (off) % 4 == 0)
if (memcmp(h->magic, IDX_MAGIC, 8) || !SEC_OK(h->off_pkg, h->npkg, sizeof(IdxPkg)) ||
!SEC_OK(h->off_prov, h->nprov, sizeof(IdxProv)) || !SEC_OK(h->off_app, h->napp, sizeof(IdxApp)) ||
!SEC_OK(h->off_src, h->nsrc, sizeof(IdxSrc)) || !SEC_OK(h->off_str, h->len_str, 1) || !h->len_str ||
!SEC_OK(h->off_desc, h->len_desc, 1) || ((const char *)m)[h->off_str + h->len_str - 1]) {
munmap(m, len);
return -1;
}
#undef SEC_OK
x->h = h;
x->map = m;
x->map_len = len;
x->pkg = (const IdxPkg *)((const char *)m + h->off_pkg);
x->prov = (const IdxProv *)((const char *)m + h->off_prov);
x->app = (const IdxApp *)((const char *)m + h->off_app);
x->src = (const IdxSrc *)((const char *)m + h->off_src);
x->str = (const char *)m + h->off_str;
x->str_len = h->len_str;
x->desc = (const char *)m + h->off_desc;
x->desc_len = h->len_desc;
x->mtime = (long)st.st_mtime;
x->ino = (long)st.st_ino;
idx_pins(x);
return 0;
}
void idx_close(Idx *x) {
if (x->map) munmap(x->map, x->map_len);
free(x->prio);
memset(x, 0, sizeof *x);
}
int idx_refresh(Idx *x, const char *dir) {
char path[512];
snprintf(path, sizeof path, "%s/index.bin", dir);
struct stat st;
if (stat(path, &st)) { if (x->map) { idx_close(x); return 1; } return 0; }
if (x->map && (long)st.st_ino == x->ino && (long)st.st_mtime == x->mtime) {
if (pin_stamp() == x->pin_stamp) return 0;
idx_pins(x); /* the preferences changed: same index, new priorities */
return 1;
}
Idx n;
if (idx_open(&n, dir)) return 0;
idx_close(x);
*x = n;
return 1;
}
static int name_cmp(const char *s, const char *k, size_t n) {
int c = strncmp(s, k, n);
if (c) return c;
return s[n] ? 1 : 0;
}
long idx_find(const Idx *x, const char *name, size_t n) {
if (!x->map) return -1;
long lo = 0, hi = (long)x->h->npkg;
while (lo < hi) {
long mid = (lo + hi) / 2;
if (name_cmp(idx_s(x, x->pkg[mid].name), name, n) < 0) lo = mid + 1; else hi = mid;
}
return lo < (long)x->h->npkg && !name_cmp(idx_s(x, x->pkg[lo].name), name, n) ? lo : -1;
}
void idx_providers(const Idx *x, const char *name, size_t n, long *plo, long *phi) {
*plo = *phi = 0;
if (!x->map) return;
long lo = 0, hi = (long)x->h->nprov;
while (lo < hi) {
long mid = (lo + hi) / 2;
if (name_cmp(idx_s(x, x->prov[mid].name), name, n) < 0) lo = mid + 1; else hi = mid;
}
long e = lo;
while (e < (long)x->h->nprov && !name_cmp(idx_s(x, x->prov[e].name), name, n)) e++;
*plo = lo;
*phi = e;
}
/* ---- building ---- */
struct IdxBuilder {
char *str;
size_t slen, scap;
uint32_t *ht; /* interned strings (UINT32_MAX = free) */
size_t htcap, htn;
IdxPkg *pk;
uint8_t (*md5)[16];
uint8_t *hasmd5;
size_t npk, cappk, capmd5;
int32_t *mnext, *mht; /* md5 → packages */
size_t mhtcap;
IdxSrc src[64];
int nsrc;
char *desc;
size_t dlen, dcap;
IdxApp *app;
size_t napp, capapp;
uint32_t *icons; /* set of icon names */
size_t iconcap, nicons;
};
static uint32_t fnv(const char *s, size_t n) {
uint32_t h = 2166136261u;
for (size_t i = 0; i < n; i++) { h ^= (uint8_t)s[i]; h *= 16777619u; }
return h;
}
static int grow(void **p, size_t *cap, size_t need, size_t elem) {
if (need <= *cap) return 0;
size_t c = *cap ? *cap : 1024;
while (c < need) c *= 2;
void *n = realloc(*p, c * elem);
if (!n) return -1;
*p = n;
*cap = c;
return 0;
}
static int ht_rehash(IdxBuilder *b) {
size_t cap = b->htcap ? b->htcap * 2 : 1 << 16;
uint32_t *n = malloc(cap * sizeof *n);
if (!n) return -1;
memset(n, 0xff, cap * sizeof *n);
for (size_t i = 0; i < b->htcap; i++) {
uint32_t o = b->ht[i];
if (o == UINT32_MAX) continue;
size_t j = fnv(b->str + o, strlen(b->str + o)) & (cap - 1);
while (n[j] != UINT32_MAX) j = (j + 1) & (cap - 1);
n[j] = o;
}
free(b->ht);
b->ht = n;
b->htcap = cap;
return 0;
}
/* Interns a string (without repeats); returns its offset or UINT32_MAX if out of memory. */
static uint32_t intern(IdxBuilder *b, const char *s, size_t n) {
if (!n) return 0;
if ((b->htn + 1) * 2 > b->htcap && ht_rehash(b)) return UINT32_MAX;
size_t j = fnv(s, n) & (b->htcap - 1);
while (b->ht[j] != UINT32_MAX) {
const char *t = b->str + b->ht[j];
if (!strncmp(t, s, n) && !t[n]) return b->ht[j];
j = (j + 1) & (b->htcap - 1);
}
if (b->slen + n + 1 > UINT32_MAX - 1 || grow((void **)&b->str, &b->scap, b->slen + n + 1, 1)) return UINT32_MAX;
uint32_t o = (uint32_t)b->slen;
memcpy(b->str + b->slen, s, n);
b->str[b->slen + n] = 0;
b->slen += n + 1;
b->ht[j] = o;
b->htn++;
return o;
}
static uint32_t intern_z(IdxBuilder *b, const char *s) { return intern(b, s, s ? strlen(s) : 0); }
IdxBuilder *idxb_new(void) {
IdxBuilder *b = calloc(1, sizeof *b);
if (!b) return NULL;
if (grow((void **)&b->str, &b->scap, 1, 1)) { free(b); return NULL; }
b->str[0] = 0;
b->slen = 1;
return b;
}
void idxb_free(IdxBuilder *b) {
if (!b) return;
free(b->str); free(b->ht); free(b->pk); free(b->md5); free(b->hasmd5); free(b->mnext); free(b->mht);
free(b->desc); free(b->app); free(b->icons);
free(b);
}
uint32_t idxb_count(const IdxBuilder *b) { return (uint32_t)b->npk; }
int idxb_source(IdxBuilder *b, const char *uri, const char *suite, const char *component, const char *codename,
const char *origin, const char *label, int64_t date, int64_t valid_until, int prio) {
if (b->nsrc >= 64) return -1;
IdxSrc *s = &b->src[b->nsrc];
memset(s, 0, sizeof *s);
s->uri = intern_z(b, uri);
s->suite = intern_z(b, suite);
s->component = intern_z(b, component);
s->codename = intern_z(b, codename);
s->origin = intern_z(b, origin);
s->label = intern_z(b, label);
s->date = date;
s->valid_until = valid_until;
s->prio = (uint32_t)prio;
return b->nsrc++;
}
static uint32_t put_desc(IdxBuilder *b, const char *s, size_t n, uint32_t *len) {
/* Debian "Description": lines with a leading space; " ." is an empty paragraph */
if (grow((void **)&b->desc, &b->dcap, b->dlen + n + 1, 1)) { *len = 0; return 0; }
uint32_t start = (uint32_t)b->dlen;
const char *p = s, *e = s + n;
int first = 1;
while (p < e) {
const char *nl = memchr(p, '\n', (size_t)(e - p));
if (!nl) nl = e;
const char *l = p;
size_t ll = (size_t)(nl - p);
if (ll && *l == ' ') { l++; ll--; }
if (ll == 1 && *l == '.') ll = 0;
if (!first) b->desc[b->dlen++] = '\n';
first = 0;
memcpy(b->desc + b->dlen, l, ll);
b->dlen += ll;
p = nl + 1;
}
*len = (uint32_t)(b->dlen - start);
return start;
}
static int prio_of(const char *v, size_t n) {
static const char *const names[] = { "required", "important", "standard", "optional", "extra" };
for (int i = 0; i < 5; i++) if (strlen(names[i]) == n && !strncmp(v, names[i], n)) return i + 1;
return PRIO_UNKNOWN;
}
#define FIELD(name) (d822_is(&f, name))
int idxb_packages(IdxBuilder *b, int src, const char *buf, size_t len, const char *arch) {
const char *pos = buf, *end = buf + len, *st, *se;
size_t archlen = strlen(arch);
uint32_t count = 0;
while (d822_next_stanza(&pos, end, &st, &se)) {
D822 it = { st, se };
D822Field f;
IdxPkg p;
memset(&p, 0, sizeof p);
p.app = UINT32_MAX;
p.src = (uint16_t)src;
uint8_t md5[16];
int hasmd5 = 0, ok_arch = 0, has_sha = 0;
const char *name = NULL, *desc = NULL;
size_t namelen = 0, desclen = 0;
while (d822_next_field(&it, &f)) {
const char *v = f.value;
size_t n = f.vlen;
switch (f.name[0] | 0x20) {
case 'a':
if (FIELD("Architecture")) { p.arch = intern(b, v, n); ok_arch = (n == archlen && !strncmp(v, arch, n)) || (n == 3 && !strncmp(v, "all", 3)); }
break;
case 'b':
if (FIELD("Breaks")) p.breaks = intern(b, v, n);
break;
case 'c':
if (FIELD("Conflicts")) p.conflicts = intern(b, v, n);
break;
case 'd':
if (FIELD("Depends")) p.depends = intern(b, v, n);
else if (FIELD("Description")) { desc = v; desclen = n; }
else if (FIELD("Description-md5") && n == 32 && !hex_decode(v, md5, 16)) hasmd5 = 1;
break;
case 'e':
if (FIELD("Essential") && n == 3 && !strncmp(v, "yes", 3)) p.flags |= IF_ESSENTIAL;
break;
case 'f':
if (FIELD("Filename")) p.filename = intern(b, v, n);
break;
case 'h':
if (FIELD("Homepage")) p.homepage = intern(b, v, n);
break;
case 'i':
if (FIELD("Installed-Size")) p.isize = (uint32_t)strtoul(v, NULL, 10);
break;
case 'm':
if (FIELD("Multi-Arch")) {
if (n == 4 && !strncmp(v, "same", 4)) p.flags |= IF_MA_SAME;
else if (n == 7 && !strncmp(v, "foreign", 7)) p.flags |= IF_MA_FOREIGN;
else if (n == 7 && !strncmp(v, "allowed", 7)) p.flags |= IF_MA_ALLOWED;
}
break;
case 'p':
if (FIELD("Package")) { name = v; namelen = n; }
else if (FIELD("Pre-Depends")) p.predepends = intern(b, v, n);
else if (FIELD("Provides")) p.provides = intern(b, v, n);
else if (FIELD("Priority")) p.prio = (uint8_t)prio_of(v, n);
else if (FIELD("Protected") && n == 3 && !strncmp(v, "yes", 3)) p.flags |= IF_PROTECTED;
break;
case 'r':
if (FIELD("Recommends")) p.recommends = intern(b, v, n);
else if (FIELD("Replaces")) p.replaces = intern(b, v, n);
break;
case 's':
if (FIELD("Size")) p.size = (uint32_t)strtoul(v, NULL, 10);
else if (FIELD("SHA256") && n == 64 && !hex_decode(v, p.sha256, 32)) has_sha = 1;
else if (FIELD("Section")) p.section = intern(b, v, n);
else if (FIELD("Suggests")) p.suggests = intern(b, v, n);
else if (FIELD("Source")) p.source = intern(b, v, n);
break;
case 'v':
if (FIELD("Version")) p.version = intern(b, v, n);
break;
}
}
if (!name || !ok_arch || !p.version || !p.filename || !has_sha || !deb_valid_name(name, namelen)) continue;
/* names with a slash or .. in Filename are rejected: they're downloaded to a fixed name, but still */
const char *fn = b->str + p.filename;
if (strstr(fn, "..") || fn[0] == '/') continue;
p.name = intern(b, name, namelen);
if (desc) {
const char *nl = memchr(desc, '\n', desclen);
size_t sl = nl ? (size_t)(nl - desc) : desclen;
p.summary = intern(b, desc, sl);
if (nl) p.desc = put_desc(b, nl + 1, desclen - sl - 1, &p.desclen);
}
if (grow((void **)&b->pk, &b->cappk, b->npk + 1, sizeof *b->pk)) return -1;
if (b->cappk > b->capmd5) { /* parallel arrays with the same capacity */
uint8_t (*nm)[16] = realloc(b->md5, b->cappk * 16);
if (!nm) return -1;
b->md5 = nm;
uint8_t *nh = realloc(b->hasmd5, b->cappk);
if (!nh) return -1;
b->hasmd5 = nh;
b->capmd5 = b->cappk;
}
b->pk[b->npk] = p;
if (hasmd5) memcpy(b->md5[b->npk], md5, 16);
b->hasmd5[b->npk] = (uint8_t)(hasmd5 && !p.desclen);
b->npk++;
count++;
if (p.name == UINT32_MAX || p.version == UINT32_MAX) return -1;
}
b->src[src].npkgs += count;
return 0;
}
static uint32_t md5h(const uint8_t *m) { return (uint32_t)m[0] | (uint32_t)m[1] << 8 | (uint32_t)m[2] << 16 | (uint32_t)m[3] << 24; }
static int build_md5_map(IdxBuilder *b) {
if (b->mht) return 0;
size_t cap = 1;
while (cap < b->npk * 2) cap <<= 1;
b->mht = malloc(cap * sizeof *b->mht);
b->mnext = malloc((b->npk ? b->npk : 1) * sizeof *b->mnext);
if (!b->mht || !b->mnext) return -1;
memset(b->mht, 0xff, cap * sizeof *b->mht);
b->mhtcap = cap;
for (size_t i = 0; i < b->npk; i++) {
b->mnext[i] = -1;
if (!b->hasmd5[i]) continue;
uint32_t h = md5h(b->md5[i]) & (uint32_t)(cap - 1);
b->mnext[i] = b->mht[h];
b->mht[h] = (int32_t)i;
}
return 0;
}
int idxb_translation(IdxBuilder *b, const char *buf, size_t len) {
if (build_md5_map(b)) return -1;
const char *pos = buf, *end = buf + len, *st, *se;
while (d822_next_stanza(&pos, end, &st, &se)) {
D822 it = { st, se };
D822Field f;
uint8_t md5[16];
int has = 0;
const char *d = NULL;
size_t dl = 0;
while (d822_next_field(&it, &f)) {
if (d822_is(&f, "Description-md5") && f.vlen == 32 && !hex_decode(f.value, md5, 16)) has = 1;
else if (d822_is(&f, "Description-en")) { d = f.value; dl = f.vlen; }
}
if (!has || !d) continue;
const char *nl = memchr(d, '\n', dl);
if (!nl) continue;
uint32_t off = 0, olen = 0;
int done = 0;
for (int32_t i = b->mht[md5h(md5) & (uint32_t)(b->mhtcap - 1)]; i >= 0; i = b->mnext[i]) {
if (!b->hasmd5[i] || memcmp(b->md5[i], md5, 16)) continue;
if (!done) { off = put_desc(b, nl + 1, dl - (size_t)(nl + 1 - d), &olen); done = 1; }
b->pk[i].desc = off;
b->pk[i].desclen = olen;
b->hasmd5[i] = 0;
}
}
return 0;
}
/* ---- DEP-11 (AppStream) ---- */
/* Trims trailing spaces and leaves exactly n line breaks (if there's already text). */
static void line_break(char *out, size_t *o, int n) {
while (*o && (out[*o - 1] == ' ' || out[*o - 1] == '\n')) (*o)--;
if (*o) while (n--) out[(*o)++] = '\n';
}
/* AppStream HTML (<p>, <ul><li>, <em>, <code>) to plain text. */
static size_t html_text(const char *s, size_t n, char *out, size_t cap) {
size_t o = 0;
int par = 0; /* a paragraph has to be started before the next text */
for (size_t i = 0; i < n && o + 8 < cap;) {
if (s[i] == '<') {
const char *gt = memchr(s + i, '>', n - i);
if (!gt) break;
size_t tl = (size_t)(gt - (s + i)) + 1;
if (!strncmp(s + i, "<p>", 3) || !strncmp(s + i, "<ul>", 4) || !strncmp(s + i, "<ol>", 4)) par = 1;
else if (!strncmp(s + i, "<li>", 4)) {
line_break(out, &o, par ? 2 : 1);
par = 0;
memcpy(out + o, "\xe2\x80\xa2 ", 4); /* "• " */
o += 4;
}
i += tl;
continue;
}
char c = s[i];
if (c == '\n' || c == '\t' || c == '\r') c = ' ';
if (c == ' ' && (!o || out[o - 1] == ' ' || out[o - 1] == '\n')) { i++; continue; }
if (par) { line_break(out, &o, 2); par = 0; }
if (c == '&') {
static const struct { const char *e; char c; } ent[] = { { "&", '&' }, { "<", '<' }, { ">", '>' }, { """, '"' }, { "'", '\'' }, { "'", '\'' } };
int hit = 0;
for (size_t k = 0; k < sizeof ent / sizeof *ent; k++) {
size_t el = strlen(ent[k].e);
if (n - i >= el && !strncmp(s + i, ent[k].e, el)) { out[o++] = ent[k].c; i += el; hit = 1; break; }
}
if (hit) continue;
}
out[o++] = c;
i++;
}
line_break(out, &o, 0);
out[o] = 0;
return o;
}
/* YAML scalar value on one line: unquoted or with '…' / "…". */
static size_t yaml_scalar(const char *v, size_t n, char *out, size_t cap) {
size_t o = 0;
if (n && v[0] == '\'') {
for (size_t i = 1; i < n && o + 1 < cap; i++) {
if (v[i] == '\'') { if (i + 1 < n && v[i + 1] == '\'') { out[o++] = '\''; i++; continue; } break; }
out[o++] = v[i];
}
} else if (n && v[0] == '"') {
for (size_t i = 1; i < n && o + 1 < cap; i++) {
if (v[i] == '"') break;
if (v[i] == '\\' && i + 1 < n) { i++; out[o++] = v[i] == 'n' ? '\n' : v[i] == 't' ? '\t' : v[i]; continue; }
out[o++] = v[i];
}
} else {
while (n && (v[n - 1] == ' ' || v[n - 1] == '\r')) n--;
if (n >= cap) n = cap - 1;
memcpy(out, v, n);
o = n;
}
out[o] = 0;
return o;
}
typedef struct {
char type[32], id[256], package[128], cats[256], icon[256];
char name[3][256], summary[3][512];
char *desc;
size_t dlen, dcap;
int icon_w;
} App;
static void app_store(IdxBuilder *b, App *a) {
if (!a->id[0] || !a->package[0] || !deb_valid_name(a->package, strlen(a->package))) return;
if (grow((void **)&b->app, &b->capapp, b->napp + 1, sizeof *b->app)) return;
IdxApp *x = &b->app[b->napp++];
memset(x, 0, sizeof *x);
x->id = intern_z(b, a->id);
x->package = intern_z(b, a->package);
x->type = intern_z(b, a->type);
x->name = intern_z(b, a->name[0]);
x->summary = intern_z(b, a->summary[0]);
x->name_es = intern_z(b, a->name[1]);
x->summary_es = intern_z(b, a->summary[1]);
x->name_pt = intern_z(b, a->name[2]);
x->summary_pt = intern_z(b, a->summary[2]);
x->categories = intern_z(b, a->cats);
x->icon = intern_z(b, a->icon);
x->desc = UINT32_MAX;
if (a->dlen) { /* in the descriptions block, 0-terminated */
char *t = malloc(a->dlen + 16);
if (t) {
size_t tl = html_text(a->desc, a->dlen, t, a->dlen + 16);
if (tl && !grow((void **)&b->desc, &b->dcap, b->dlen + tl + 1, 1)) {
x->desc = (uint32_t)b->dlen;
memcpy(b->desc + b->dlen, t, tl + 1);
b->dlen += tl + 1;
}
free(t);
}
}
if (a->icon[0]) {
uint32_t o = x->icon;
if ((b->nicons + 1) * 2 > b->iconcap) {
size_t cap = b->iconcap ? b->iconcap * 2 : 4096;
uint32_t *n = malloc(cap * sizeof *n);
if (!n) return;
memset(n, 0xff, cap * sizeof *n);
for (size_t i = 0; i < b->iconcap; i++) if (b->icons[i] != UINT32_MAX) {
size_t j = fnv(b->str + b->icons[i], strlen(b->str + b->icons[i])) & (cap - 1);
while (n[j] != UINT32_MAX) j = (j + 1) & (cap - 1);
n[j] = b->icons[i];
}
free(b->icons);
b->icons = n;
b->iconcap = cap;
}
size_t j = fnv(b->str + o, strlen(b->str + o)) & (b->iconcap - 1);
while (b->icons[j] != UINT32_MAX && b->icons[j] != o) j = (j + 1) & (b->iconcap - 1);
if (b->icons[j] == UINT32_MAX) { b->icons[j] = o; b->nicons++; }
}
}
int idxb_icon_wanted(IdxBuilder *b, const char *name) {
if (!b->iconcap) return 0;
size_t n = strlen(name);
size_t j = fnv(name, n) & (b->iconcap - 1);
while (b->icons[j] != UINT32_MAX) {
if (!strcmp(b->str + b->icons[j], name)) return 1;
j = (j + 1) & (b->iconcap - 1);
}
return 0;
}
static int lang_slot(const char *k, size_t n) {
if (n == 1 && k[0] == 'C') return 0;
if (n == 2 && !strncmp(k, "es", 2)) return 1;
if (n == 2 && !strncmp(k, "pt", 2)) return 2;
if (n == 5 && !strncmp(k, "pt-BR", 5)) return 3; /* if there's no pt */
return -1;
}
int idxb_appstream(IdxBuilder *b, const char *buf, size_t len) {
App a;
memset(&a, 0, sizeof a);
const char *p = buf, *end = buf + len;
char top[32] = "";
int in_cached = 0, block = 0, block_desc = 0, cont_slot = -1, cont_is_name = 0, cur_icon_set = 0;
char cur_icon[256] = "";
for (;;) {
const char *nl = p < end ? memchr(p, '\n', (size_t)(end - p)) : NULL;
const char *le = nl ? nl : end;
size_t ll = (size_t)(le - p);
int doc_end = p >= end || (ll >= 3 && !strncmp(p, "---", 3));
size_t ind = 0;
while (ind < ll && p[ind] == ' ') ind++;
/* literal block (>- / |): empty lines or with indentation ≥ 4 */
if (block && !doc_end && (ind == ll || ind >= 4)) {
if (block_desc) {
const char *t = p + (ind < 4 ? ind : 4);
size_t tl = (size_t)(le - t);
if (!grow((void **)&a.desc, &a.dcap, a.dlen + tl + 2, 1)) {
if (a.dlen) a.desc[a.dlen++] = ind == ll ? '\n' : ' ';
memcpy(a.desc + a.dlen, t, tl);
a.dlen += tl;
}
}
goto next;
}
block = block_desc = 0;
if (cont_slot >= 0 && !doc_end && ind >= 4 && ind < ll) { /* split plain scalar */
char *dst = cont_is_name ? a.name[cont_slot] : a.summary[cont_slot];
size_t cap = cont_is_name ? sizeof a.name[0] : sizeof a.summary[0], dl = strlen(dst);
snprintf(dst + dl, cap - dl, " %.*s", (int)(ll - ind), p + ind);
goto next;
}
cont_slot = -1;
if (doc_end) {
if (cur_icon_set && !a.icon[0]) snprintf(a.icon, sizeof a.icon, "%s", cur_icon);
if (a.type[0]) app_store(b, &a);
char *keep = a.desc;
size_t kc = a.dcap;
memset(&a, 0, sizeof a);
a.desc = keep;
a.dcap = kc;
top[0] = 0;
in_cached = cur_icon_set = 0;
cur_icon[0] = 0;
if (p >= end) break;
goto next;
}
if (ind == 0) {
if (ll >= 2 && p[0] == '-' && p[1] == ' ') {
if (!strcmp(top, "Categories")) {
size_t cl = strlen(a.cats);
snprintf(a.cats + cl, sizeof a.cats - cl, "%s%.*s", cl ? ";" : "", (int)(ll - 2), p + 2);
}
goto next;
}
const char *colon = memchr(p, ':', ll);
if (!colon) goto next;
size_t kl = (size_t)(colon - p);
snprintf(top, sizeof top, "%.*s", (int)(kl < 31 ? kl : 31), p);
const char *v = colon + 1;
while (v < le && *v == ' ') v++;
size_t vl = (size_t)(le - v);
in_cached = 0;
if (!strcmp(top, "Type")) yaml_scalar(v, vl, a.type, sizeof a.type);
else if (!strcmp(top, "ID")) yaml_scalar(v, vl, a.id, sizeof a.id);
else if (!strcmp(top, "Package")) yaml_scalar(v, vl, a.package, sizeof a.package);
goto next;
}
if (ind == 2 && (!strcmp(top, "Name") || !strcmp(top, "Summary") || !strcmp(top, "Description"))) {
const char *k = p + 2, *colon = memchr(k, ':', (size_t)(le - k));
if (!colon) goto next;
int slot = lang_slot(k, (size_t)(colon - k));
const char *v = colon + 1;
while (v < le && *v == ' ') v++;
size_t vl = (size_t)(le - v);
if (vl && (v[0] == '>' || v[0] == '|')) {
block = 1;
block_desc = !strcmp(top, "Description") && slot == 0;
if (block_desc) a.dlen = 0;
goto next;
}
if (slot < 0 || !strcmp(top, "Description")) goto next;
int is_name = !strcmp(top, "Name");
if (slot == 3) { /* pt-BR: only if there's no pt */
char *dst = is_name ? a.name[2] : a.summary[2];
if (dst[0]) goto next;
slot = 2;
}
if (is_name) yaml_scalar(v, vl, a.name[slot], sizeof a.name[0]);
else yaml_scalar(v, vl, a.summary[slot], sizeof a.summary[0]);
if (vl && v[0] != '\'' && v[0] != '"') { cont_slot = slot; cont_is_name = is_name; }
goto next;
}
if (!strcmp(top, "Icon")) {
if (ind == 2 && ll >= 9 && !strncmp(p + 2, "cached:", 7)) { in_cached = 1; goto next; }
if (ind == 2 && p[2] != '-') { in_cached = 0; goto next; }
if (!in_cached) goto next;
if (ind == 2 && ll > 10 && !strncmp(p + 2, "- name:", 7)) {
const char *v = p + 9;
while (v < le && *v == ' ') v++;
yaml_scalar(v, (size_t)(le - v), cur_icon, sizeof cur_icon);
cur_icon_set = 1;
goto next;
}
if (ind == 4 && ll > 10 && !strncmp(p + 4, "width:", 6)) {
if (atoi(p + 10) == 64 && cur_icon[0]) snprintf(a.icon, sizeof a.icon, "%s", cur_icon);
}
}
next:
p = nl ? nl + 1 : end;
}
free(a.desc);
return 0;
}
/* ---- writing ---- */
static const IdxBuilder *sort_b;
static int pkg_order(const void *pa, const void *pb) {
const IdxPkg *a = &sort_b->pk[*(const uint32_t *)pa], *b = &sort_b->pk[*(const uint32_t *)pb];
int c = strcmp(sort_b->str + a->name, sort_b->str + b->name);
if (c) return c;
c = ver_cmp(sort_b->str + b->version, sort_b->str + a->version); /* newest first */
if (c) return c;
return (int)sort_b->src[b->src].prio - (int)sort_b->src[a->src].prio;
}
static int prov_order(const void *pa, const void *pb) {
const IdxProv *a = pa, *b = pb;
int c = strcmp(sort_b->str + a->name, sort_b->str + b->name);
if (c) return c;
return a->pkg < b->pkg ? -1 : a->pkg > b->pkg;
}
static int write_all(int fd, const void *p, size_t n) {
const char *c = p;
while (n) {
ssize_t w = write(fd, c, n);
if (w < 0 && errno == EINTR) continue;
if (w <= 0) return -1;
c += w;
n -= (size_t)w;
}
return 0;
}
static int pad4(int fd, size_t *off) {
static const char z[4] = { 0 };
size_t p = (4 - *off % 4) % 4;
*off += p;
return p ? write_all(fd, z, p) : 0;
}
int idxb_write(IdxBuilder *b, const char *dir, const char *arch, char *err, size_t errlen) {
if (b->npk >= UINT32_MAX / 2) { lerr_set(err, errlen, "pkg.index.tooManyPackages", NULL); return -1; }
uint32_t *perm = malloc((b->npk ? b->npk : 1) * sizeof *perm), *inv = malloc((b->npk ? b->npk : 1) * sizeof *inv);
if (!perm || !inv) { free(perm); free(inv); lerr_set(err, errlen, "sys.outOfMemory", NULL); return -1; }
for (size_t i = 0; i < b->npk; i++) perm[i] = (uint32_t)i;
sort_b = b;
qsort(perm, b->npk, sizeof *perm, pkg_order);
for (size_t i = 0; i < b->npk; i++) inv[perm[i]] = (uint32_t)i;
IdxPkg *sorted = malloc((b->npk ? b->npk : 1) * sizeof *sorted);
if (!sorted) { free(perm); free(inv); lerr_set(err, errlen, "sys.outOfMemory", NULL); return -1; }
for (size_t i = 0; i < b->npk; i++) sorted[i] = b->pk[perm[i]];
/* provides */
IdxProv *prov = NULL;
size_t nprov = 0, capprov = 0;
for (size_t i = 0; i < b->npk; i++) {
if (!sorted[i].provides) continue;
const char *s = b->str + sorted[i].provides, *e = s + strlen(s);
DebRel r[8];
int n;
while ((n = deb_next_group(&s, e, r, 8)) > 0) {
if (grow((void **)&prov, &capprov, nprov + (size_t)n, sizeof *prov)) break;
for (int k = 0; k < n; k++) {
IdxProv *x = &prov[nprov++];
x->name = intern(b, r[k].name, r[k].nlen);
x->version = r[k].op == REL_EQ ? intern(b, r[k].ver, r[k].vlen) : 0;
x->pkg = (uint32_t)i;
}
}
}
sort_b = b;
qsort(prov, nprov, sizeof *prov, prov_order);
/* apps → packages (all versions with that name) */
for (size_t a = 0; a < b->napp; a++) {
const char *pn = b->str + b->app[a].package;
size_t lo = 0, hi = b->npk;
while (lo < hi) { size_t m = (lo + hi) / 2; if (strcmp(b->str + sorted[m].name, pn) < 0) lo = m + 1; else hi = m; }
for (size_t i = lo; i < b->npk && !strcmp(b->str + sorted[i].name, pn); i++) {
/* if the package has several, the first desktop application wins */
if (sorted[i].app == UINT32_MAX || (strcmp(b->str + b->app[sorted[i].app].type, "desktop-application") &&
!strcmp(b->str + b->app[a].type, "desktop-application")))
sorted[i].app = (uint32_t)a;
}
}
IdxHeader h;
memset(&h, 0, sizeof h);
memcpy(h.magic, IDX_MAGIC, 8);
snprintf(h.arch, sizeof h.arch, "%s", arch);
h.npkg = (uint32_t)b->npk;
h.nprov = (uint32_t)nprov;
h.napp = (uint32_t)b->napp;
h.nsrc = (uint32_t)b->nsrc;
h.built = (int64_t)time(NULL);
size_t off = sizeof h;
h.off_pkg = (uint32_t)off; off += b->npk * sizeof(IdxPkg);
h.off_prov = (uint32_t)off; off += nprov * sizeof(IdxProv);
h.off_app = (uint32_t)off; off += b->napp * sizeof(IdxApp);
off = (off + 7) & ~(size_t)7;
h.off_src = (uint32_t)off; off += (size_t)b->nsrc * sizeof(IdxSrc);
h.off_str = (uint32_t)off; h.len_str = (uint32_t)b->slen; off += b->slen;
off = (off + 3) & ~(size_t)3;
h.off_desc = (uint32_t)off; h.len_desc = (uint32_t)b->dlen; off += b->dlen;
if (off > UINT32_MAX) { free(perm); free(inv); free(sorted); free(prov); lerr_set(err, errlen, "pkg.index.tooLarge", NULL); return -1; }
char tmp[512], path[512];
snprintf(tmp, sizeof tmp, "%s/index.bin.new", dir);
snprintf(path, sizeof path, "%s/index.bin", dir);
int fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW, 0644);
int ok = fd >= 0;
size_t w = 0;
if (ok) ok = !write_all(fd, &h, sizeof h);
w += sizeof h;
if (ok) ok = !write_all(fd, sorted, b->npk * sizeof(IdxPkg));
w += b->npk * sizeof(IdxPkg);
if (ok) ok = !write_all(fd, prov, nprov * sizeof(IdxProv));
w += nprov * sizeof(IdxProv);
if (ok) ok = !write_all(fd, b->app, b->napp * sizeof(IdxApp));
w += b->napp * sizeof(IdxApp);
while (ok && w % 8) { ok = !write_all(fd, "", 1); w++; }
if (ok) ok = !write_all(fd, b->src, (size_t)b->nsrc * sizeof(IdxSrc));
w += (size_t)b->nsrc * sizeof(IdxSrc);
if (ok) ok = !write_all(fd, b->str, b->slen);
w += b->slen;
if (ok) ok = !pad4(fd, &w);
if (ok) ok = !write_all(fd, b->desc, b->dlen);
if (ok) ok = fsync(fd) == 0;
if (fd >= 0 && close(fd)) ok = 0;
free(perm); free(inv); free(sorted); free(prov);
if (!ok || rename(tmp, path)) { unlink(tmp); lerr_set(err, errlen, "pkg.index.writeFailed", "path", path, "errno", lerr_errno(errno), NULL); return -1; }
return 0;
}