mirror of
https://github.com/subhobhai943/SUB-OS.git
synced 2026-10-25 16:52:29 +00:00
subhobhai943andClaude Opus 4.8
4ecf119377
GUI polish / HD: - Default display mode raised to 1920x1080 (video=1920x1080); make run/vnc use vgamem_mb=64 and -m 512M. The growable heap absorbs the larger backbuffer, shadow and wallpaper (observed: one 16 MB growth to a 48 MB heap). - Wallpaper: three-stop vertical gradient, a soft concentric-frame edge vignette for depth, a finer faint grid, and a centred brand mark. - Window chrome: brighter/saturated titlebar gradient when focused, an accent underline on the active window, and larger/softer drop shadows. - Default session windows are placed and sized for the HD work area. - Live FPS pill in the taskbar tray (green/amber/red by rate); tray widened so FPS + CPU trace + memory badge + clock no longer overlap. Kernel: - kernel/time/ktime.c + include/kernel/ktime.h (new): a unified monotonic high-resolution clock that prefers the HPET (nanosecond) and falls back to the 100 Hz PIT tick. Wired ktime_init() into boot; drives the compositor's FPS sampling. New `ktime` LazyBox applet reports the source and uptime. Verified live (screenshotted): boots to 1920x1080, KTIME reports "source: HPET, nanosecond resolution", the polished desktop renders with the active-window accent and vignette, and the tray shows a live FPS reading. Clean build on x86_64/aarch64/armv8i; 0 panics / 0 OOM. Co-Authored-By: Claude Opus 4.8 <[email protected]> Claude-Session: https://claude.ai/code/session_01Fh5z6V7nGPbHvqVG5p4CXX
2641 lines
101 KiB
C
2641 lines
101 KiB
C
#include <userland/lazybox.h>
|
|
#include <userland/nano.h>
|
|
#include <fs/vfs.h>
|
|
#include <fs/ramfs.h>
|
|
#include <net/net.h>
|
|
#include <net/dns.h>
|
|
#include <net/dhcp.h>
|
|
#include <drivers/e1000.h>
|
|
#include <drivers/ata.h>
|
|
#include <drivers/tty.h>
|
|
#include <drivers/speaker.h>
|
|
#include <drivers/pci.h>
|
|
#include <drivers/rtc.h>
|
|
#include <drivers/mouse.h>
|
|
#include <sound/sound.h>
|
|
#include <sound/tts.h>
|
|
#include <crypto/crypto.h>
|
|
#include <certs/certs.h>
|
|
#include <security/security.h>
|
|
#include <security/capability.h>
|
|
#include <io_uring/io_uring.h>
|
|
#include <virt/virt.h>
|
|
#include <virt/virtio.h>
|
|
#include <init/version.h>
|
|
#include <init/init.h>
|
|
#include <kernel/module.h>
|
|
#include <kernel/task.h>
|
|
#include <ipc/ipc.h>
|
|
#include <mm/pmm.h>
|
|
#include <mm/kmalloc.h>
|
|
#include <kernel/rust.h>
|
|
#include <kernel/nt/ob.h>
|
|
#include <kernel/nt/reg.h>
|
|
#include <kernel/nt/io.h>
|
|
#include <drivers/hpet.h>
|
|
#include <drivers/nvram.h>
|
|
#include <drivers/lpt.h>
|
|
#include <kernel/ktime.h>
|
|
#include <kernel/sub_lang.h>
|
|
#include <kernel/cpp_kernel.h>
|
|
#include <userland/snake.h>
|
|
#include <ipc/shm_posix.h>
|
|
#include <net/dns_cache.h>
|
|
#include <sound/beep.h>
|
|
#include <kernel/tsc.h>
|
|
#include <kernel/vt_art.h>
|
|
#include <drivers/cpufreq.h>
|
|
#include <userland/coreutils.h>
|
|
#include <kernel/ktest.h>
|
|
#include <kernel/rcu.h>
|
|
#include <kernel/futex.h>
|
|
#include <kernel/wait.h>
|
|
#include <mm/page_cache.h>
|
|
#include <lib/hashtable.h>
|
|
#include <lib/kfifo.h>
|
|
#include <lib/rbtree.h>
|
|
#include <drivers/virtio_gpu.h>
|
|
#include <drivers/e1000e.h>
|
|
#include <drivers/virtio_input.h>
|
|
#include <gui/gui.h>
|
|
#include <arch/arch.h>
|
|
#include <kernel/printk.h>
|
|
#include <lib/string.h>
|
|
#include <lib/printf.h>
|
|
#include <security/auth.h>
|
|
#include <net/http.h>
|
|
#include <init/service.h>
|
|
#include <kernel/syslog.h>
|
|
#include <kernel/cron.h>
|
|
#include <kernel/metrics.h>
|
|
#include <kernel/trace.h>
|
|
#include <kernel/namespace.h>
|
|
#include <kernel/bpf.h>
|
|
#include <kernel/kobject.h>
|
|
#include <mm/vma.h>
|
|
#include <drivers/canvas.h>
|
|
#include <drivers/pty.h>
|
|
#include <block/block.h>
|
|
#include <drivers/hwmon.h>
|
|
#include <fs/fat32.h>
|
|
#include <sound/melody.h>
|
|
#include <userland/sh.h>
|
|
|
|
// -------------------------------------------------------------
|
|
// Core & Filesystem Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_ls(int argc, char** argv) {
|
|
const char* path = (argc >= 2) ? argv[1] : vfs_getcwd();
|
|
vfs_node_t* dir = vfs_namei(path);
|
|
|
|
if (!dir) {
|
|
printk(KERN_ERR "ls: cannot access '%s': No such file or directory\n", path);
|
|
return 1;
|
|
}
|
|
|
|
if (!(dir->flags & FS_DIRECTORY)) {
|
|
printk(KERN_INFO "%s\n", path);
|
|
return 0;
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Type Size (B) Inode Name\n" ANSI_RESET);
|
|
printk("-----------------------------------------\n");
|
|
|
|
uint32_t idx = 0;
|
|
struct vfs_dirent* ent;
|
|
while ((ent = dir->readdir(dir, idx++)) != NULL) {
|
|
const char* color = ANSI_WHITE;
|
|
const char* type_str = "FILE ";
|
|
if (ent->type & FS_DIRECTORY) {
|
|
color = ANSI_BRIGHT_BLUE;
|
|
type_str = "DIR ";
|
|
} else if (ent->type & FS_CHARDEVICE) {
|
|
color = ANSI_BRIGHT_YELLOW;
|
|
type_str = "CHR ";
|
|
}
|
|
|
|
vfs_node_t* child = dir->finddir ? dir->finddir(dir, ent->name) : NULL;
|
|
size_t sz = child ? child->length : 0;
|
|
|
|
printk("%s %8llu %6llu %s%s" ANSI_RESET "\n",
|
|
type_str, sz, ent->inode, color, ent->name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cat(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: cat <file...>\n");
|
|
return 1;
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
int fd = vfs_open(argv[i], O_RDONLY);
|
|
if (fd < 0) {
|
|
printk(KERN_ERR "cat: %s: No such file or directory\n", argv[i]);
|
|
continue;
|
|
}
|
|
|
|
char buf[512];
|
|
ssize_t bytes;
|
|
while ((bytes = vfs_read(fd, buf, sizeof(buf) - 1)) > 0) {
|
|
buf[bytes] = '\0';
|
|
printk("%s", buf);
|
|
}
|
|
vfs_close(fd);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_touch(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: touch <file...>\n");
|
|
return 1;
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
int fd = vfs_open(argv[i], O_CREAT | O_RDWR);
|
|
if (fd >= 0) {
|
|
vfs_close(fd);
|
|
} else {
|
|
printk(KERN_ERR "touch: cannot touch '%s': No such file or directory\n", argv[i]);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_mkdir(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: mkdir <directory...>\n");
|
|
return 1;
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
if (vfs_mkdir(argv[i], 0755) != 0) {
|
|
printk(KERN_ERR "mkdir: cannot create directory '%s'\n", argv[i]);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_echo(int argc, char** argv) {
|
|
for (int i = 1; i < argc; i++) {
|
|
printk("%s%s", argv[i], (i == argc - 1) ? "" : " ");
|
|
}
|
|
printk("\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_pwd(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk("%s\n", vfs_getcwd());
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cd(int argc, char** argv) {
|
|
const char* target = (argc >= 2) ? argv[1] : "/";
|
|
int res = vfs_chdir(target);
|
|
if (res != 0) {
|
|
printk(KERN_ERR "cd: %s: No such file or directory\n", target);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_wc(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: wc <file>\n");
|
|
return 1;
|
|
}
|
|
|
|
int fd = vfs_open(argv[1], O_RDONLY);
|
|
if (fd < 0) {
|
|
printk(KERN_ERR "wc: %s: No such file\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
uint64_t lines = 0, words = 0, bytes = 0;
|
|
char buf[512];
|
|
ssize_t n;
|
|
bool in_word = false;
|
|
|
|
while ((n = vfs_read(fd, buf, sizeof(buf))) > 0) {
|
|
bytes += n;
|
|
for (ssize_t i = 0; i < n; i++) {
|
|
if (buf[i] == '\n') lines++;
|
|
if (buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\n' || buf[i] == '\r') {
|
|
in_word = false;
|
|
} else if (!in_word) {
|
|
in_word = true;
|
|
words++;
|
|
}
|
|
}
|
|
}
|
|
vfs_close(fd);
|
|
|
|
printk("%4llu %4llu %4llu %s\n", lines, words, bytes, argv[1]);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_head(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: head [-n lines] <file>\n");
|
|
return 1;
|
|
}
|
|
|
|
int max_lines = 10;
|
|
const char* path = argv[1];
|
|
if (argc >= 4 && strcmp(argv[1], "-n") == 0) {
|
|
max_lines = atoi(argv[2]);
|
|
path = argv[3];
|
|
}
|
|
|
|
int fd = vfs_open(path, O_RDONLY);
|
|
if (fd < 0) {
|
|
printk(KERN_ERR "head: %s: No such file\n", path);
|
|
return 1;
|
|
}
|
|
|
|
char buf[512];
|
|
ssize_t n;
|
|
int lines_printed = 0;
|
|
|
|
while (lines_printed < max_lines && (n = vfs_read(fd, buf, sizeof(buf) - 1)) > 0) {
|
|
for (ssize_t i = 0; i < n && lines_printed < max_lines; i++) {
|
|
printk("%c", buf[i]);
|
|
if (buf[i] == '\n') lines_printed++;
|
|
}
|
|
}
|
|
vfs_close(fd);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_tail(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: tail <file>\n");
|
|
return 1;
|
|
}
|
|
return applet_cat(argc, argv);
|
|
}
|
|
|
|
static int applet_stat(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: stat <file>\n");
|
|
return 1;
|
|
}
|
|
|
|
vfs_node_t* node = vfs_namei(argv[1]);
|
|
if (!node) {
|
|
printk(KERN_ERR "stat: cannot stat '%s': No such file or directory\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
const char* type = "regular file";
|
|
if (node->flags & FS_DIRECTORY) type = "directory";
|
|
else if (node->flags & FS_CHARDEVICE) type = "character device";
|
|
|
|
printk(" File: %s\n", argv[1]);
|
|
printk(" Size: %-15llu Blocks: %-10llu IO Block: 4096 %s\n",
|
|
(uint64_t)node->length, (uint64_t)((node->length + 511) / 512), type);
|
|
printk(" Inode: %-15llu Links: 1\n", (uint64_t)node->inode);
|
|
printk("Access: (0%o/flags=0x%x) Uid: (%d/root) Gid: (%d/root)\n",
|
|
node->mode, node->flags, node->uid, node->gid);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cp(int argc, char** argv) {
|
|
if (argc < 3) {
|
|
printk(KERN_INFO "Usage: cp <source> <dest>\n");
|
|
return 1;
|
|
}
|
|
|
|
int src = vfs_open(argv[1], O_RDONLY);
|
|
if (src < 0) {
|
|
printk(KERN_ERR "cp: cannot stat '%s': No such file\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
int dst = vfs_open(argv[2], O_CREAT | O_WRONLY | O_TRUNC);
|
|
if (dst < 0) {
|
|
printk(KERN_ERR "cp: cannot create '%s'\n", argv[2]);
|
|
vfs_close(src);
|
|
return 1;
|
|
}
|
|
|
|
char buf[512];
|
|
ssize_t n;
|
|
while ((n = vfs_read(src, buf, sizeof(buf))) > 0) {
|
|
vfs_write(dst, buf, n);
|
|
}
|
|
|
|
vfs_close(src);
|
|
vfs_close(dst);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_grep(int argc, char** argv) {
|
|
if (argc < 3) {
|
|
printk(KERN_INFO "Usage: grep <pattern> <file>\n");
|
|
return 1;
|
|
}
|
|
|
|
const char* pattern = argv[1];
|
|
int fd = vfs_open(argv[2], O_RDONLY);
|
|
if (fd < 0) {
|
|
printk(KERN_ERR "grep: %s: No such file\n", argv[2]);
|
|
return 1;
|
|
}
|
|
|
|
char line[256];
|
|
int pos = 0;
|
|
char c;
|
|
|
|
while (vfs_read(fd, &c, 1) == 1) {
|
|
if (c == '\n' || pos >= (int)sizeof(line) - 1) {
|
|
line[pos] = '\0';
|
|
if (strstr(line, pattern) != NULL) {
|
|
printk("%s\n", line);
|
|
}
|
|
pos = 0;
|
|
} else if (c != '\r') {
|
|
line[pos++] = c;
|
|
}
|
|
}
|
|
vfs_close(fd);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_hexdump(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: hexdump <file>\n");
|
|
return 1;
|
|
}
|
|
|
|
int fd = vfs_open(argv[1], O_RDONLY);
|
|
if (fd < 0) {
|
|
printk(KERN_ERR "hexdump: %s: No such file\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
uint8_t buf[16];
|
|
ssize_t n;
|
|
uint64_t offset = 0;
|
|
|
|
while ((n = vfs_read(fd, buf, 16)) > 0) {
|
|
printk("%08llx ", offset);
|
|
for (int i = 0; i < 16; i++) {
|
|
if (i < n) printk("%02x ", buf[i]);
|
|
else printk(" ");
|
|
if (i == 7) printk(" ");
|
|
}
|
|
printk(" |");
|
|
for (int i = 0; i < n; i++) {
|
|
char ch = (buf[i] >= 32 && buf[i] <= 126) ? (char)buf[i] : '.';
|
|
printk("%c", ch);
|
|
}
|
|
printk("|\n");
|
|
offset += n;
|
|
}
|
|
vfs_close(fd);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_nano_wrapper(int argc, char** argv) {
|
|
return nano_main(argc, argv);
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Cryptography & Security Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_md5sum(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: md5sum <file|string>\n");
|
|
return 1;
|
|
}
|
|
|
|
uint8_t digest[16];
|
|
int fd = vfs_open(argv[1], O_RDONLY);
|
|
if (fd >= 0) {
|
|
char buf[512];
|
|
ssize_t n;
|
|
md5_ctx_t ctx;
|
|
md5_init(&ctx);
|
|
while ((n = vfs_read(fd, buf, sizeof(buf))) > 0) {
|
|
md5_update(&ctx, (uint8_t*)buf, n);
|
|
}
|
|
md5_final(digest, &ctx);
|
|
vfs_close(fd);
|
|
} else {
|
|
md5((const uint8_t*)argv[1], strlen(argv[1]), digest);
|
|
}
|
|
|
|
for (int i = 0; i < 16; i++) printk("%02x", digest[i]);
|
|
printk(" %s\n", argv[1]);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_sha256sum(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: sha256sum <file|string>\n");
|
|
return 1;
|
|
}
|
|
|
|
uint8_t digest[32];
|
|
int fd = vfs_open(argv[1], O_RDONLY);
|
|
if (fd >= 0) {
|
|
char buf[512];
|
|
ssize_t n;
|
|
sha256_ctx_t ctx;
|
|
sha256_init(&ctx);
|
|
while ((n = vfs_read(fd, buf, sizeof(buf))) > 0) {
|
|
sha256_update(&ctx, (uint8_t*)buf, n);
|
|
}
|
|
sha256_final(digest, &ctx);
|
|
vfs_close(fd);
|
|
} else {
|
|
sha256((const uint8_t*)argv[1], strlen(argv[1]), digest);
|
|
}
|
|
|
|
for (int i = 0; i < 32; i++) printk("%02x", digest[i]);
|
|
printk(" %s\n", argv[1]);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_crc32(int argc, char** argv) {
|
|
const char* str = (argc >= 2) ? argv[1] : "";
|
|
uint32_t val = crc32(0, (const uint8_t*)str, strlen(str));
|
|
printk("0x%08X \"%s\"\n", val, str);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cksum(int argc, char** argv) {
|
|
const char* str = (argc >= 2) ? argv[1] : "";
|
|
size_t len = strlen(str);
|
|
const uint8_t* buf = (const uint8_t*)str;
|
|
|
|
// All three come from the memory-safe Rust checksum engine
|
|
// (rust/src/checksum/mod.rs), with a C bridge on non-x86 targets.
|
|
uint32_t crc = rust_crc32c(buf, len);
|
|
uint32_t adl = rust_adler32(buf, len);
|
|
uint64_t fnv = rust_fnv1a64(buf, len);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Rust checksum engine" ANSI_RESET " for \"%s\" (%llu bytes):\n",
|
|
str, (unsigned long long)len);
|
|
printk(" CRC-32C : 0x%08X\n", crc);
|
|
printk(" Adler-32 : 0x%08X\n", adl);
|
|
printk(" FNV-1a-64 : 0x%016llX\n", (unsigned long long)fnv);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_rle(int argc, char** argv) {
|
|
const char* str = (argc >= 2) ? argv[1] : "aaaaabbbccccccccd";
|
|
size_t len = strlen(str);
|
|
|
|
uint8_t comp[512];
|
|
uint8_t back[512];
|
|
int clen = rust_rle_compress((const uint8_t*)str, len, comp, sizeof(comp));
|
|
if (clen < 0) {
|
|
printk(KERN_ERR "rle: input too large for the demo buffer\n");
|
|
return 1;
|
|
}
|
|
int dlen = rust_rle_decompress(comp, (size_t)clen, back, sizeof(back));
|
|
|
|
bool ok = (dlen == (int)len) && (memcmp(back, str, len) == 0);
|
|
int ratio = (len > 0) ? (clen * 100) / (int)len : 0;
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Rust RLE codec" ANSI_RESET " (run-length encoding):\n");
|
|
printk(" Input : \"%s\"\n", str);
|
|
printk(" Original : %llu bytes\n", (unsigned long long)len);
|
|
printk(" Compressed : %d bytes (%d%% of original)\n", clen, ratio);
|
|
printk(" Round-trip : %s\n", ok ? ANSI_BRIGHT_GREEN "OK (lossless)" ANSI_RESET
|
|
: ANSI_BRIGHT_RED "MISMATCH" ANSI_RESET);
|
|
return ok ? 0 : 1;
|
|
}
|
|
|
|
static void objdir_print_tree(ob_object_t* obj, int depth) {
|
|
if (!obj) return;
|
|
char indent[40];
|
|
int n = depth * 2;
|
|
if (n > (int)sizeof(indent) - 1) n = sizeof(indent) - 1;
|
|
for (int i = 0; i < n; i++) indent[i] = ' ';
|
|
indent[n] = '\0';
|
|
|
|
char detail[72];
|
|
detail[0] = '\0';
|
|
if (obj->type == OB_TYPE_EVENT) {
|
|
snprintf(detail, sizeof(detail), " [%s, %s]",
|
|
obj->body.event.manual_reset ? "manual-reset" : "auto-reset",
|
|
obj->body.event.signaled ? "signaled" : "nonsignaled");
|
|
} else if (obj->type == OB_TYPE_SEMAPHORE) {
|
|
snprintf(detail, sizeof(detail), " [%d/%d]",
|
|
obj->body.sem.count, obj->body.sem.limit);
|
|
}
|
|
|
|
printk("%s%s%s " ANSI_YELLOW "(%s" ANSI_RESET " ref=%d hnd=%d%s)%s\n",
|
|
indent, obj->name,
|
|
(obj->type == OB_TYPE_DIRECTORY) ? "\\" : "",
|
|
ob_type_name(obj->type), obj->ref_count, obj->handle_count,
|
|
obj->permanent ? " perm" : "", detail);
|
|
|
|
if (obj->type == OB_TYPE_DIRECTORY) {
|
|
int c = ob_dir_child_count(obj);
|
|
for (int i = 0; i < c; i++) {
|
|
objdir_print_tree(ob_dir_child(obj, i), depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int applet_objdir(int argc, char** argv) {
|
|
const char* path = (argc >= 2) ? argv[1] : "\\";
|
|
ob_object_t* obj = ob_lookup_path(path);
|
|
if (!obj) {
|
|
printk(KERN_ERR "objdir: object '%s' not found in the namespace\n", path);
|
|
return 1;
|
|
}
|
|
printk(ANSI_BRIGHT_CYAN "NT Object Namespace" ANSI_RESET " at '%s':\n", path);
|
|
objdir_print_tree(obj, 0);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ntobj(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint32_t objs = 0, handles = 0, per[OB_TYPE_MAX];
|
|
ob_get_stats(&objs, &handles, per);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "NT Object Manager statistics:\n" ANSI_RESET);
|
|
printk(" Total objects : %u\n", objs);
|
|
printk(" Open handles : %u / %d\n", handles, OB_HANDLE_MAX);
|
|
for (int i = 0; i < OB_TYPE_MAX; i++) {
|
|
printk(" %-10s: %u\n", ob_type_name((ob_type_t)i), per[i]);
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Dispatcher / handle demo:\n" ANSI_RESET);
|
|
ob_object_t* evt = NULL;
|
|
if (NT_SUCCESS(ob_create_object(OB_TYPE_EVENT, "DemoEvent",
|
|
ob_lookup_path("\\KernelObjects"), &evt)) && evt) {
|
|
HANDLE h = ob_open_handle(evt);
|
|
ob_dereference_object(evt); // the handle now keeps it alive
|
|
bool before = ke_test_event(evt);
|
|
ke_set_event(evt);
|
|
bool after = ke_test_event(evt); // auto-reset consumes the signal
|
|
printk(" \\KernelObjects\\DemoEvent handle=0x%X test:%d set->test:%d\n",
|
|
h, before, after);
|
|
ob_close_handle(h);
|
|
printk(" Closed handle -> object reclaimed (handle_count and ref_count hit 0)\n");
|
|
}
|
|
|
|
KIRQL old = ke_raise_irql(DISPATCH_LEVEL);
|
|
printk(" IRQL: raised %d(PASSIVE) -> %d(DISPATCH); ", old, ke_get_current_irql());
|
|
ke_lower_irql(old);
|
|
printk("lowered back to %d\n", ke_get_current_irql());
|
|
return 0;
|
|
}
|
|
|
|
static int reg_query_cmd(const char* path) {
|
|
reg_key_t* key = reg_open_key(path);
|
|
if (!key) {
|
|
printk(KERN_ERR "reg: key '%s' not found\n", path);
|
|
return 1;
|
|
}
|
|
printk(ANSI_BRIGHT_CYAN "%s\n" ANSI_RESET, path);
|
|
|
|
int vc = reg_enum_value_count(key);
|
|
if (vc == 0) {
|
|
printk(" (no values)\n");
|
|
}
|
|
for (int i = 0; i < vc; i++) {
|
|
reg_value_t* v = reg_enum_value(key, i);
|
|
char rendered[REG_STR_MAX + 32];
|
|
reg_value_to_string(v, rendered, sizeof(rendered));
|
|
printk(" " ANSI_YELLOW "%-20s" ANSI_RESET " %-11s %s\n",
|
|
v->name, reg_type_name(v->type), rendered);
|
|
}
|
|
|
|
int kc = reg_enum_key_count(key);
|
|
for (int i = 0; i < kc; i++) {
|
|
reg_key_t* sub = reg_enum_key(key, i);
|
|
printk(ANSI_BRIGHT_GREEN " [%s]\n" ANSI_RESET, sub->name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_reg(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk("Usage: reg query <\\path>\n");
|
|
printk(" reg add <\\path>\n");
|
|
printk(" reg set <\\path> <name> <dword|sz> <value>\n");
|
|
printk(" reg stats\n");
|
|
return 1;
|
|
}
|
|
|
|
if (strcmp(argv[1], "stats") == 0) {
|
|
uint32_t keys = 0, values = 0;
|
|
reg_get_stats(&keys, &values);
|
|
printk("Registry: %u keys, %u values under \\Registry\n", keys, values);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "query") == 0) {
|
|
return reg_query_cmd((argc >= 3) ? argv[2] : "\\Registry");
|
|
}
|
|
if (strcmp(argv[1], "add") == 0 && argc >= 3) {
|
|
reg_key_t* k = reg_create_key(argv[2]);
|
|
if (!k) { printk(KERN_ERR "reg: failed to create '%s'\n", argv[2]); return 1; }
|
|
printk("Created key %s\n", argv[2]);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "set") == 0 && argc >= 6) {
|
|
reg_key_t* k = reg_open_key(argv[2]);
|
|
if (!k) { printk(KERN_ERR "reg: key '%s' not found\n", argv[2]); return 1; }
|
|
if (strcmp(argv[4], "dword") == 0) {
|
|
reg_set_dword(k, argv[3], (uint32_t)atoi(argv[5]));
|
|
} else if (strcmp(argv[4], "sz") == 0) {
|
|
reg_set_sz(k, argv[3], argv[5]);
|
|
} else {
|
|
printk("reg: unknown type '%s' (use dword or sz)\n", argv[4]);
|
|
return 1;
|
|
}
|
|
printk("Set %s\\%s\n", argv[2], argv[3]);
|
|
return 0;
|
|
}
|
|
|
|
printk("reg: unrecognised sub-command '%s'\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_iodev(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint32_t drivers = 0, devices = 0;
|
|
uint64_t irps = 0;
|
|
io_get_stats(&drivers, &devices, &irps);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "NT I/O Manager:\n" ANSI_RESET);
|
|
printk(" Drivers: %u Devices: %u IRPs dispatched: %llu\n",
|
|
drivers, devices, (unsigned long long)irps);
|
|
|
|
int dc = io_device_count();
|
|
for (int i = 0; i < dc; i++) {
|
|
DEVICE_OBJECT* dev = io_device_at(i);
|
|
if (!dev) continue;
|
|
printk(" " ANSI_YELLOW "%-22s" ANSI_RESET " drv=%-16s r=%llu w=%llu ioctl=%llu",
|
|
dev->name, dev->driver ? dev->driver->name : "?",
|
|
(unsigned long long)dev->read_count,
|
|
(unsigned long long)dev->write_count,
|
|
(unsigned long long)dev->ioctl_count);
|
|
if (dev->attached_to) {
|
|
printk(" -> %s", dev->attached_to->name);
|
|
}
|
|
printk("\n");
|
|
}
|
|
|
|
// Live demo: push a WRITE IRP through the filtered Null stack and a READ to
|
|
// the Zero device, then report what came back.
|
|
printk(ANSI_BRIGHT_CYAN "IRP demo:\n" ANSI_RESET);
|
|
DEVICE_OBJECT* mon = io_lookup_device("\\Device\\NullMonitor");
|
|
if (mon) {
|
|
char payload[16];
|
|
memset(payload, 'X', sizeof(payload));
|
|
IRP* irp = io_build_irp(IRP_MJ_WRITE, payload, sizeof(payload));
|
|
if (irp) {
|
|
NTSTATUS st = io_call_driver(mon, irp);
|
|
printk(" WRITE %u bytes to %s -> status=0x%X, %u bytes sunk (via filter)\n",
|
|
(unsigned)sizeof(payload), mon->name, st, irp->information);
|
|
io_free_irp(irp);
|
|
}
|
|
}
|
|
DEVICE_OBJECT* zero = io_lookup_device("\\Device\\Zero");
|
|
if (zero) {
|
|
uint8_t buf[8];
|
|
memset(buf, 0xEE, sizeof(buf));
|
|
IRP* irp = io_build_irp(IRP_MJ_READ, buf, sizeof(buf));
|
|
if (irp) {
|
|
io_call_driver(zero, irp);
|
|
printk(" READ %u bytes from %s -> first bytes %02X %02X %02X (zeroed)\n",
|
|
irp->information, zero->name, buf[0], buf[1], buf[2]);
|
|
io_free_irp(irp);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ktime(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint64_t ns = ktime_ns();
|
|
printk(ANSI_BRIGHT_CYAN "Monotonic clock (ktime):\n" ANSI_RESET);
|
|
printk(" Source : %s%s\n", ktime_source(),
|
|
ktime_is_highres() ? " (nanosecond resolution)" : " (10 ms tick)");
|
|
printk(" Uptime : %llu.%03llu s (%llu ns)\n",
|
|
(unsigned long long)(ns / 1000000000ULL),
|
|
(unsigned long long)((ns / 1000000ULL) % 1000ULL),
|
|
(unsigned long long)ns);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_hpet(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
if (!hpet_available()) {
|
|
printk("HPET: not available on this platform\n");
|
|
return 1;
|
|
}
|
|
printk(ANSI_BRIGHT_CYAN "High Precision Event Timer:\n" ANSI_RESET);
|
|
printk(" Frequency : %llu Hz\n", (unsigned long long)hpet_get_frequency_hz());
|
|
printk(" Comparators: %u\n", hpet_num_timers());
|
|
printk(" Main count : %llu\n", (unsigned long long)hpet_read_counter());
|
|
printk(" Uptime : %llu ns since HPET enable\n", (unsigned long long)hpet_get_ns());
|
|
return 0;
|
|
}
|
|
|
|
static int applet_nvram(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
nvram_dump();
|
|
printk(" checksum(0x0E..0x7F) = 0x%02X\n", nvram_checksum());
|
|
return 0;
|
|
}
|
|
|
|
static int applet_lpt(int argc, char** argv) {
|
|
if (!lpt_present()) {
|
|
printk("LPT: no parallel port present\n");
|
|
return 1;
|
|
}
|
|
const char* text = (argc >= 2) ? argv[1] : "SUB-OS\n";
|
|
int n = lpt_write(text, strlen(text));
|
|
printk("LPT1: status=0x%02X, wrote %d byte(s) to the parallel port\n",
|
|
lpt_status(), n);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_rand(int argc, char** argv) {
|
|
int count = (argc >= 2) ? atoi(argv[1]) : 4;
|
|
printk("Random Integers: ");
|
|
for (int i = 0; i < count; i++) {
|
|
printk("%u ", prng_rand32());
|
|
}
|
|
printk("\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_certcheck(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
size_t count = certs_get_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS X.509 Kernel Trust Keyring (%llu certs) ===\n" ANSI_RESET, (uint64_t)count);
|
|
for (size_t i = 0; i < count; i++) {
|
|
const x509_cert_t* c = certs_get_cert(i);
|
|
if (c) {
|
|
printk("[%llu] %s\n", (uint64_t)(i + 1), c->subject);
|
|
printk(" Issuer: %s\n", c->issuer);
|
|
printk(" Fingerprint: ");
|
|
for (int j = 0; j < 16; j++) printk("%02x", c->fingerprint[j]);
|
|
printk("... [TRUSTED]\n");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_capsh(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk("Current Security LSM: %s\n", security_get_active_lsm_name());
|
|
printk("Capabilities: Current=0x%016llx (Full Set)\n", (uint64_t)CAP_FULL_SET);
|
|
printk("Bounds: cap_chown, cap_dac_override, cap_net_raw, cap_sys_admin [ALL PERMITTED]\n");
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Audio & Text-to-Speech Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_tts(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: tts <text to synthesize>\n");
|
|
tts_speak("hello sub os");
|
|
return 0;
|
|
}
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
tts_speak(argv[i]);
|
|
if (i + 1 < argc) tts_speak(" ");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_alsamixer(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
sound_device_t* dev = sound_get_default_device();
|
|
printk(ANSI_BRIGHT_CYAN "=== ALSA Sound Architecture & Mixer Control ===\n" ANSI_RESET);
|
|
if (dev) {
|
|
printk("Card: %s\n", dev->name);
|
|
printk("Sample Rate: %u Hz | Channels: %d | Depth: %d-bit\n",
|
|
dev->sample_rate, dev->channels, dev->bits_per_sample);
|
|
printk("Master Volume: [||||||||||||||||||||] %d%%\n", dev->volume);
|
|
} else {
|
|
printk("PC Speaker Synthesizer: Active (1193180 Hz base timer)\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Kernel Modules & Dynamic Loading Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_lsmod(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "Module Size Used by\n" ANSI_RESET);
|
|
size_t count = module_get_count();
|
|
for (size_t i = 0; i < count; i++) {
|
|
const kernel_module_t* m = module_get(i);
|
|
if (m && m->loaded) {
|
|
printk("%-20s %8llu 0 [Live]\n", m->name, (uint64_t)m->size);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_insmod(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: insmod <module_name>\n");
|
|
return 1;
|
|
}
|
|
if (module_load(argv[1], NULL, NULL, 8192) == 0) {
|
|
printk(KERN_INFO "Module '%s' loaded successfully\n", argv[1]);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "insmod: failed to insert module '%s'\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_rmmod(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: rmmod <module_name>\n");
|
|
return 1;
|
|
}
|
|
if (module_unload(argv[1]) == 0) {
|
|
printk(KERN_INFO "Module '%s' unloaded successfully\n", argv[1]);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "rmmod: failed to remove module '%s'\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Network & Hardware Drivers Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_ifconfig(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint8_t mac[6];
|
|
e1000_get_mac(mac);
|
|
|
|
printk("eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500\n");
|
|
printk(" inet 10.0.2.15 netmask 255.255.255.0 broadcast 10.0.2.2\n");
|
|
printk(" ether %02x:%02x:%02x:%02x:%02x:%02x txqueuelen 1000 (Ethernet)\n",
|
|
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
printk(" RX packets 0 bytes 0\n");
|
|
printk(" TX packets 0 bytes 0\n");
|
|
printk(" Link Status: %s\n", e1000_is_link_up() ? "UP" : "DOWN");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ping(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: ping <ip_address> [count]\n");
|
|
return 1;
|
|
}
|
|
|
|
uint32_t target_ip = ip_parse(argv[1]);
|
|
int count = (argc >= 3) ? atoi(argv[2]) : 2;
|
|
|
|
printk("PING %s (56 data bytes):\n", argv[1]);
|
|
net_ping(target_ip, (uint32_t)count, 1000);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_arp(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "Address HWtype HWaddress Flags Mask Iface\n" ANSI_RESET);
|
|
printk("10.0.2.2 ether 52:55:0a:00:02:02 C eth0\n");
|
|
printk("10.0.2.3 ether 52:55:0a:00:02:03 C eth0\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_dhclient(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
return dhcp_request_lease();
|
|
}
|
|
|
|
static int applet_nslookup(int argc, char** argv) {
|
|
const char* host = (argc >= 2) ? argv[1] : "google.com";
|
|
uint32_t ip = dns_resolve(host);
|
|
char ip_buf[16];
|
|
ip_to_str(ip, ip_buf);
|
|
printk("Server: 10.0.2.3\nAddress: 10.0.2.3#53\n\nNon-authoritative answer:\nName: %s\nAddress: %s\n",
|
|
host, ip_buf);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_hdparm(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const ata_device_t* dev = ata_get_primary_master();
|
|
if (!dev || !dev->present) {
|
|
printk(KERN_ERR "hdparm: No ATA disk detected\n");
|
|
return 1;
|
|
}
|
|
|
|
printk("/dev/sda (ATA Primary Master):\n");
|
|
printk(" Model Number: %s\n", dev->model);
|
|
printk(" Capacity: %llu MB (%llu sectors)\n",
|
|
(dev->sector_count * 512) / (1024 * 1024), (uint64_t)dev->sector_count);
|
|
printk(" Sector Size: 512 bytes logical/physical\n");
|
|
printk(" Addressing: 28-bit LBA Mode\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_lspci(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "=== PCI Bus Device Enumeration ===\n" ANSI_RESET);
|
|
pci_device_t* dev = pci_get_devices();
|
|
while (dev) {
|
|
printk("%02x:%02x.%d [%04x:%04x] Class %02x.%02x (IRQ %d)\n",
|
|
dev->bus, dev->slot, dev->function,
|
|
dev->vendor_id, dev->device_id,
|
|
dev->class_id, dev->subclass_id, dev->irq);
|
|
dev = dev->next;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_speaker(int argc, char** argv) {
|
|
int freq = (argc >= 2) ? atoi(argv[1]) : 587;
|
|
int dur = (argc >= 3) ? atoi(argv[2]) : 200;
|
|
speaker_beep((uint32_t)freq, (uint32_t)dur);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_mouse(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const mouse_state_t* m = mouse_get_state();
|
|
printk("Mouse State: X=%d, Y=%d, Left=%s, Right=%s, Mid=%s\n",
|
|
m->x, m->y, m->left_btn ? "ON" : "OFF",
|
|
m->right_btn ? "ON" : "OFF", m->middle_btn ? "ON" : "OFF");
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// System & Virtualization Applets
|
|
// -------------------------------------------------------------
|
|
|
|
static int applet_uname(int argc, char** argv) {
|
|
if (argc >= 2 && strcmp(argv[1], "-a") == 0) {
|
|
printk("SUB-OS sub-node %s #1 SMP PREEMPT 2026 %s GNU/LazyBox\n", kernel_get_version(), arch_get_name());
|
|
} else {
|
|
printk("SUB-OS\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_date(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
char date_buf[64];
|
|
rtc_format_string(date_buf, sizeof(date_buf));
|
|
printk("%s\n", date_buf);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_free(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint64_t total_kb = (pmm_get_total_pages() * 4096) / 1024;
|
|
uint64_t used_kb = (pmm_get_used_pages() * 4096) / 1024;
|
|
uint64_t free_kb = (pmm_get_free_pages() * 4096) / 1024;
|
|
|
|
printk(ANSI_BRIGHT_CYAN " total used free shared buff/cache available\n" ANSI_RESET);
|
|
printk("Mem: %8llu %8llu %8llu 0 110 %8llu\n",
|
|
total_kb, used_kb, free_kb, free_kb);
|
|
printk("Heap: %8llu %8llu %8llu\n",
|
|
kmalloc_get_total() / 1024, kmalloc_get_used() / 1024, kmalloc_get_free() / 1024);
|
|
printk(" (dynamic kernel heap, grown on demand %llu time(s))\n",
|
|
(unsigned long long)heap_get_grow_count());
|
|
return 0;
|
|
}
|
|
|
|
static int applet_uptime(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint64_t ticks = pit_get_ticks();
|
|
uint64_t secs = ticks / 100;
|
|
uint64_t hrs = secs / 3600;
|
|
uint64_t mins = (secs % 3600) / 60;
|
|
secs = secs % 60;
|
|
|
|
printk("up %02llu:%02llu:%02llu, 1 user, load average: 0.00, 0.01, 0.00\n",
|
|
hrs, mins, secs);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_dmesg(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
dmesg_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_sleep(int argc, char** argv) {
|
|
int secs = (argc >= 2) ? atoi(argv[1]) : 1;
|
|
if (secs > 0) {
|
|
pit_sleep((uint32_t)secs * 1000);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_clear(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
tty_clear();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_rustinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "=================================================================\n" ANSI_RESET);
|
|
printk(ANSI_BRIGHT_GREEN " SUB-OS Rust Core Subsystem (Memory-Safe Kernel Engine)\n" ANSI_RESET);
|
|
printk(ANSI_BRIGHT_CYAN "=================================================================\n" ANSI_RESET);
|
|
printk(ANSI_YELLOW " Compiler Profile : " ANSI_RESET "Rustc 1.75+ (Freestanding bare-metal no_std)\n");
|
|
printk(ANSI_YELLOW " Active Drivers : " ANSI_RESET "ChaCha20 CSPRNG, HWMON Thermal Governor\n");
|
|
printk(ANSI_YELLOW " Memory Safety : " ANSI_RESET "Guaranteed (Borrow Checker + Ownership semantics)\n");
|
|
printk(ANSI_YELLOW " Status : " ANSI_RESET "%s\n\n", rust_kernel_status());
|
|
return 0;
|
|
}
|
|
|
|
static int applet_chacha20(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: chacha20 <text_to_encrypt/decrypt>\n");
|
|
return 1;
|
|
}
|
|
const char* input = argv[1];
|
|
size_t len = strlen(input);
|
|
char buffer[256];
|
|
if (len > sizeof(buffer) - 1) len = sizeof(buffer) - 1;
|
|
memcpy(buffer, input, len);
|
|
buffer[len] = '\0';
|
|
|
|
uint8_t key[32] = {
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
|
|
};
|
|
uint8_t nonce[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x00};
|
|
|
|
rust_chacha20_crypt(key, nonce, 1, (uint8_t*)buffer, len);
|
|
|
|
printk("ChaCha20 Cipher Output (Hex, %llu bytes):\n " ANSI_BRIGHT_GREEN, (uint64_t)len);
|
|
for (size_t i = 0; i < len; i++) {
|
|
printk("%02x ", (uint8_t)buffer[i]);
|
|
}
|
|
printk(ANSI_RESET "\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_sha3sum(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: sha3sum <text>\n");
|
|
return 1;
|
|
}
|
|
const char* text = argv[1];
|
|
uint8_t hash[32];
|
|
rust_sha3_256((const uint8_t*)text, strlen(text), hash);
|
|
|
|
for (int i = 0; i < 32; i++) {
|
|
printk("%02x", hash[i]);
|
|
}
|
|
printk(" %s (Rust SHA3-256)\n", text);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_dcache(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint64_t hits = 0, misses = 0;
|
|
rust_dcache_get_metrics(&hits, &misses);
|
|
printk(ANSI_BRIGHT_CYAN "=== Rust VFS Directory Entry Cache (dcache) Metrics ===\n" ANSI_RESET);
|
|
printk(" Cache Status : " ANSI_GREEN "ACTIVE" ANSI_RESET " (LRU 64-Entry Fast Hash)\n");
|
|
printk(" Cache Hits : " ANSI_YELLOW "%llu\n" ANSI_RESET, (uint64_t)hits);
|
|
printk(" Cache Misses : " ANSI_YELLOW "%llu\n" ANSI_RESET, (uint64_t)misses);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_watchdog(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
rust_health_report_t report = rust_watchdog_get_report();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Rust Kernel Health & Watchdog Report ===\n" ANSI_RESET);
|
|
printk(" Status : %s\n", report.is_healthy ? ANSI_GREEN "HEALTHY (NOMINAL)" ANSI_RESET : ANSI_RED "WARNING" ANSI_RESET);
|
|
printk(" Heartbeats : " ANSI_YELLOW "%llu\n" ANSI_RESET, (uint64_t)report.total_heartbeats);
|
|
printk(" Monitored Units: " ANSI_GREEN "%u active subsystems\n" ANSI_RESET, report.active_modules);
|
|
printk(" Subsystem Mask : 0x%08x\n", report.subsystem_mask);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_jsonquery(int argc, char** argv) {
|
|
if (argc < 3) {
|
|
printk(KERN_INFO "Usage: jsonquery \"<json_string>\" <key>\n");
|
|
return 1;
|
|
}
|
|
const char* json_str = argv[1];
|
|
const char* key = argv[2];
|
|
char value[128];
|
|
|
|
int res = rust_json_get_string(
|
|
(const uint8_t*)json_str, strlen(json_str),
|
|
(const uint8_t*)key, strlen(key),
|
|
(uint8_t*)value, sizeof(value)
|
|
);
|
|
|
|
if (res >= 0) {
|
|
printk("Key '%s' = " ANSI_BRIGHT_GREEN "\"%s\"" ANSI_RESET " (Parsed via Rust Zero-Copy Engine)\n", key, value);
|
|
} else {
|
|
printk(ANSI_RED "Key '%s' not found in JSON payload.\n" ANSI_RESET, key);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cryptobench(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "=================================================================\n" ANSI_RESET);
|
|
printk(ANSI_BRIGHT_GREEN " SUB-OS In-Kernel Cryptographic & SIMD Throughput Benchmark\n" ANSI_RESET);
|
|
printk(ANSI_BRIGHT_CYAN "=================================================================\n" ANSI_RESET);
|
|
printk("Running memory-safe micro-benchmarks...\n\n");
|
|
|
|
rust_crypto_bench_result_t res;
|
|
rust_crypto_run_benchmark(&res);
|
|
|
|
printk(" %-25s : " ANSI_BRIGHT_GREEN "%4u MB/s" ANSI_RESET " (RFC-8439 Stream Cipher)\n", "ChaCha20-Poly1305", res.chacha20_mbs);
|
|
printk(" %-25s : " ANSI_BRIGHT_GREEN "%4u MB/s" ANSI_RESET " (FIPS-197 128-Bit Block Cipher)\n", "AES-128 Hardware/SW", res.aes128_mbs);
|
|
printk(" %-25s : " ANSI_BRIGHT_GREEN "%4u MB/s" ANSI_RESET " (FIPS-202 Keccak Permutation)\n", "SHA3-256 Digest", res.sha3_256_mbs);
|
|
printk(" %-25s : " ANSI_BRIGHT_YELLOW "%4u Score" ANSI_RESET "\n\n", "Composite Crypto Rating", res.score);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_fdisk(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "Disk /dev/sda: 1.5 MB, 2880 sectors (512 bytes/sector)\n" ANSI_RESET);
|
|
printk("Disklabel type: dos (MBR / GPT Compatible)\n\n");
|
|
|
|
uint8_t mbr_sector[512];
|
|
memset(mbr_sector, 0, sizeof(mbr_sector));
|
|
mbr_sector[510] = 0x55;
|
|
mbr_sector[511] = 0xAA;
|
|
|
|
rust_decoded_partition_t parts[4];
|
|
int count = rust_storage_decode_mbr(mbr_sector, parts, 4);
|
|
|
|
printk("Device Boot Start End Sectors Size Id Type\n");
|
|
printk("-----------------------------------------------------------------\n");
|
|
for (int i = 0; i < count; i++) {
|
|
printk("/dev/sda%-2u %c %8llu %8llu %7llu %4lluM %02x %s\n",
|
|
parts[i].partition_number,
|
|
parts[i].is_bootable ? '*' : ' ',
|
|
parts[i].start_lba,
|
|
parts[i].start_lba + parts[i].sector_count - 1,
|
|
parts[i].sector_count,
|
|
parts[i].size_mb ? parts[i].size_mb : 1,
|
|
parts[i].partition_type_id,
|
|
parts[i].name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_rfilter(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
uint64_t processed = 0, blocked = 0;
|
|
size_t rules = 0;
|
|
rust_filter_get_stats(&processed, &blocked, &rules);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "=== Rust Kernel NetFilter Stateful Packet Engine ===\n" ANSI_RESET);
|
|
printk(" Filter Status : " ANSI_GREEN "ACTIVE & ENFORCING" ANSI_RESET "\n");
|
|
printk(" Configured Rules: " ANSI_YELLOW "%llu" ANSI_RESET "\n", (uint64_t)rules);
|
|
printk(" Packets Evaluated: " ANSI_YELLOW "%llu" ANSI_RESET "\n", (uint64_t)processed);
|
|
printk(" Packets Blocked : " ANSI_RED "%llu" ANSI_RESET "\n", (uint64_t)blocked);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_subinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
sub_kernel_print_signature();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_subi(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: subi <file.sb> OR subi -e \"<sub_code>\"\n");
|
|
return 1;
|
|
}
|
|
if (strcmp(argv[1], "-e") == 0) {
|
|
if (argc < 3) {
|
|
printk(ANSI_RED "Error: missing code expression after -e\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
return sub_vm_eval_string(argv[2]);
|
|
}
|
|
return sub_vm_eval_file(argv[1]);
|
|
}
|
|
|
|
static int applet_subpower(int argc, char** argv) {
|
|
int32_t temp = 45;
|
|
uint32_t load = 50;
|
|
if (argc >= 2) temp = (int32_t)strtol(argv[1], NULL, 10);
|
|
if (argc >= 3) load = (uint32_t)strtol(argv[2], NULL, 10);
|
|
|
|
int pstate = sub_power_calc_pstate(temp, load);
|
|
uint32_t freq = sub_power_get_freq_mhz(pstate);
|
|
uint32_t volt = sub_power_get_voltage_mv(pstate);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-Lang In-Kernel CPU Power Governor ===\n" ANSI_RESET);
|
|
printk(" Current Temp : " ANSI_YELLOW "%d C\n" ANSI_RESET, temp);
|
|
printk(" Current Load : " ANSI_YELLOW "%u %%\n" ANSI_RESET, load);
|
|
printk(" Target P-State: " ANSI_BRIGHT_GREEN "P%d\n" ANSI_RESET, pstate);
|
|
printk(" Target Clock : " ANSI_BRIGHT_GREEN "%u MHz\n" ANSI_RESET, freq);
|
|
printk(" Core Voltage : " ANSI_BRIGHT_GREEN "%u mV\n" ANSI_RESET, volt);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_subbench(int argc, char** argv) {
|
|
uint32_t iters = 100;
|
|
if (argc >= 2) iters = (uint32_t)strtol(argv[1], NULL, 10);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Running SUB-Lang In-Kernel Recursive & Matrix Benchmark...\n" ANSI_RESET);
|
|
uint32_t score = sub_benchmark_run(iters);
|
|
printk(" Iterations : " ANSI_YELLOW "%u\n" ANSI_RESET, iters);
|
|
printk(" Benchmark : " ANSI_BRIGHT_GREEN "PASSED\n" ANSI_RESET);
|
|
printk(" SUB Rating : " ANSI_BRIGHT_YELLOW "%u points\n" ANSI_RESET, score);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_subquote(int argc, char** argv) {
|
|
static int quote_counter = 0;
|
|
int idx = 0;
|
|
if (argc >= 2) idx = (int)strtol(argv[1], NULL, 10);
|
|
else idx = (quote_counter++) % 5;
|
|
|
|
printk(ANSI_BRIGHT_MAGENTA "💬 SUB-OS Signature Quote:\n" ANSI_RESET);
|
|
printk(" \"" ANSI_BRIGHT_WHITE "%s" ANSI_RESET "\"\n\n", sub_easter_egg_get(idx));
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cppinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
cpp_kernel_print_status();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cpptest(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
return cpp_test_oop_subsystem();
|
|
}
|
|
|
|
static int applet_cppdevs(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
cpp_device_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cppbench(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
return cpp_run_benchmarks();
|
|
}
|
|
|
|
static int applet_shm(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
posix_shm_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_dnscache(int argc, char** argv) {
|
|
if (argc >= 2 && strcmp(argv[1], "-f") == 0) {
|
|
dns_cache_flush();
|
|
return 0;
|
|
}
|
|
dns_cache_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cpufreq(int argc, char** argv) {
|
|
if (argc >= 3 && strcmp(argv[1], "-g") == 0) {
|
|
if (cpufreq_set_governor_by_name(argv[2]) == 0) {
|
|
printk(ANSI_BRIGHT_GREEN "CPU governor switched to '%s'\n" ANSI_RESET, argv[2]);
|
|
return 0;
|
|
} else {
|
|
printk(ANSI_BRIGHT_RED "Invalid governor '%s'. Valid: performance, powersave, ondemand, conservative, schedutil\n" ANSI_RESET, argv[2]);
|
|
return 1;
|
|
}
|
|
}
|
|
cpufreq_dump_info();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_gpuinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
virtio_gpu_dump_status();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_e1000e(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
e1000e_dump_stats();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_startx(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
return gui_start_desktop();
|
|
}
|
|
|
|
static int applet_readelf(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
int fd = vfs_open(argv[1], 0);
|
|
if (fd >= 0) {
|
|
uint8_t header_buf[1024];
|
|
int n = vfs_read(fd, header_buf, sizeof(header_buf));
|
|
vfs_close(fd);
|
|
if (n >= 52) {
|
|
rust_elf_dump(header_buf, n);
|
|
return 0;
|
|
}
|
|
}
|
|
printk(ANSI_BRIGHT_RED "Error opening file '%s'\n" ANSI_RESET, argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
// Default: Inspect in-memory running kernel ELF image
|
|
const uint8_t* kernel_hdr = (const uint8_t*)0x100000;
|
|
if (rust_elf_validate(kernel_hdr, 512) == 0) {
|
|
rust_elf_dump(kernel_hdr, 512);
|
|
} else {
|
|
// Construct sample ELF64 header for demonstration
|
|
uint8_t sample_elf[128];
|
|
memset(sample_elf, 0, sizeof(sample_elf));
|
|
sample_elf[0] = 0x7F; sample_elf[1] = 'E'; sample_elf[2] = 'L'; sample_elf[3] = 'F';
|
|
sample_elf[4] = 2; // 64-bit
|
|
sample_elf[5] = 1; // Little-endian
|
|
sample_elf[6] = 1; // Version
|
|
sample_elf[18] = 0x3E; // EM_X86_64
|
|
*(uint64_t*)&sample_elf[24] = 0x0000000000100000; // Entry point
|
|
*(uint64_t*)&sample_elf[32] = 64; // PH offset
|
|
*(uint16_t*)&sample_elf[54] = 56; // PH entry size
|
|
*(uint16_t*)&sample_elf[56] = 2; // 2 PH entries
|
|
// PH 0: LOAD RX
|
|
*(uint32_t*)&sample_elf[64] = 1; // PT_LOAD
|
|
*(uint32_t*)&sample_elf[68] = 5; // PF_R | PF_X
|
|
*(uint64_t*)&sample_elf[80] = 0x100000;
|
|
*(uint64_t*)&sample_elf[104] = 0x80000;
|
|
rust_elf_dump(sample_elf, sizeof(sample_elf));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_buddyinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
rust_buddy_analyze(pmm_get_total_pages(), pmm_get_free_pages());
|
|
rust_buddy_dump_stats();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_aead(int argc, char** argv) {
|
|
const char* plaintext = (argc >= 2) ? argv[1] : "SUB-OS Authenticated Secret Kernel Message";
|
|
size_t plain_len = strlen(plaintext);
|
|
|
|
uint8_t key[32] = {
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
|
|
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
|
|
0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20
|
|
};
|
|
uint8_t nonce[12] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B };
|
|
const char* aad = "SUB-OS-AEAD-V1";
|
|
|
|
uint8_t ciphertext[256];
|
|
uint8_t tag[16];
|
|
uint8_t decrypted[256];
|
|
|
|
printk(ANSI_BRIGHT_CYAN "=== Rust ChaCha20-Poly1305 AEAD Cryptographic Test ===\n" ANSI_RESET);
|
|
printk(" Plaintext : \"" ANSI_BRIGHT_WHITE "%s" ANSI_RESET "\" (%llu bytes)\n", plaintext, (uint64_t)plain_len);
|
|
printk(" AAD : \"%s\"\n", aad);
|
|
|
|
int enc_res = rust_aead_encrypt(key, nonce, (const uint8_t*)aad, strlen(aad),
|
|
(const uint8_t*)plaintext, plain_len, ciphertext, tag);
|
|
if (enc_res != 0) {
|
|
printk(ANSI_BRIGHT_RED "Encryption failed!\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
|
|
printk(" Tag (MAC) : " ANSI_BRIGHT_YELLOW);
|
|
for (int i = 0; i < 16; i++) printk("%02x", tag[i]);
|
|
printk(ANSI_RESET "\n");
|
|
|
|
int dec_res = rust_aead_decrypt(key, nonce, (const uint8_t*)aad, strlen(aad),
|
|
ciphertext, plain_len, tag, decrypted);
|
|
if (dec_res == 0) {
|
|
decrypted[plain_len] = '\0';
|
|
printk(" Decrypted : \"" ANSI_BRIGHT_GREEN "%s" ANSI_RESET "\"\n", decrypted);
|
|
printk(" Auth Status: " ANSI_BRIGHT_GREEN "VERIFIED (100%% Authenticated)\n" ANSI_RESET);
|
|
} else {
|
|
printk(ANSI_BRIGHT_RED "Decryption / Authentication failed!\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_whoami(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const user_account_t* u = auth_get_current_user();
|
|
printk("%s\n", u ? u->username : "SUB");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_id(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const user_account_t* u = auth_get_current_user();
|
|
if (u) {
|
|
printk("uid=%u(%s) gid=%u(%s) groups=%u(%s)\n",
|
|
u->uid, u->username, u->gid, u->username, u->gid, u->username);
|
|
} else {
|
|
printk("uid=0(root) gid=0(root) groups=0(root)\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_cal(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(" August 2026\n");
|
|
printk("Su Mo Tu We Th Fr Sa\n");
|
|
printk(" 1\n");
|
|
printk(" 2 3 4 5 6 7 8\n");
|
|
printk(" 9 10 11 12 13 14 15\n");
|
|
printk(ANSI_INVERT "16" ANSI_RESET " 17 18 19 20 21 22\n");
|
|
printk("23 24 25 26 27 28 29\n");
|
|
printk("30 31\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_base64(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: base64 [-d] <text>\n");
|
|
return 1;
|
|
}
|
|
bool decode = false;
|
|
const char* text = argv[1];
|
|
if (strcmp(argv[1], "-d") == 0) {
|
|
if (argc < 3) {
|
|
printk(ANSI_RED "Error: missing base64 string to decode\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
decode = true;
|
|
text = argv[2];
|
|
}
|
|
|
|
char out[512];
|
|
memset(out, 0, sizeof(out));
|
|
if (decode) {
|
|
int len = rust_base64_decode((const uint8_t*)text, strlen(text), (uint8_t*)out, sizeof(out) - 1);
|
|
if (len < 0) {
|
|
printk(ANSI_RED "Error: invalid base64 input\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
printk("%s\n", out);
|
|
} else {
|
|
int len = rust_base64_encode((const uint8_t*)text, strlen(text), (uint8_t*)out, sizeof(out) - 1);
|
|
if (len < 0) {
|
|
printk(ANSI_RED "Error: base64 encoding failed\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
printk("%s\n", out);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_pstree(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
task_dump_pstree();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_kill(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: kill [-<signal>] <pid>\n");
|
|
return 1;
|
|
}
|
|
int sig = 15;
|
|
pid_t pid = 0;
|
|
if (argv[1][0] == '-') {
|
|
sig = (int)strtol(argv[1] + 1, NULL, 10);
|
|
if (argc >= 3) {
|
|
pid = (pid_t)strtol(argv[2], NULL, 10);
|
|
} else {
|
|
printk(ANSI_RED "kill: missing PID\n" ANSI_RESET);
|
|
return 1;
|
|
}
|
|
} else {
|
|
pid = (pid_t)strtol(argv[1], NULL, 10);
|
|
}
|
|
return task_kill(pid, sig);
|
|
}
|
|
|
|
int cmd_tree_main(int argc, char** argv);
|
|
|
|
static int applet_tree(int argc, char** argv) {
|
|
return cmd_tree_main(argc, argv);
|
|
}
|
|
|
|
static int applet_tscinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
tsc_dump_info();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_vtart(int argc, char** argv) {
|
|
if (argc >= 2 && strcmp(argv[1], "--palette") == 0) {
|
|
vt_show_palette_256();
|
|
return 0;
|
|
} else if (argc >= 2 && strcmp(argv[1], "--bars") == 0) {
|
|
vt_show_load_bars(15, 28, 42);
|
|
return 0;
|
|
}
|
|
vt_show_logo_banner();
|
|
vt_show_load_bars(12, 24, 35);
|
|
vt_show_palette_256();
|
|
return 0;
|
|
}
|
|
|
|
static void find_walk_dir(vfs_node_t* node, const char* current_path, const char* query) {
|
|
if (!node || !node->readdir) return;
|
|
|
|
for (uint32_t idx = 0; ; idx++) {
|
|
vfs_dirent_t* ent = node->readdir(node, idx);
|
|
if (!ent) break;
|
|
if (strcmp(ent->name, ".") == 0 || strcmp(ent->name, "..") == 0) continue;
|
|
|
|
char subpath[256];
|
|
if (strcmp(current_path, "/") == 0) {
|
|
snprintf(subpath, sizeof(subpath), "/%s", ent->name);
|
|
} else {
|
|
snprintf(subpath, sizeof(subpath), "%s/%s", current_path, ent->name);
|
|
}
|
|
|
|
if (!query || strstr(ent->name, query) != NULL) {
|
|
if (ent->type & FS_DIRECTORY) {
|
|
printk(ANSI_BRIGHT_BLUE "%s\n" ANSI_RESET, subpath);
|
|
} else {
|
|
printk("%s\n", subpath);
|
|
}
|
|
}
|
|
|
|
if (ent->type & FS_DIRECTORY) {
|
|
vfs_node_t* child = node->finddir ? node->finddir(node, ent->name) : NULL;
|
|
if (child) {
|
|
find_walk_dir(child, subpath, query);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int applet_find(int argc, char** argv) {
|
|
const char* start_path = "/";
|
|
const char* pattern = NULL;
|
|
|
|
if (argc >= 2) {
|
|
if (strcmp(argv[1], "-name") == 0 && argc >= 3) {
|
|
pattern = argv[2];
|
|
} else {
|
|
start_path = argv[1];
|
|
if (argc >= 4 && strcmp(argv[2], "-name") == 0) {
|
|
pattern = argv[3];
|
|
}
|
|
}
|
|
}
|
|
|
|
vfs_node_t* node = vfs_namei(start_path);
|
|
if (!node) {
|
|
printk(ANSI_RED "find: '%s': No such file or directory\n" ANSI_RESET, start_path);
|
|
return 1;
|
|
}
|
|
|
|
if (!pattern || strstr(start_path, pattern) != NULL) {
|
|
printk("%s\n", start_path);
|
|
}
|
|
find_walk_dir(node, start_path, pattern);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_traceroute(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: traceroute <host / ip>\n");
|
|
return 1;
|
|
}
|
|
const char* target = argv[1];
|
|
printk(ANSI_BRIGHT_CYAN "traceroute to %s (30 hops max, 60 byte packets)\n" ANSI_RESET, target);
|
|
|
|
const char* hops[] = {
|
|
"10.0.2.2 (gateway.local)",
|
|
"192.168.1.1 (router.home)",
|
|
"10.100.1.254 (core-switch.net)",
|
|
"72.14.215.10 (google-backbone.net)",
|
|
target
|
|
};
|
|
int total_hops = 5;
|
|
|
|
for (int i = 1; i <= total_hops; i++) {
|
|
uint32_t rtt = 1 + (i * 4);
|
|
printk(" %2d %-32s %u.%03u ms %u.%03u ms %u.%03u ms\n",
|
|
i, hops[i - 1], rtt, (rtt * 111) % 1000,
|
|
rtt + 1, (rtt * 222) % 1000, rtt + 2, (rtt * 333) % 1000);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ipcs(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "------ Message Queues --------\n" ANSI_RESET);
|
|
printk("key msqid owner perms used-bytes messages\n");
|
|
printk(ANSI_BRIGHT_CYAN "------ Shared Memory Segments --------\n" ANSI_RESET);
|
|
printk("key shmid owner perms bytes nattch\n");
|
|
printk(ANSI_BRIGHT_CYAN "------ Semaphore Arrays --------\n" ANSI_RESET);
|
|
printk("key semid owner perms nsems\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_virtinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const hypervisor_info_t* hv = virt_get_hypervisor_info();
|
|
printk("Hypervisor Detected: %s\n", hv ? hv->name : "None");
|
|
printk("Signature: '%s'\n", hv ? hv->signature : "");
|
|
printk("Virtualized: %s\n", virt_is_virtualized() ? "YES" : "NO");
|
|
printk("VirtIO Devices: %llu registered\n", (uint64_t)virtio_get_device_count());
|
|
for (size_t i = 0; i < virtio_get_device_count(); i++) {
|
|
const virtio_device_t* dev = virtio_get_device(i);
|
|
if (dev) printk(" [%llu] %s (IO: 0x%x, IRQ: %d)\n", (uint64_t)i, dev->name, dev->io_base, dev->irq);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_io_uring_test(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
io_uring_ring_t* ring = io_uring_get_default_ring();
|
|
if (!ring) {
|
|
printk(KERN_ERR "io_uring: Ring not available\n");
|
|
return 1;
|
|
}
|
|
|
|
io_uring_sqe_t* sqe = io_uring_get_sqe(ring);
|
|
if (!sqe) {
|
|
printk(KERN_ERR "io_uring: SQE allocation failed\n");
|
|
return 1;
|
|
}
|
|
|
|
sqe->opcode = IORING_OP_NOP;
|
|
sqe->user_data = 0x12345678;
|
|
|
|
int res = io_uring_submit(ring);
|
|
printk("io_uring: Submitted %d SQE(s). Checking CQE...\n", res);
|
|
|
|
io_uring_cqe_t* cqe = io_uring_peek_cqe(ring);
|
|
if (cqe) {
|
|
printk("io_uring: CQE Received! user_data=0x%llx res=%d [SUCCESS]\n",
|
|
cqe->user_data, cqe->res);
|
|
io_uring_cqe_seen(ring, cqe);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ps(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN " PID USER VSZ STAT COMMAND\n" ANSI_RESET);
|
|
printk(" 1 root 4096 S /init\n");
|
|
printk(" 2 root 0 S [kthreadd]\n");
|
|
printk(" 3 root 0 S [kworker/0:0]\n");
|
|
printk(" 4 root 1024 R /bin/lazybox (shell)\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_top(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk("Tasks: 4 total, 1 running, 3 sleeping, 0 stopped, 0 zombie\n");
|
|
printk("%%Cpu(s): 0.2 us, 0.5 sy, 0.0 ni, 99.3 id, 0.0 wa\n");
|
|
return applet_free(0, NULL);
|
|
}
|
|
|
|
static int applet_reboot(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_RED "Restarting system via ACPI/8042...\n" ANSI_RESET);
|
|
pit_sleep(200);
|
|
outb(0x64, 0xFE);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_poweroff(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_RED "System powering down via ACPI S5...\n" ANSI_RESET);
|
|
pit_sleep(200);
|
|
outw(0x604, 0x2000);
|
|
outw(0xB004, 0x2000);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_lazybox(int argc, char** argv);
|
|
|
|
// -------------------------------------------------------------
|
|
// Advanced Linux Subsystem Applets
|
|
// -------------------------------------------------------------
|
|
#include <mm/slab.h>
|
|
#include <kernel/trace.h>
|
|
#include <kernel/namespace.h>
|
|
#include <net/filter.h>
|
|
#include <sound/melody.h>
|
|
#include <userland/sh.h>
|
|
|
|
static int applet_sh(int argc, char** argv) {
|
|
return sh_main(argc, argv);
|
|
}
|
|
|
|
static int applet_slabinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "slabinfo - version: 2.1\n" ANSI_RESET);
|
|
printk(ANSI_YELLOW "# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab>\n" ANSI_RESET);
|
|
size_t count = slab_get_cache_count();
|
|
for (size_t i = 0; i < count; i++) {
|
|
const kmem_cache_t* c = slab_get_cache(i);
|
|
if (c && c->in_use) {
|
|
printk("%-18s %11u %10u %9llu %12llu %14d\n",
|
|
c->name, c->active_objects, c->active_objects + 16,
|
|
(uint64_t)c->object_size, (uint64_t)c->objects_per_slab, 1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_trace(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
if (strcmp(argv[1], "on") == 0) {
|
|
trace_enable(true);
|
|
printk(KERN_INFO "Tracing enabled\n");
|
|
return 0;
|
|
} else if (strcmp(argv[1], "off") == 0) {
|
|
trace_enable(false);
|
|
printk(KERN_INFO "Tracing disabled\n");
|
|
return 0;
|
|
} else if (strcmp(argv[1], "clear") == 0) {
|
|
trace_clear();
|
|
printk(KERN_INFO "Trace buffer cleared\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
size_t total = trace_get_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Kernel Event Trace Ringbuffer (%llu events) ===\n" ANSI_RESET, (uint64_t)total);
|
|
printk(ANSI_YELLOW "# CPU PID TIMESTAMP CATEGORY EVENT\n" ANSI_RESET);
|
|
const char* cat_names[] = {"SYS ", "IRQ ", "SCHED", "MM ", "NET ", "FS "};
|
|
|
|
for (size_t i = 0; i < total; i++) {
|
|
const trace_entry_t* e = trace_get_entry(i);
|
|
if (e) {
|
|
const char* cat_str = (e->category < TRACE_CAT_MAX) ? cat_names[e->category] : "MISC ";
|
|
printk("[%3u] %4u %10llu ms [%s] %s\n",
|
|
e->cpu_id, e->pid, e->timestamp * 10, cat_str, e->message);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_unshare(int argc, char** argv) {
|
|
const char* name = (argc >= 2) ? argv[1] : "isolated_container";
|
|
nsproxy_t* ns = namespace_create(name, CLONE_NEWPID | CLONE_NEWUTS | CLONE_NEWNS);
|
|
if (ns) {
|
|
printk(KERN_INFO "Created and entered isolated namespace ID %u ('%s')\n", ns->id, ns->name);
|
|
printk(" Hostname: %s\n", ns->uts.hostname);
|
|
printk(" PID Offset: %u\n", ns->pid_offset);
|
|
namespace_switch(ns->id);
|
|
} else {
|
|
printk(KERN_ERR "unshare: failed to create namespace\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_iptables(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "Chain INPUT (policy ACCEPT)\n" ANSI_RESET);
|
|
printk(ANSI_YELLOW "target prot opt source destination\n" ANSI_RESET);
|
|
size_t count = filter_get_rule_count();
|
|
for (size_t i = 0; i < count; i++) {
|
|
const filter_rule_t* r = filter_get_rule(i);
|
|
if (r && r->in_use) {
|
|
const char* act = (r->action == FILTER_ACTION_ACCEPT) ? "ACCEPT " : "DROP ";
|
|
const char* proto = (r->protocol == 1) ? "icmp" : (r->protocol == 6) ? "tcp " : (r->protocol == 17) ? "udp " : "all ";
|
|
printk("%s %-4s -- 0.0.0.0/0 0.0.0.0/0 dport:%-5u /* %s */ (pkts: %llu, bytes: %llu)\n",
|
|
act, proto, r->dst_port, r->comment, r->packet_count, r->byte_count);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_tune(int argc, char** argv) {
|
|
const char* which = (argc >= 2) ? argv[1] : "startup";
|
|
if (strcmp(which, "tetris") == 0) {
|
|
melody_play_tetris();
|
|
} else if (strcmp(which, "mario") == 0) {
|
|
melody_play_mario();
|
|
} else {
|
|
melody_play_startup();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_env(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const char* keys[] = {"PATH", "USER", "HOME", "SHELL", "TERM", "OS", NULL};
|
|
for (int i = 0; keys[i] != NULL; i++) {
|
|
const char* val = sh_get_env(keys[i]);
|
|
if (val) {
|
|
printk("%s=%s\n", keys[i], val);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_export(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
return applet_env(argc, argv);
|
|
}
|
|
for (int i = 1; i < argc; i++) {
|
|
char* eq = strchr(argv[i], '=');
|
|
if (eq) {
|
|
*eq = '\0';
|
|
sh_set_env(argv[i], eq + 1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_basename(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk("\n");
|
|
return 0;
|
|
}
|
|
const char* p = argv[1];
|
|
const char* last = strrchr(p, '/');
|
|
printk("%s\n", last ? last + 1 : p);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_dirname(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(".\n");
|
|
return 0;
|
|
}
|
|
char buf[256];
|
|
strncpy(buf, argv[1], sizeof(buf) - 1);
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
char* last = strrchr(buf, '/');
|
|
if (!last) {
|
|
printk(".\n");
|
|
} else if (last == buf) {
|
|
printk("/\n");
|
|
} else {
|
|
*last = '\0';
|
|
printk("%s\n", buf);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Server, Authentication & System Administration Applets
|
|
// -------------------------------------------------------------
|
|
#include <net/http.h>
|
|
#include <init/service.h>
|
|
#include <kernel/syslog.h>
|
|
#include <security/auth.h>
|
|
#include <kernel/cron.h>
|
|
#include <kernel/metrics.h>
|
|
|
|
static int applet_httpd(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
if (strcmp(argv[1], "start") == 0) {
|
|
uint16_t port = (argc >= 3) ? (uint16_t)atoi(argv[2]) : 80;
|
|
httpd_start(port);
|
|
return 0;
|
|
} else if (strcmp(argv[1], "stop") == 0) {
|
|
httpd_stop();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN "=== Embedded Micro HTTP Server & REST API ===\n" ANSI_RESET);
|
|
printk("Status: %s\n", httpd_is_running() ? ANSI_BRIGHT_GREEN "RUNNING" ANSI_RESET : ANSI_YELLOW "STOPPED" ANSI_RESET);
|
|
printk("Port: 80 (HTTP/1.1)\n");
|
|
printk("Requests Served: %u\n", httpd_get_requests_served());
|
|
printk("Usage: httpd [start [port] | stop | status]\n");
|
|
return 0;
|
|
}
|
|
|
|
#include <net/ssh.h>
|
|
|
|
static int applet_sshd(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
if (strcmp(argv[1], "start") == 0) {
|
|
uint16_t port = (argc >= 3) ? (uint16_t)atoi(argv[2]) : 22;
|
|
sshd_start(port);
|
|
return 0;
|
|
} else if (strcmp(argv[1], "stop") == 0) {
|
|
sshd_stop();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN "=== OpenSSH Remote Secure Shell Server (SSHD) ===\n" ANSI_RESET);
|
|
printk("Status: %s\n", sshd_is_running() ? ANSI_BRIGHT_GREEN "RUNNING" ANSI_RESET : ANSI_YELLOW "STOPPED" ANSI_RESET);
|
|
printk("Port: %u (SSH-2.0)\n", sshd_get_port());
|
|
printk("Active Sessions: %u\n", sshd_get_sessions_count());
|
|
printk("Usage: sshd [start [port] | stop | status]\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ssh(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: ssh [user@]hostname [command]\n");
|
|
return 1;
|
|
}
|
|
|
|
char username[32] = "SUB";
|
|
char host[64] = "localhost";
|
|
uint16_t port = 22;
|
|
|
|
const char* target = argv[1];
|
|
const char* at = strchr(target, '@');
|
|
if (at) {
|
|
size_t ulen = at - target;
|
|
if (ulen < sizeof(username)) {
|
|
memcpy(username, target, ulen);
|
|
username[ulen] = '\0';
|
|
}
|
|
strncpy(host, at + 1, sizeof(host) - 1);
|
|
} else {
|
|
strncpy(host, target, sizeof(host) - 1);
|
|
}
|
|
|
|
char cmd_buf[128] = "";
|
|
if (argc >= 3) {
|
|
for (int i = 2; i < argc; i++) {
|
|
strcat(cmd_buf, argv[i]);
|
|
if (i + 1 < argc) strcat(cmd_buf, " ");
|
|
}
|
|
}
|
|
|
|
char out_resp[1024];
|
|
if (ssh_client_execute(username, username, host, port, cmd_buf, out_resp, sizeof(out_resp)) == 0) {
|
|
printk("%s", out_resp);
|
|
if (cmd_buf[0] != '\0') {
|
|
// Execute the requested command
|
|
return lazybox_run_applet(argv[2], argc - 2, &argv[2]);
|
|
}
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "%s", out_resp);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_curl(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: curl <url|path>\n");
|
|
return 1;
|
|
}
|
|
char buf[2048];
|
|
if (http_client_get(argv[1], buf, sizeof(buf)) > 0) {
|
|
printk("%s\n", buf);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "curl: failed to retrieve %s\n", argv[1]);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_wget(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: wget <url>\n");
|
|
return 1;
|
|
}
|
|
printk("Connecting to %s... connected.\n", argv[1]);
|
|
return applet_curl(argc, argv);
|
|
}
|
|
|
|
static int applet_systemctl(int argc, char** argv) {
|
|
if (argc >= 3) {
|
|
if (strcmp(argv[1], "start") == 0) {
|
|
if (service_start(argv[2]) == 0) {
|
|
printk(KERN_INFO "Started %s\n", argv[2]);
|
|
} else {
|
|
printk(KERN_ERR "Failed to start %s\n", argv[2]);
|
|
}
|
|
return 0;
|
|
} else if (strcmp(argv[1], "stop") == 0) {
|
|
service_stop(argv[2]);
|
|
printk(KERN_INFO "Stopped %s\n", argv[2]);
|
|
return 0;
|
|
} else if (strcmp(argv[1], "restart") == 0) {
|
|
service_restart(argv[2]);
|
|
printk(KERN_INFO "Restarted %s\n", argv[2]);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN " UNIT LOAD ACTIVE SUB DESCRIPTION\n" ANSI_RESET);
|
|
size_t count = service_get_count();
|
|
for (size_t i = 0; i < count; i++) {
|
|
const service_unit_t* s = service_get_by_index(i);
|
|
if (s && s->in_use) {
|
|
const char* act = (s->state == SERVICE_STATE_RUNNING) ? ANSI_BRIGHT_GREEN "active running" ANSI_RESET : ANSI_BRIGHT_BLACK "inactive dead" ANSI_RESET;
|
|
printk(" %-26s loaded %-14s %s\n", s->name, act, s->description);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_logger(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: logger <message>\n");
|
|
return 1;
|
|
}
|
|
char buf[128] = "";
|
|
for (int i = 1; i < argc; i++) {
|
|
strcat(buf, argv[i]);
|
|
if (i + 1 < argc) strcat(buf, " ");
|
|
}
|
|
syslog_write(LOG_INFO | LOG_USER, "user", buf);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_logread(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
size_t count = syslog_get_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Syslog Telemetry Ringbuffer (%llu entries) ===\n" ANSI_RESET, (uint64_t)count);
|
|
for (size_t i = 0; i < count; i++) {
|
|
const syslog_entry_t* e = syslog_get_entry(i);
|
|
if (e) {
|
|
printk("[%6llus] <%s.%u> %s: %s\n",
|
|
(uint64_t)e->timestamp, e->facility_str, e->priority, e->ident, e->message);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_su(int argc, char** argv) {
|
|
const char* target = (argc >= 2) ? argv[1] : "SUB";
|
|
if (auth_set_current_user(target) == 0) {
|
|
printk(KERN_INFO "Switched to user '%s'\n", target);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "su: user '%s' does not exist\n", target);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_passwd(int argc, char** argv) {
|
|
const char* user = (argc >= 2) ? argv[1] : "SUB";
|
|
const char* new_pass = (argc >= 3) ? argv[2] : "password";
|
|
if (auth_change_password(user, new_pass) == 0) {
|
|
printk(KERN_INFO "passwd: password updated successfully for '%s'\n", user);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "passwd: user '%s' not found\n", user);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_useradd(int argc, char** argv) {
|
|
if (argc < 2) {
|
|
printk(KERN_INFO "Usage: useradd <username> [password]\n");
|
|
return 1;
|
|
}
|
|
const char* pass = (argc >= 3) ? argv[2] : "123456";
|
|
if (auth_add_user(argv[1], pass, 1000 + (uint32_t)auth_get_user_count(), 1000, "/home", "/bin/sh") == 0) {
|
|
printk(KERN_INFO "User '%s' created successfully\n", argv[1]);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "useradd: failed to create user\n");
|
|
return 1;
|
|
}
|
|
|
|
static int applet_crontab(int argc, char** argv) {
|
|
if (argc >= 3 && strcmp(argv[1], "-a") == 0) {
|
|
cron_add_job(argv[2], 60);
|
|
printk(KERN_INFO "crontab: scheduled periodic job '%s' (interval: 60s)\n", argv[2]);
|
|
return 0;
|
|
}
|
|
|
|
size_t count = cron_get_job_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== Active Scheduled Cron Jobs (%llu jobs) ===\n" ANSI_RESET, (uint64_t)count);
|
|
printk(ANSI_YELLOW "ID INTERVAL RUNS COMMAND\n" ANSI_RESET);
|
|
for (size_t i = 0; i < count; i++) {
|
|
const cron_job_t* j = cron_get_job(i);
|
|
if (j && j->in_use) {
|
|
printk("%-4u %-10u %-5u %s\n", j->id, j->interval_sec, j->run_count, j->command);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_vmstat(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
system_metrics_t m;
|
|
metrics_sample(&m);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----\n" ANSI_RESET);
|
|
printk(" r b swpd free buff cache si so bi bo in cs us sy id wa st\n");
|
|
printk(" 1 0 0 %6llu 110 12415 0 0 8 12 100 120 %2u %2u %2u 0 0\n",
|
|
m.mem_free_kb, m.cpu_user_pct, m.cpu_system_pct, m.cpu_idle_pct);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_iostat(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
system_metrics_t m;
|
|
metrics_sample(&m);
|
|
|
|
printk(ANSI_BRIGHT_CYAN "Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn\n" ANSI_RESET);
|
|
printk("sda 1.20 0.50 0.05 1440 64\n");
|
|
printk("ram0 0.10 0.00 0.00 0 0\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_netstat(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "Active Internet connections (servers and established)\n" ANSI_RESET);
|
|
printk(ANSI_YELLOW "Proto Recv-Q Send-Q Local Address Foreign Address State\n" ANSI_RESET);
|
|
|
|
if (sshd_is_running()) {
|
|
printk("tcp 0 0 0.0.0.0:%-5u 0.0.0.0:* LISTEN (sshd)\n", sshd_get_port());
|
|
}
|
|
if (httpd_is_running()) {
|
|
printk("tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN (httpd)\n");
|
|
}
|
|
printk("udp 0 0 0.0.0.0:53 0.0.0.0:* LISTEN (dns)\n");
|
|
printk("udp 0 0 0.0.0.0:68 0.0.0.0:* ESTABLISHED (dhcp)\n");
|
|
|
|
for (size_t i = 0; i < 8; i++) {
|
|
const ssh_session_t* s = sshd_get_session(i);
|
|
if (s && s->in_use) {
|
|
char client_ip_str[16];
|
|
ip_to_str(s->client_ip, client_ip_str);
|
|
printk("tcp 0 0 10.0.2.15:22 %s:%-5u ESTABLISHED (%s)\n",
|
|
client_ip_str, s->client_port, s->username);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_htop(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
system_metrics_t m;
|
|
metrics_sample(&m);
|
|
|
|
printk(ANSI_BRIGHT_CYAN " CPU[|||| 4.2%%] Tasks: 6, 1 thr, 1 running\n" ANSI_RESET);
|
|
printk(ANSI_BRIGHT_CYAN " Mem[|||||||||||||||| %4lluM/%5lluM] Uptime: %llu sec\n" ANSI_RESET,
|
|
m.mem_used_kb / 1024, m.mem_total_kb / 1024, (uint64_t)(pit_get_ticks() / 100));
|
|
printk(ANSI_YELLOW " PID USER PRI NI VIRT RES SHR S CPU%% MEM%% TIME+ Command\n" ANSI_RESET);
|
|
printk(" 1 root 20 0 4096 1024 512 S 0.0 0.8 0:00.05 /init\n");
|
|
printk(" 2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 [kthreadd]\n");
|
|
printk(" 3 root 20 0 1024 512 256 S 0.1 0.4 0:00.02 [syslogd]\n");
|
|
printk(" 4 root 20 0 2048 1024 512 S 0.2 0.8 0:00.04 [httpd:80]\n");
|
|
printk(" 5 root 20 0 1024 512 256 R 3.9 0.4 0:00.03 /bin/lazybox (htop)\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_bpftool(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
size_t count = bpf_get_prog_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS In-Kernel eBPF Programs (%llu loaded) ===\n" ANSI_RESET, (uint64_t)count);
|
|
printk(ANSI_YELLOW "ID TYPE INSNS RUNS TIME_NS NAME\n" ANSI_RESET);
|
|
for (size_t i = 0; i < count; i++) {
|
|
const bpf_prog_t* p = bpf_get_prog(i);
|
|
if (p && p->in_use) {
|
|
const char* tstr = "SOCKET_FILTER";
|
|
if (p->type == BPF_PROG_TYPE_KPROBE) tstr = "KPROBE ";
|
|
else if (p->type == BPF_PROG_TYPE_XDP) tstr = "XDP ";
|
|
printk("%-4u %s %-6u %-6llu %-8llu %s\n",
|
|
p->id, tstr, p->insn_count, p->run_count, p->total_runtime_ns, p->name);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_pmap(int argc, char** argv) {
|
|
uint32_t pid = (argc >= 2) ? (uint32_t)atoi(argv[1]) : 1;
|
|
vma_dump_maps(pid);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_lssys(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
kobject_dump_tree();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_ptyinfo(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
size_t active = pty_get_active_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Unix98 Pseudo-Terminal Subsystem (PTY) ===\n" ANSI_RESET);
|
|
printk("Active Pairs: %llu / %u\n", (uint64_t)active, PTY_MAX_PAIRS);
|
|
for (size_t i = 0; i < PTY_MAX_PAIRS; i++) {
|
|
const pty_pair_t* p = pty_get_pair(i);
|
|
if (p) {
|
|
printk(" [%u] Master: %-12s Slave: %-12s Status: %s\n",
|
|
p->pty_num, p->master_name, p->slave_name,
|
|
p->in_use ? ANSI_BRIGHT_GREEN "ACTIVE" ANSI_RESET : ANSI_YELLOW "IDLE" ANSI_RESET);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_desktop(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(KERN_INFO "Rendering 2D Graphical Desktop Canvas on Linear Framebuffer...\n");
|
|
canvas_render_desktop_mockup();
|
|
printk(ANSI_BRIGHT_GREEN "Desktop UI Frame Rendered (320x200 32bpp TrueColor)\n" ANSI_RESET);
|
|
return 0;
|
|
}
|
|
|
|
static int applet_lsblk(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
size_t count = block_get_device_count();
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Block Storage Devices (%llu devices) ===\n" ANSI_RESET, (uint64_t)count);
|
|
printk(ANSI_YELLOW "NAME MAJ:MIN SIZE TYPE MOUNTPOINTS\n" ANSI_RESET);
|
|
for (size_t i = 0; i < count; i++) {
|
|
block_device_t* dev = block_get_device_by_index(i);
|
|
if (dev) {
|
|
uint64_t sz_mb = (dev->total_sectors * dev->sector_size) / (1024 * 1024);
|
|
const char* mp = "-";
|
|
if (strcmp(dev->name, "sda") == 0) mp = "/";
|
|
else if (strcmp(dev->name, "ram0") == 0) mp = "/mnt/ramdisk";
|
|
else if (strcmp(dev->name, "nvme0n1") == 0) mp = "/mnt/nvme";
|
|
printk("%-12s 8:%-2u %4lluM disk %s\n",
|
|
dev->name, (uint32_t)i, sz_mb, mp);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_df(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const fat32_fs_t* f = fat32_get_fs_info();
|
|
printk(ANSI_YELLOW "Filesystem 1K-blocks Used Available Use%% Mounted on\n" ANSI_RESET);
|
|
printk("rootfs 512000 32400 479600 7%% /\n");
|
|
printk("devtmpfs 8192 0 8192 0%% /dev\n");
|
|
printk("procfs 0 0 0 0%% /proc\n");
|
|
printk("sysfs 0 0 0 0%% /sys\n");
|
|
printk("ramfs 8192 512 7680 6%% /mnt/ramdisk\n");
|
|
if (f && f->mounted) {
|
|
uint64_t total_kb = (uint64_t)f->total_clusters * (f->sectors_per_cluster * 512 / 1024);
|
|
uint64_t free_kb = (uint64_t)f->free_clusters * (f->sectors_per_cluster * 512 / 1024);
|
|
uint64_t used_kb = total_kb - free_kb;
|
|
uint32_t pct = (total_kb > 0) ? (uint32_t)((used_kb * 100) / total_kb) : 0;
|
|
printk("/dev/%-9s %9llu %9llu %9llu %3u%% %s (FAT32)\n",
|
|
f->dev ? f->dev->name : "sda", total_kb, used_kb, free_kb, pct, f->mountpoint);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int applet_mkfs_vfat(int argc, char** argv) {
|
|
const char* dev = (argc >= 2) ? argv[1] : "ram0";
|
|
const char* label = (argc >= 3) ? argv[2] : "SUBOS_FAT32";
|
|
if (fat32_format(dev, label) == 0) {
|
|
printk(ANSI_BRIGHT_GREEN "mkfs.vfat: successfully initialized FAT32 volume on %s (Label: %s)\n" ANSI_RESET, dev, label);
|
|
return 0;
|
|
}
|
|
printk(KERN_ERR "mkfs.vfat: failed to format device '%s'\n", dev);
|
|
return 1;
|
|
}
|
|
|
|
static int applet_lsdev(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
printk(ANSI_BRIGHT_CYAN "=== SUB-OS Active Hardware Device Drivers ===\n" ANSI_RESET);
|
|
printk(ANSI_YELLOW "SUBSYSTEM DRIVER STATUS DETAILS\n" ANSI_RESET);
|
|
printk("Storage NVMe PCIe ACTIVE Samsung 980 PRO 1TB (PCIe Gen4 x4)\n");
|
|
printk("Storage AHCI SATA ACTIVE Crucial MX500 SATA SSD (Port 0)\n");
|
|
printk("Storage VirtIO-Blk ACTIVE Para-virtualized Storage (/dev/vda)\n");
|
|
printk("Storage ATA / IDE ACTIVE Primary Master Drive (512B Sectors)\n");
|
|
printk("Network Intel E1000 ACTIVE 82540EM Gigabit Ethernet (eth0)\n");
|
|
printk("Network VirtIO-Net ACTIVE 10-Gigabit Virtual NIC (eth1)\n");
|
|
printk("Network RTL8139 ACTIVE Realtek 10/100 Fast Ethernet\n");
|
|
printk("Audio Intel HDA ACTIVE Azalia High Definition Audio (48kHz)\n");
|
|
printk("Audio AC97 ACTIVE Analog Devices AD1980 AC'97 Audio\n");
|
|
printk("Bus PCI Host ACTIVE PCI 2.3 Bus Master Enumerator\n");
|
|
printk("Bus USB 3.0 xHCI ACTIVE Extensible Host Controller (8 Ports)\n");
|
|
printk("Display Bochs VBE ACTIVE VESA/VBE Dynamic Resolution Engine\n");
|
|
printk("Display Linear FB ACTIVE VESA / Bochs Linear Framebuffer (32bpp)\n");
|
|
printk("Sensors CoreTemp DTS ACTIVE CPU Digital Thermal & Fan Tachometer\n");
|
|
printk("Entropy VirtIO-RNG ACTIVE True Hardware Random Generator (/dev/hwrng)\n");
|
|
printk("Input PS/2 Mouse ACTIVE Dual-packet Wheel Mouse Driver\n");
|
|
printk("Input PS/2 Kbd ACTIVE Scancode Set 1 AT Keyboard Driver\n");
|
|
return 0;
|
|
}
|
|
|
|
static int applet_sensors(int argc, char** argv) {
|
|
(void)argc; (void)argv;
|
|
const hwmon_data_t* hw = hwmon_get_data();
|
|
printk(ANSI_BRIGHT_CYAN "%s\n" ANSI_RESET, hw->chip_name);
|
|
printk("Adapter: ISA adapter\n");
|
|
printk("Package id 0: " ANSI_BRIGHT_GREEN "+%d.0 C" ANSI_RESET " (crit = +100.0 C)\n", hw->cpu_temp_celsius);
|
|
printk("Core 0: " ANSI_BRIGHT_GREEN "+%d.0 C" ANSI_RESET " (high = +80.0 C, crit = +100.0 C)\n", hw->cpu_temp_celsius - 1);
|
|
printk("Core 1: " ANSI_BRIGHT_GREEN "+%d.0 C" ANSI_RESET " (high = +80.0 C, crit = +100.0 C)\n", hw->cpu_temp_celsius + 1);
|
|
printk("Ambient: " ANSI_BRIGHT_CYAN "+%d.0 C" ANSI_RESET "\n", hw->ambient_temp_celsius);
|
|
printk("CPU Fan: " ANSI_YELLOW "%u RPM" ANSI_RESET " (min = 1000 RPM)\n", hw->fan_rpm);
|
|
printk("Vcore: " ANSI_WHITE "+%u.%02u V" ANSI_RESET "\n", hw->vcore_millivolts / 1000, (hw->vcore_millivolts % 1000) / 10);
|
|
printk("+12V: " ANSI_WHITE "+%u.%02u V" ANSI_RESET "\n", hw->v12_millivolts / 1000, (hw->v12_millivolts % 1000) / 10);
|
|
printk("+5V: " ANSI_WHITE "+%u.%02u V" ANSI_RESET "\n", hw->v5_millivolts / 1000, (hw->v5_millivolts % 1000) / 10);
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Kernel Core Diagnostics: KTest, RCU, Futex, Wait Queues, Page Cache
|
|
// -------------------------------------------------------------
|
|
static int applet_ktest(int argc, char** argv) {
|
|
if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
|
|
ktest_list_suites();
|
|
return 0;
|
|
}
|
|
|
|
ktest_result_t result;
|
|
int failures = (argc >= 2) ? ktest_run_suite(argv[1], &result)
|
|
: ktest_run_all(&result);
|
|
return (failures > 0) ? 1 : 0;
|
|
}
|
|
|
|
static int applet_rcuinfo(int argc, char** argv) {
|
|
if (argc >= 2 && strcmp(argv[1], "-s") == 0) {
|
|
printk("Forcing an RCU grace period...\n");
|
|
rcu_synchronize();
|
|
printk(ANSI_BRIGHT_GREEN "Grace period #%llu completed\n" ANSI_RESET,
|
|
(unsigned long long)rcu_get_grace_period());
|
|
return 0;
|
|
}
|
|
rcu_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_futexinfo(int argc, char** argv) {
|
|
futex_dump();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_waitinfo(int argc, char** argv) {
|
|
wait_dump_stats();
|
|
return 0;
|
|
}
|
|
|
|
static int applet_pagecache(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
if (strcmp(argv[1], "sync") == 0) {
|
|
int n = page_cache_sync();
|
|
printk("page cache: %d dirty page(s) written back\n", n);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "drop") == 0) {
|
|
page_cache_drop_all();
|
|
printk("page cache: flushed and dropped all clean pages\n");
|
|
return 0;
|
|
}
|
|
printk("Usage: pagecache [sync|drop]\n");
|
|
return 1;
|
|
}
|
|
page_cache_dump();
|
|
return 0;
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// Applet Dispatch Table (Over 70 Linux Tools)
|
|
// -------------------------------------------------------------
|
|
static const lazybox_applet_t applets[] = {
|
|
// Core & Scripting
|
|
{"lazybox", applet_lazybox, "lazybox [applet]", "Multi-call utility manager", "Core"},
|
|
{"sh", applet_sh, "sh <script> | -c <cmd>", "Shell script interpreter", "Core"},
|
|
{"echo", applet_echo, "echo [text...]", "Display text to stdout", "Core"},
|
|
{"env", applet_env, "env", "Print environment variables","Core"},
|
|
{"export", applet_export, "export VAR=VAL", "Set environment variable", "Core"},
|
|
{"whoami", applet_whoami, "whoami", "Print current user", "Core"},
|
|
{"id", applet_id, "id", "Print user and group IDs", "Core"},
|
|
{"date", applet_date, "date", "Display CMOS RTC date", "Core"},
|
|
{"cal", applet_cal, "cal", "Display calendar", "Core"},
|
|
|
|
// Filesystem & Editor
|
|
{"ls", applet_ls, "ls [path]", "List directory contents", "Filesystem"},
|
|
{"cat", applet_cat, "cat <file...>", "Concatenate files to stdout","Filesystem"},
|
|
{"touch", applet_touch, "touch <file...>", "Create empty files", "Filesystem"},
|
|
{"mkdir", applet_mkdir, "mkdir <dir...>", "Create directories", "Filesystem"},
|
|
{"pwd", applet_pwd, "pwd", "Print current directory", "Filesystem"},
|
|
{"cd", applet_cd, "cd <dir>", "Change directory", "Filesystem"},
|
|
{"wc", applet_wc, "wc <file>", "Count lines, words, bytes", "Filesystem"},
|
|
{"head", applet_head, "head [-n lines] <file>", "Output first lines of file", "Filesystem"},
|
|
{"tail", applet_tail, "tail <file>", "Output last lines of file", "Filesystem"},
|
|
{"stat", applet_stat, "stat <file>", "Display file status", "Filesystem"},
|
|
{"cp", applet_cp, "cp <src> <dst>", "Copy files", "Filesystem"},
|
|
{"grep", applet_grep, "grep <pattern> <file>", "Search pattern in file", "Filesystem"},
|
|
{"hexdump", applet_hexdump, "hexdump <file>", "Display hex dump of file", "Filesystem"},
|
|
{"basename", applet_basename, "basename <path>", "Strip directory path", "Filesystem"},
|
|
{"dirname", applet_dirname, "dirname <path>", "Strip non-directory suffix", "Filesystem"},
|
|
{"nano", applet_nano_wrapper, "nano [file]", "Visual full-screen editor", "Filesystem"},
|
|
|
|
// Server & Web
|
|
{"httpd", applet_httpd, "httpd [start|stop|status]", "Embedded micro HTTP server", "Server"},
|
|
{"sshd", applet_sshd, "sshd [start|stop|status]", "OpenSSH server daemon", "Server"},
|
|
{"ssh", applet_ssh, "ssh [user@]host [cmd]", "Secure shell remote client", "Server"},
|
|
{"curl", applet_curl, "curl <url>", "HTTP transfer utility", "Server"},
|
|
{"wget", applet_wget, "wget <url>", "Download files via HTTP", "Server"},
|
|
{"systemctl", applet_systemctl, "systemctl [cmd] [unit]", "Manage system service daemons","Server"},
|
|
{"service", applet_systemctl, "service [unit] [cmd]", "Service manager alias", "Server"},
|
|
{"crontab", applet_crontab, "crontab [-a job]", "Periodic cron job scheduler","Server"},
|
|
|
|
// Logging & Authentication
|
|
{"logger", applet_logger, "logger <msg>", "Send message to syslog", "Security"},
|
|
{"logread", applet_logread, "logread", "Read system logs", "Security"},
|
|
{"su", applet_su, "su [user]", "Switch user session", "Security"},
|
|
{"passwd", applet_passwd, "passwd [user]", "Change password", "Security"},
|
|
{"useradd", applet_useradd, "useradd <user>", "Add new user account", "Security"},
|
|
|
|
// Sound & Voice Synthesis
|
|
{"tts", applet_tts, "tts <text>", "Phonetic formant voice synth","Sound"},
|
|
{"tune", applet_tune, "tune [tetris|mario|startup]","8-bit retro chip melody player","Sound"},
|
|
{"alsamixer", applet_alsamixer, "alsamixer", "Audio control & mixer", "Sound"},
|
|
|
|
// Kernel, Diagnostics & Namespaces
|
|
{"lsmod", applet_lsmod, "lsmod", "Show kernel module status", "Kernel"},
|
|
{"insmod", applet_insmod, "insmod <mod>", "Insert kernel module", "Kernel"},
|
|
{"rmmod", applet_rmmod, "rmmod <mod>", "Remove kernel module", "Kernel"},
|
|
{"slabinfo", applet_slabinfo, "slabinfo", "Kernel SLAB cache statistics","Kernel"},
|
|
{"trace", applet_trace, "trace [on|off|dump|clear]", "Kernel execution event tracer","Kernel"},
|
|
{"unshare", applet_unshare, "unshare [name]", "Create isolated namespace", "Kernel"},
|
|
{"bpftool", applet_bpftool, "bpftool", "Inspect in-kernel BPF bytecode","Kernel"},
|
|
{"bpf", applet_bpftool, "bpf", "eBPF utility alias", "Kernel"},
|
|
{"pmap", applet_pmap, "pmap [pid]", "Process memory map viewer", "Kernel"},
|
|
{"lssys", applet_lssys, "lssys", "Sysfs kobject hierarchy tree","Kernel"},
|
|
{"ptyinfo", applet_ptyinfo, "ptyinfo", "Pseudo-terminal subsystem info","Kernel"},
|
|
{"desktop", applet_desktop, "desktop", "Render 2D GUI Canvas desktop","Kernel"},
|
|
{"draw", applet_desktop, "draw", "Canvas graphics demo", "Kernel"},
|
|
|
|
// Cryptography & Security
|
|
{"md5sum", applet_md5sum, "md5sum <file|text>", "Compute MD5 hash", "Crypto"},
|
|
{"sha256sum", applet_sha256sum, "sha256sum <file|text>", "Compute SHA-256 hash", "Crypto"},
|
|
{"crc32", applet_crc32, "crc32 <text>", "Calculate CRC32 checksum", "Crypto"},
|
|
{"cksum", applet_cksum, "cksum <text>", "Rust CRC-32C/Adler-32/FNV", "Crypto"},
|
|
{"rle", applet_rle, "rle <text>", "Rust RLE compress round-trip","Crypto"},
|
|
{"objdir", applet_objdir, "objdir [\\path]", "List the NT object namespace","Kernel"},
|
|
{"ntobj", applet_ntobj, "ntobj", "NT Object Manager stats/demo","Kernel"},
|
|
{"reg", applet_reg, "reg query|add|set|stats", "NT configuration registry", "Kernel"},
|
|
{"iodev", applet_iodev, "iodev", "NT I/O Manager devices & IRP","Kernel"},
|
|
{"hpet", applet_hpet, "hpet", "High Precision Event Timer", "Hardware"},
|
|
{"ktime", applet_ktime, "ktime", "Monotonic high-res clock", "Kernel"},
|
|
{"nvram", applet_nvram, "nvram", "Dump CMOS NVRAM bytes", "Hardware"},
|
|
{"lpt", applet_lpt, "lpt [text]", "Send text to LPT1 parallel", "Hardware"},
|
|
{"rand", applet_rand, "rand [count]", "Generate random numbers", "Crypto"},
|
|
{"certcheck", applet_certcheck, "certcheck", "View X.509 kernel keyring", "Security"},
|
|
{"capsh", applet_capsh, "capsh", "View process capabilities", "Security"},
|
|
{"ipcs", applet_ipcs, "ipcs", "Show IPC facilities status", "Security"},
|
|
|
|
// Network & Firewall
|
|
{"ifconfig", applet_ifconfig, "ifconfig", "Display network interface", "Network"},
|
|
{"ping", applet_ping, "ping <ip> [count]", "ICMP Echo ping utility", "Network"},
|
|
{"arp", applet_arp, "arp", "View ARP cache table", "Network"},
|
|
{"dhclient", applet_dhclient, "dhclient", "Request DHCP lease", "Network"},
|
|
{"nslookup", applet_nslookup, "nslookup <host>", "Query DNS name servers", "Network"},
|
|
{"iptables", applet_iptables, "iptables", "Firewall packet filter rules","Network"},
|
|
{"netstat", applet_netstat, "netstat", "Network port connections", "Network"},
|
|
|
|
// Storage & Devices
|
|
{"lsblk", applet_lsblk, "lsblk", "List block storage devices", "Storage"},
|
|
{"df", applet_df, "df", "Display filesystem disk usage","Storage"},
|
|
{"mkfs.vfat", applet_mkfs_vfat, "mkfs.vfat [dev] [label]", "Format FAT32 filesystem", "Storage"},
|
|
{"mkfs.fat32", applet_mkfs_vfat, "mkfs.fat32 [dev] [label]", "Format FAT32 alias", "Storage"},
|
|
{"lsdev", applet_lsdev, "lsdev", "List active hardware drivers", "Storage"},
|
|
{"hdparm", applet_hdparm, "hdparm", "Inspect ATA hard disk", "Storage"},
|
|
{"lspci", applet_lspci, "lspci", "List PCI devices", "Storage"},
|
|
{"speaker", applet_speaker, "speaker <freq> <dur_ms>", "Play PC speaker tone", "Storage"},
|
|
{"mouse", applet_mouse, "mouse", "Query PS/2 mouse cursor", "Storage"},
|
|
|
|
// Virtualization & Async I/O
|
|
{"virtinfo", applet_virtinfo, "virtinfo", "Hypervisor & VirtIO status", "Virtualization"},
|
|
{"io_uring_test", applet_io_uring_test, "io_uring_test", "Test io_uring async queue", "Virtualization"},
|
|
|
|
// System Monitoring & Metrics
|
|
{"sensors", applet_sensors, "sensors", "CPU Thermal & Fan Sensors", "System"},
|
|
{"uname", applet_uname, "uname [-a]", "Print system architecture", "System"},
|
|
{"free", applet_free, "free", "Display RAM and Heap usage", "System"},
|
|
{"uptime", applet_uptime, "uptime", "System running duration", "System"},
|
|
{"vmstat", applet_vmstat, "vmstat", "Virtual memory statistics", "System"},
|
|
{"iostat", applet_iostat, "iostat", "I/O device utilization", "System"},
|
|
{"htop", applet_htop, "htop", "Visual task manager", "System"},
|
|
{"dmesg", applet_dmesg, "dmesg", "Dump kernel boot ringbuffer","System"},
|
|
{"ps", applet_ps, "ps", "List active processes", "System"},
|
|
{"top", applet_top, "top", "Interactive task manager", "System"},
|
|
{"sleep", applet_sleep, "sleep <seconds>", "Delay execution", "System"},
|
|
{"reboot", applet_reboot, "reboot", "Reboot the computer", "System"},
|
|
{"poweroff", applet_poweroff, "poweroff", "Power off the computer", "System"},
|
|
{"clear", applet_clear, "clear", "Clear console screen", "Terminal"},
|
|
{"rustinfo", applet_rustinfo, "rustinfo", "Rust subsystem & safety telemetry", "System"},
|
|
{"chacha20", applet_chacha20, "chacha20 <text>", "Rust ChaCha20 stream cipher", "Crypto"},
|
|
{"sha3sum", applet_sha3sum, "sha3sum <text>", "Rust FIPS-202 SHA3-256 hash", "Crypto"},
|
|
{"dcache", applet_dcache, "dcache", "Rust VFS directory cache metrics", "Filesystem"},
|
|
{"watchdog", applet_watchdog, "watchdog", "Rust kernel health & watchdog", "System"},
|
|
{"jsonquery", applet_jsonquery, "jsonquery \"<json>\" <key>", "Rust zero-copy JSON extractor", "Core"},
|
|
{"cryptobench", applet_cryptobench, "cryptobench", "Rust cryptographic benchmark", "System"},
|
|
{"fdisk", applet_fdisk, "fdisk", "Rust MBR/GPT partition decoder", "Storage"},
|
|
{"rfilter", applet_rfilter, "rfilter", "Rust NetFilter firewall stats", "Network"},
|
|
{"subinfo", applet_subinfo, "subinfo", "SUB-Lang identity & signature", "System"},
|
|
{"subi", applet_subi, "subi <file.sb | -e \"code\">", "SUB-Lang in-kernel interpreter", "Core"},
|
|
{"subpower", applet_subpower, "subpower [temp] [load]", "SUB-Lang CPU power governor", "System"},
|
|
{"subbench", applet_subbench, "subbench [iterations]", "SUB-Lang recursive benchmark", "System"},
|
|
{"subquote", applet_subquote, "subquote [index]", "SUB-OS signature quote", "System"},
|
|
{"base64", applet_base64, "base64 [-d] <text>", "Rust RFC-4648 Base64 codec", "Crypto"},
|
|
{"pstree", applet_pstree, "pstree", "Display process tree hierarchy", "System"},
|
|
{"kill", applet_kill, "kill [-sig] <pid>", "Send signal to process", "System"},
|
|
{"tree", applet_tree, "tree [dir]", "Visual directory tree graph", "Filesystem"},
|
|
{"find", applet_find, "find [path] [-name query]", "Recursive file search", "Filesystem"},
|
|
{"traceroute", applet_traceroute, "traceroute <host/ip>", "Trace network route hops", "Network"},
|
|
{"snake", applet_snake, "snake [--demo]", "Interactive ANSI Snake Game", "Games"},
|
|
{"cppinfo", applet_cppinfo, "cppinfo", "C++ OOP kernel telemetry", "System"},
|
|
{"cpptest", applet_cpptest, "cpptest", "C++ polymorphism & new/del", "System"},
|
|
{"cppdevs", applet_cppdevs, "cppdevs", "C++ OOP device tree", "System"},
|
|
{"cppbench", applet_cppbench, "cppbench", "C++ OOP benchmark suite", "System"},
|
|
{"shm", applet_shm, "shm", "POSIX /dev/shm shared memory", "System"},
|
|
{"dnscache", applet_dnscache, "dnscache [-f]", "DNS resolver cache & metrics", "Network"},
|
|
{"beep", applet_beep, "beep [freq/jingle] [ms]", "PC speaker & HDA tone synth", "Sound"},
|
|
{"readelf", applet_readelf, "readelf [file.elf]", "Rust ELF binary inspector", "System"},
|
|
{"buddyinfo", applet_buddyinfo, "buddyinfo", "Rust buddy allocator stats", "System"},
|
|
{"aead", applet_aead, "aead [message]", "Rust ChaCha20-Poly1305 AEAD", "Crypto"},
|
|
{"tscinfo", applet_tscinfo, "tscinfo", "Hardware TSC cycle counter", "System"},
|
|
{"vtart", applet_vtart, "vtart [--palette/--bars]", "Terminal graphics visualizer", "Terminal"},
|
|
{"cpufreq", applet_cpufreq, "cpufreq [-g governor]", "CPU frequency & P-State gov", "System"},
|
|
{"gpuinfo", applet_gpuinfo, "gpuinfo", "VirtIO-GPU hardware status", "Virtualization"},
|
|
{"e1000e", applet_e1000e, "e1000e", "Intel e1000e PCIe NIC stats", "Network"},
|
|
{"startx", applet_startx, "startx", "Start SUB-OS Desktop GUI", "Desktop"},
|
|
{"gui", applet_startx, "gui", "Start SUB-OS Desktop GUI", "Desktop"},
|
|
{"desktop", applet_startx, "desktop", "Start SUB-OS Desktop GUI", "Desktop"},
|
|
|
|
// Kernel Core Diagnostics
|
|
{"ktest", applet_ktest, "ktest [suite|-l]", "Run in-kernel self-test suites", "Kernel"},
|
|
{"rcuinfo", applet_rcuinfo, "rcuinfo [-s]", "Tiny RCU grace period status", "Kernel"},
|
|
{"futexinfo", applet_futexinfo, "futexinfo", "Futex hash bucket telemetry", "Kernel"},
|
|
{"waitinfo", applet_waitinfo, "waitinfo", "Wait queue & sleeper statistics", "Kernel"},
|
|
{"pagecache", applet_pagecache, "pagecache [sync|drop]", "Block page cache & hit rate", "Storage"},
|
|
|
|
// Text Processing Suite (GNU coreutils compatible)
|
|
{"sort", coreutils_sort, "sort [-rnfu] <file>", "Sort lines of a text file", "Filesystem"},
|
|
{"uniq", coreutils_uniq, "uniq [-cdu] <file>", "Filter adjacent duplicate lines", "Filesystem"},
|
|
{"cut", coreutils_cut, "cut -f <n> [-d c] <file>", "Extract columns from lines", "Filesystem"},
|
|
{"tr", coreutils_tr, "tr <set1> <set2> <file>", "Translate or delete characters", "Filesystem"},
|
|
{"rev", coreutils_rev, "rev <file>", "Reverse characters of each line", "Filesystem"},
|
|
{"tac", coreutils_tac, "tac <file>", "Print file lines in reverse", "Filesystem"},
|
|
{"nl", coreutils_nl, "nl [-a] <file>", "Number the lines of a file", "Filesystem"},
|
|
{"seq", coreutils_seq, "seq [first [step]] last", "Print a sequence of numbers", "Core"},
|
|
{"diff", coreutils_diff, "diff <file1> <file2>", "Compare files line by line", "Filesystem"},
|
|
{"xxd", coreutils_xxd, "xxd [-l n] <file>", "Canonical hex + ASCII dump", "Filesystem"},
|
|
{"du", coreutils_du, "du [-s] [path]", "Estimate file space usage", "Storage"},
|
|
{"factor", coreutils_factor, "factor <number...>", "Print prime factorization", "Core"},
|
|
{"sum", coreutils_sum, "sum <file>", "BSD 16-bit rotating checksum", "Crypto"},
|
|
{"truncate", coreutils_truncate, "truncate -s <n> <file>", "Shrink or extend a file", "Filesystem"},
|
|
|
|
{NULL, NULL, NULL, NULL, NULL}
|
|
};
|
|
|
|
static int applet_lazybox(int argc, char** argv) {
|
|
if (argc >= 2) {
|
|
return lazybox_run_applet(argv[1], argc - 1, &argv[1]);
|
|
}
|
|
|
|
printk(ANSI_BRIGHT_CYAN "LazyBox v%s (2026-08-16) Linux-Compatible Multi-Call Suite\n" ANSI_RESET, LAZYBOX_VERSION);
|
|
printk("Usage: lazybox [function] [arguments]...\n\n");
|
|
printk(ANSI_YELLOW "Defined Applet Categories:\n" ANSI_RESET);
|
|
|
|
const char* cats[] = {"Core", "Filesystem", "Sound", "Kernel", "Crypto", "Security", "Network", "Storage", "Virtualization", "System", "Terminal", NULL};
|
|
for (int c = 0; cats[c] != NULL; c++) {
|
|
printk(ANSI_BRIGHT_GREEN " [%s]\n " ANSI_RESET, cats[c]);
|
|
for (int i = 0; applets[i].name != NULL; i++) {
|
|
if (strcmp(applets[i].category, cats[c]) == 0) {
|
|
printk(" %-14s", applets[i].name);
|
|
}
|
|
}
|
|
printk("\n");
|
|
}
|
|
printk("\n");
|
|
return 0;
|
|
}
|
|
|
|
void lazybox_init(void) {
|
|
// Initialized
|
|
}
|
|
|
|
bool lazybox_has_applet(const char* name) {
|
|
if (!name) return false;
|
|
for (int i = 0; applets[i].name != NULL; i++) {
|
|
if (strcmp(applets[i].name, name) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int lazybox_run_applet(const char* name, int argc, char** argv) {
|
|
if (!name) return -1;
|
|
for (int i = 0; applets[i].name != NULL; i++) {
|
|
if (strcmp(applets[i].name, name) == 0) {
|
|
return applets[i].func(argc, argv);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|