buninu-linux 0.3.1 → 0.5.1

package/initramfs/lib/bunterm/input.js

@@ -0,0 +1,140 @@
+// /lib/bunterm/input.js — keyboard bytes from a Linux virtual console.
+//
+// The console is read in raw mode so every key reaches the terminal
+// emulator unchanged (Ctrl-C included; the program in the PTY decides what
+// it means). The kernel keeps translating keys to bytes (K_XLATE), and its
+// "linux" console sequences for a few keys are rewritten into the xterm
+// forms that programs seeing TERM=xterm-256color expect.
+
+import { closeSync, openSync, read } from "node:fs";
+import { libc, ptr, errno, strerror } from "../dlopen.js";
+
+const TCGETS = 0x5401;
+const TCSETS = 0x5402;
+// struct termios (kernel ABI): 4 x u32 flags, c_line, c_cc[19].
+const TERMIOS_LENGTH = 36;
+const IFLAG = 0;
+const OFLAG = 4;
+const CFLAG = 8;
+const LFLAG = 12;
+const CC = 17;
+const VTIME = 5;
+const VMIN = 6;
+
+const IGNBRK = 0o1, BRKINT = 0o2, PARMRK = 0o10, ISTRIP = 0o40, INLCR = 0o100,
+  IGNCR = 0o200, ICRNL = 0o400, IXON = 0o2000;
+const OPOST = 0o1;
+const CSIZE = 0o60, CS8 = 0o60, PARENB = 0o400;
+const ISIG = 0o1, ICANON = 0o2, ECHO = 0o10, ECHONL = 0o100, IEXTEN = 0o100000;
+
+const fail = (operation) => {
+  const code = errno();
+  throw new Error(`${operation}: ${strerror(code)}`);
+};
+
+const getTermios = (fd) => {
+  const buffer = new Uint8Array(TERMIOS_LENGTH);
+  if (libc.symbols.ioctl(fd, TCGETS, ptr(buffer)) === -1) fail("TCGETS");
+  return buffer;
+};
+
+const setTermios = (fd, buffer) => {
+  if (libc.symbols.ioctl(fd, TCSETS, ptr(buffer)) === -1) fail("TCSETS");
+};
+
+// cfmakeraw() on a copy of the current settings.
+const rawTermios = (current) => {
+  const raw = new Uint8Array(current);
+  const view = new DataView(raw.buffer);
+  const clear = (offset, mask) => view.setUint32(offset, view.getUint32(offset, true) & ~mask, true);
+  clear(IFLAG, IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
+  clear(OFLAG, OPOST);
+  clear(LFLAG, ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+  clear(CFLAG, CSIZE | PARENB);
+  view.setUint32(CFLAG, view.getUint32(CFLAG, true) | CS8, true);
+  raw[CC + VMIN] = 1;
+  raw[CC + VTIME] = 0;
+  return raw;
+};
+
+// Linux console sequences → xterm sequences (keys programs commonly bind).
+const consoleToXterm = new Map([
+  ["\u001b[[A", "\u001bOP"], ["\u001b[[B", "\u001bOQ"], ["\u001b[[C", "\u001bOR"],
+  ["\u001b[[D", "\u001bOS"], ["\u001b[[E", "\u001b[15~"],
+  ["\u001b[1~", "\u001b[H"], ["\u001b[4~", "\u001b[F"],
+]);
+
+const cursorKeys = new Map([
+  ["\u001b[A", "\u001bOA"], ["\u001b[B", "\u001bOB"], ["\u001b[C", "\u001bOC"], ["\u001b[D", "\u001bOD"],
+  ["\u001b[H", "\u001bOH"], ["\u001b[F", "\u001bOF"],
+]);
+
+// Rewrites console key sequences in `text`. With `applicationCursorKeys`
+// (DECCKM set by the program) the arrow keys use the SS3 forms.
+export const translateKeys = (text, { applicationCursorKeys = false } = {}) => {
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    if (text[index] !== "\u001b") {
+      output += text[index++];
+      continue;
+    }
+    let matched = false;
+    for (const [from, to] of consoleToXterm) {
+      if (text.startsWith(from, index)) {
+        output += applicationCursorKeys ? (cursorKeys.get(to) ?? to) : to;
+        index += from.length;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+    if (applicationCursorKeys) {
+      for (const [from, to] of cursorKeys) {
+        if (text.startsWith(from, index)) {
+          output += to;
+          index += from.length;
+          matched = true;
+          break;
+        }
+      }
+      if (matched) continue;
+    }
+    output += text[index++];
+  }
+  return output;
+};
+
+// Opens the keyboard: `device` names a console such as /dev/tty1; without
+// it the process's own stdin is used (it must be a terminal). `onData`
+// receives Buffers. close() restores the previous terminal settings.
+export const openKeyboard = ({ device = null, onData, onError = () => {} }) => {
+  const fd = device ? openSync(device, "r+") : 0;
+  const saved = getTermios(fd);
+  setTermios(fd, rawTermios(saved));
+  let open = true;
+  const chunk = Buffer.alloc(4096);
+  const pump = () => {
+    if (!open) return;
+    read(fd, chunk, 0, chunk.length, null, (error, count) => {
+      if (!open) return;
+      if (error) {
+        if (error.code === "EAGAIN") { setTimeout(pump, 10); return; }
+        onError(error);
+        return;
+      }
+      if (count > 0) onData(Buffer.from(chunk.subarray(0, count)));
+      pump();
+    });
+  };
+  pump();
+  return {
+    fd,
+    close() {
+      if (!open) return;
+      open = false;
+      try { setTermios(fd, saved); } catch {}
+      if (device) closeSync(fd);
+    },
+  };
+};

package/initramfs/lib/bunterm/mouse.js

@@ -0,0 +1,222 @@
+// /lib/bunterm/mouse.js — pointing devices through the Linux input layer.
+//
+// Read from /dev/input/event*, where the kernel reports one 24-byte
+// input_event per axis, button or wheel notch, ending each batch with an
+// EV_SYN. Relative devices (a mouse) move the pointer by their deltas;
+// absolute ones (QEMU's USB tablet, a touchscreen) place it directly, which
+// needs the axis range from EVIOCGABS. This module is only loaded when
+// bunterm is asked for a mouse.
+
+import { closeSync, existsSync, openSync, read, readFileSync, readdirSync } from "node:fs";
+import { libc, ptr } from "../dlopen.js";
+
+const EVENT_SIZE = 24;
+const EV_SYN = 0x00;
+const EV_KEY = 0x01;
+const EV_REL = 0x02;
+const EV_ABS = 0x03;
+const REL_X = 0x00;
+const REL_Y = 0x01;
+const REL_WHEEL = 0x08;
+const REL_HWHEEL = 0x06;
+const ABS_X = 0x00;
+const ABS_Y = 0x01;
+const BTN_LEFT = 0x110;
+const BTN_RIGHT = 0x111;
+const BTN_MIDDLE = 0x112;
+const BTN_TOUCH = 0x14a;
+
+// struct input_absinfo { s32 value, minimum, maximum, fuzz, flat, resolution }
+const EVIOCGABS = (axis) => 0x80184540 + axis;
+
+const buttonNames = {
+  [BTN_LEFT]: "left",
+  [BTN_RIGHT]: "right",
+  [BTN_MIDDLE]: "middle",
+  [BTN_TOUCH]: "left",
+};
+
+const capability = (directory, name) => {
+  try {
+    // A capability file is a space-separated list of 64-bit hex words, most
+    // significant first, so the last word holds bits 0-63.
+    const words = readFileSync(`${directory}/${name}`, "utf8").trim().split(/\s+/u).reverse();
+    return (bit) => {
+      const word = words[Math.floor(bit / 64)];
+      return word ? (BigInt(`0x${word}`) >> BigInt(bit % 64)) & 1n ? true : false : false;
+    };
+  } catch {
+    return () => false;
+  }
+};
+
+// Every /dev/input/event* that looks like a pointer, with how it reports
+// position. A device with both relative and absolute axes counts as absolute.
+export const findPointers = (directory = "/dev/input") => {
+  const found = [];
+  let names = [];
+  try {
+    names = readdirSync(directory).filter((name) => /^event\d+$/u.test(name));
+  } catch {
+    return found;
+  }
+  for (const name of names.sort()) {
+    const sysfs = `/sys/class/input/${name}/device/capabilities`;
+    if (!existsSync(sysfs)) continue;
+    const relative = capability(sysfs, "rel");
+    const absolute = capability(sysfs, "abs");
+    const keys = capability(sysfs, "key");
+    const hasRelative = relative(REL_X) && relative(REL_Y);
+    const hasAbsolute = absolute(ABS_X) && absolute(ABS_Y);
+    const hasButton = keys(BTN_LEFT) || keys(BTN_TOUCH);
+    if (!hasButton || (!hasRelative && !hasAbsolute)) continue;
+    let label = name;
+    try {
+      label = readFileSync(`/sys/class/input/${name}/device/name`, "utf8").trim() || name;
+    } catch {}
+    found.push({
+      path: `${directory}/${name}`,
+      name: label,
+      kind: hasAbsolute ? "absolute" : "relative",
+      wheel: relative(REL_WHEEL),
+    });
+  }
+  return found;
+};
+
+const absoluteRange = (fd, axis) => {
+  const info = new Int32Array(6);
+  if (libc.symbols.ioctl(fd, EVIOCGABS(axis), ptr(info)) === -1) return null;
+  const [, minimum, maximum] = info;
+  return maximum > minimum ? { minimum, maximum } : null;
+};
+
+// Opens every pointer in `devices` and reports the pointer state after each
+// EV_SYN: { x, y, buttons: { left, middle, right }, wheel, hwheel, moved,
+// pressed, released }. Coordinates are pixels clamped to width x height.
+// `speed` scales relative motion. close() releases the devices.
+export const openPointer = ({
+  devices = findPointers(),
+  width,
+  height,
+  speed = 1,
+  x = Math.floor(width / 2),
+  y = Math.floor(height / 2),
+  onSync,
+  onError = () => {},
+}) => {
+  const state = {
+    x, y,
+    buttons: { left: false, middle: false, right: false },
+    wheel: 0,
+    hwheel: 0,
+    moved: false,
+    pressed: [],
+    released: [],
+  };
+  const open = [];
+
+  for (const device of devices) {
+    let fd = -1;
+    try {
+      fd = openSync(device.path, "r");
+      const ranges = device.kind === "absolute"
+        ? { x: absoluteRange(fd, ABS_X), y: absoluteRange(fd, ABS_Y) }
+        : null;
+      // An absolute device without a usable range is read as relative.
+      const kind = ranges?.x && ranges?.y ? "absolute" : "relative";
+      open.push({ ...device, fd, kind, ranges, buffer: Buffer.alloc(EVENT_SIZE * 64), reading: true });
+    } catch (error) {
+      if (fd >= 0) {
+        try { closeSync(fd); } catch {}
+      }
+      onError(new Error(`${device.path}: ${error.message}`));
+    }
+  }
+
+  const clamp = (value, maximum) => Math.max(0, Math.min(maximum - 1, value));
+
+  const apply = (entry, type, code, value) => {
+    if (type === EV_REL) {
+      if (code === REL_X) { state.x = clamp(Math.round(state.x + value * speed), width); state.moved = true; }
+      else if (code === REL_Y) { state.y = clamp(Math.round(state.y + value * speed), height); state.moved = true; }
+      else if (code === REL_WHEEL) state.wheel += value;
+      else if (code === REL_HWHEEL) state.hwheel += value;
+      return;
+    }
+    if (type === EV_ABS && entry.kind === "absolute") {
+      const range = code === ABS_X ? entry.ranges.x : code === ABS_Y ? entry.ranges.y : null;
+      if (!range) return;
+      const span = range.maximum - range.minimum;
+      const fraction = (value - range.minimum) / span;
+      if (code === ABS_X) state.x = clamp(Math.round(fraction * width), width);
+      else state.y = clamp(Math.round(fraction * height), height);
+      state.moved = true;
+      return;
+    }
+    if (type === EV_KEY) {
+      const button = buttonNames[code];
+      if (!button) return;
+      const down = value !== 0;
+      if (state.buttons[button] === down) return; // key repeat
+      state.buttons[button] = down;
+      (down ? state.pressed : state.released).push(button);
+    }
+  };
+
+  const flush = () => {
+    const report = {
+      x: state.x,
+      y: state.y,
+      buttons: { ...state.buttons },
+      wheel: state.wheel,
+      hwheel: state.hwheel,
+      moved: state.moved,
+      pressed: state.pressed,
+      released: state.released,
+    };
+    state.wheel = 0;
+    state.hwheel = 0;
+    state.moved = false;
+    state.pressed = [];
+    state.released = [];
+    if (report.moved || report.wheel || report.hwheel || report.pressed.length || report.released.length) {
+      try { onSync(report); } catch (error) { onError(error); }
+    }
+  };
+
+  const pump = (entry) => {
+    if (!entry.reading) return;
+    read(entry.fd, entry.buffer, 0, entry.buffer.length, null, (error, count) => {
+      if (!entry.reading) return;
+      if (error) {
+        if (error.code === "EAGAIN") { setTimeout(() => pump(entry), 10); return; }
+        entry.reading = false;
+        onError(new Error(`${entry.path}: ${error.message}`));
+        return;
+      }
+      for (let offset = 0; offset + EVENT_SIZE <= count; offset += EVENT_SIZE) {
+        const type = entry.buffer.readUInt16LE(offset + 16);
+        const code = entry.buffer.readUInt16LE(offset + 18);
+        const value = entry.buffer.readInt32LE(offset + 20);
+        if (type === EV_SYN) flush();
+        else apply(entry, type, code, value);
+      }
+      pump(entry);
+    });
+  };
+
+  for (const entry of open) pump(entry);
+
+  return {
+    devices: open.map(({ path, name, kind }) => ({ path, name, kind })),
+    state,
+    close() {
+      for (const entry of open) {
+        entry.reading = false;
+        try { closeSync(entry.fd); } catch {}
+      }
+      open.length = 0;
+    },
+  };
+};