NAME
+ dhcp - obtain network configuration via DHCP
+
+SYNOPSIS
+ dhcp
+
+DESCRIPTION
+ The DHCP client automatically obtains an IP address, subnet mask,
+ default gateway, and other network parameters from a DHCP server
+ on the local network using the Dynamic Host Configuration Protocol
+ (RFC 2131).
+
+ On success the network configuration is applied immediately via
+ set_netcfg(). On failure the original configuration is restored.
+
+ The client is run automatically by the init system at boot, but
+ may also be invoked manually from the shell.
+
+PROTOCOL
+ The client performs the standard four-message DHCP exchange:
+
+ 1. DHCPDISCOVER Broadcast to 255.255.255.255:67
+ 2. DHCPOFFER Server offers an IP address
+ 3. DHCPREQUEST Client accepts the offered address
+ 4. DHCPACK Server confirms the lease
+
+ The BROADCAST flag (0x8000) is set so that server replies are
+ sent to the broadcast address, since the client has no IP yet.
+
+ Each step has a 10-second timeout. If no response is received
+ the client exits with an error and restores the previous config.
+
+OUTPUT
+ On success the client prints the assigned configuration:
+
+ IP Address, Subnet Mask, Gateway, DNS Server, Lease Time
+
+OPTIONS
+ The DHCP client requests the following options from the server:
+
+ 1 Subnet Mask
+ 3 Router (default gateway)
+ 6 DNS Server
+ 51 Lease Time
+
+SEE ALSO
+ ifconfig(1), shell(1), syscalls(2)
NAME
+ edit - text editor for MontaukOS
+
+SYNOPSIS
+ edit [filename]
+
+DESCRIPTION
+ edit is an interactive text editor. When invoked with a filename,
+ it opens the file for editing. If the file does not exist, a new
+ empty buffer is created and will be saved to that path on write.
+
+ When invoked without arguments, edit opens an empty buffer. You
+ will be prompted for a filename when saving.
+
+KEYBOARD SHORTCUTS
+
+ Navigation
+ Arrow Keys Move cursor up/down/left/right
+ Home Move to start of line
+ End Move to end of line
+ Page Up Scroll up one page
+ Page Down Scroll down one page
+
+ Editing
+ Backspace Delete character before cursor
+ Delete Delete character at cursor
+ Enter Insert new line
+ Tab Insert 4 spaces
+
+ Commands
+ Ctrl+S Save file
+ Ctrl+Q Quit (warns if unsaved changes)
+ Ctrl+F Search for text
+ Ctrl+G Find next occurrence
+
+DISPLAY
+ The top line shows the filename, a modified indicator [+],
+ and the current cursor position (Ln, Col).
+
+ The bottom line shows keyboard shortcuts or status messages.
+
+ Line numbers are displayed in a gutter on the left side.
+ Lines past the end of the file are marked with ~.
+
+EXAMPLES
+ edit intro.1 Edit a file
+ edit Open a new empty buffer
+
+SEE ALSO
+ cat(1), shell(1)
NAME
+ fetch - HTTP/HTTPS client for MontaukOS
+
+SYNOPSIS
+ fetch [-v] <url>
+ fetch [-v] <host> <port> [path]
+
+DESCRIPTION
+ fetch performs an HTTP/1.0 GET request and prints the response
+ body to the terminal. Supports both plain HTTP and HTTPS (TLS 1.2)
+ connections. By default only the body is printed.
+
+ In URL mode, the scheme (http:// or https://) determines whether
+ TLS is used. The port defaults to 80 for HTTP and 443 for HTTPS.
+
+ In legacy mode, the host and port are specified as separate
+ arguments and the connection is always plain HTTP.
+
+ The host may be an IP address or a hostname. Hostnames are
+ resolved via the configured DNS server.
+
+ If no path is given, "/" is used.
+
+OPTIONS
+-v
+ Verbose mode. Print connection info, trust anchor count, TLS
+ handshake progress, and the HTTP status/size header before
+ the body.
+
+EXAMPLES
+ fetch https://icanhazip.com
+ Print your public IP address over HTTPS.
+
+ fetch http://icanhazip.com
+ Same, but over plain HTTP.
+
+ fetch -v https://example.com
+ Fetch a page with verbose output showing:
+ Connecting to example.com:443 (HTTPS)...
+ Loaded 128 trust anchors
+ TLS handshake...
+ TLS connection established
+ GET /
+ HTTP 200 OK (1256 bytes)
+
+ fetch 10.0.68.1 80 /
+ Fetch from a local server by IP (legacy syntax).
+
+TLS SUPPORT
+ HTTPS connections use BearSSL for TLS 1.2. Server certificates
+ are validated against the system CA bundle at
+ 0:/os/certs/ca-certificates.crt.
+
+ Entropy for the TLS handshake is provided by RDTSC-seeded
+ random data via the SYS_GETRANDOM syscall.
+
+KEYBOARD
+ Ctrl+Q Abort the request
+
+SEE ALSO
+ ping(1), nslookup(1), tcpconnect(1), shell(1), syscalls(2)
NAME
+ open, read, getsize, close, readdir - file I/O system calls
+
+SYNOPSIS
+ int montauk::open(const char* path);
+ int montauk::read(int handle, uint8_t* buf, uint64_t offset, uint64_t size);
+ uint64_t montauk::getsize(int handle);
+ void montauk::close(int handle);
+ int montauk::readdir(const char* path, const char** names, int max);
+
+DESCRIPTION
+ MontaukOS provides a Virtual File System (VFS) with read/write
+ support. Drive 0 is the boot ramdisk; additional drives may be
+ mounted from GPT partitions backed by FAT32 or ext2 (see
+ syscalls(2), STORAGE section). Files are accessed via paths in
+ the format "<drive>:/<path>".
+
+ open
+ Opens a file and returns a non-negative handle on success, or a
+ negative value on error (file not found, no free handles).
+
+ int h = montauk::open("0:/os/hello.elf");
+
+ read
+ Reads up to 'size' bytes starting at 'offset' into 'buf'.
+ Returns the number of bytes actually read, or negative on error.
+ There is no implicit file position -- the offset is explicit on
+ every call.
+
+ uint8_t buf[512];
+ int n = montauk::read(h, buf, 0, 512);
+
+ getsize
+ Returns the total size in bytes of the file.
+
+ uint64_t sz = montauk::getsize(h);
+
+ close
+ Closes the file handle and frees kernel resources.
+
+ montauk::close(h);
+
+ readdir
+ Lists entries in a directory. Up to 'max' entry names (VFS cap
+ 256, driver-backed listings such as 0:/os/ cap 128) are written
+ to the 'names' array. The kernel allocates a user-accessible
+ page for the string data automatically. Directory entries are
+ returned with a trailing slash.
+
+ const char* entries[64];
+ int count = montauk::readdir("0:/", entries, 64);
+ // entries: "os/", "apps/", "man/", "www/", "users/", ...
+
+ For directories that may contain more entries than fit in one
+ call, use montauk::readdir_at(path, names, max, startIndex) and
+ advance startIndex by the returned count until it returns 0.
+
+READING PATTERN
+ The standard pattern for reading a file:
+
+ int h = montauk::open("0:/man/intro.1");
+ uint64_t size = montauk::getsize(h);
+ uint8_t buf[512];
+ uint64_t off = 0;
+ while (off < size) {
+ uint64_t chunk = size - off;
+ if (chunk > 511) chunk = 511;
+ int n = montauk::read(h, buf, off, chunk);
+ if (n <= 0) break;
+ buf[n] = '\0';
+ montauk::print((const char*)buf);
+ off += n;
+ }
+ montauk::close(h);
+
+WRITING, DELETING, RENAMING
+ int montauk::fcreate(const char* path);
+ int montauk::fwrite(int handle, const uint8_t* buf, uint64_t offset, uint64_t size);
+ int montauk::fdelete(const char* path);
+ int montauk::fmkdir(const char* path);
+ int montauk::frename(const char* oldPath, const char* newPath);
+
+ fcreate creates a new file and returns a handle. fwrite writes
+ bytes at the given offset. fdelete removes a file, fmkdir
+ creates a directory, and frename renames or moves a file or
+ directory (the basis for file manager move operations).
+
+ On drive 0 (the ramdisk), changes persist only until reboot --
+ the ramdisk is reloaded from the USTAR archive on each boot. On
+ disk-backed drives (FAT32/ext2 partitions mounted with
+ montauk::fs_mount), changes are written through to storage; use
+ montauk::fs_sync() to flush caches before power-off.
+
+NOTES
+ Drive 0 is loaded at boot from a USTAR tar archive into RAM.
+ Other drives are mounted on demand from GPT partitions on
+ SATA/NVMe/USB block devices; see syscalls(2), STORAGE and
+ DEVICES sections.
+
+SEE ALSO
+ syscalls(2), spawn(2), malloc(3)
NAME
+ fontscale - get or set terminal font scale
+
+SYNOPSIS
+ fontscale
+ fontscale <n>
+ fontscale <x> <y>
+
+DESCRIPTION
+ Controls the terminal font scale factor. The Flanterm terminal
+ emulator renders text at a configurable scale multiplier.
+ Increasing the scale makes text larger, which is useful on
+ high-resolution displays or real hardware where text may be
+ too small to read comfortably.
+
+ With no arguments, prints the current scale factor and terminal
+ dimensions.
+
+ With one argument, sets both the horizontal and vertical scale
+ to the same value.
+
+ With two arguments, sets asymmetric horizontal and vertical
+ scale factors independently.
+
+ Valid scale values are 1 through 8. After rescaling, the screen
+ is cleared.
+
+OUTPUT
+ fontscale
+ Scale: 1x1 (160 cols x 50 rows)
+
+ fontscale 2
+ Scale set to 2x2 (80 cols x 25 rows)
+
+EXAMPLES
+ fontscale Show current scale and dimensions
+ fontscale 2 Double the font size
+ fontscale 3 2 3x horizontal, 2x vertical
+ fontscale 1 Reset to default size
+
+SEE ALSO
+ shell(1), syscalls(2)
NAME
+ fb_info, fb_map - direct framebuffer access
+
+SYNOPSIS
+ void montauk::fb_info(montauk::abi::FbInfo* info);
+ void* montauk::fb_map();
+
+DESCRIPTION
+ These syscalls allow userspace programs to access the linear
+ framebuffer directly for graphical output.
+
+ fb_info
+ Fills in an FbInfo structure with the framebuffer geometry:
+
+ montauk::abi::FbInfo fb;
+ montauk::fb_info(&fb);
+ // fb.width, fb.height, fb.pitch, fb.bpp
+
+ The pitch is the number of bytes per scanline (may be larger
+ than width * 4 due to alignment). bpp is always 32.
+
+ fb_map
+ Maps the physical framebuffer into the process address space at
+ a fixed virtual address (0x50000000) and returns that address.
+
+ uint32_t* pixels = (uint32_t*)montauk::fb_map();
+
+ Each pixel is a 32-bit value in 0xAARRGGBB format (blue in the
+ low byte). Writing to this memory directly updates the screen.
+
+PIXEL FORMAT
+ Bits 31-24: Alpha (unused, typically 0xFF)
+ Bits 23-16: Red
+ Bits 15-8: Green
+ Bits 7-0: Blue
+
+ Example: red = 0x00FF0000, green = 0x0000FF00, blue = 0x000000FF
+
+EXAMPLE
+ Fill the screen with blue:
+
+ montauk::abi::FbInfo fb;
+ montauk::fb_info(&fb);
+ uint32_t* pixels = (uint32_t*)montauk::fb_map();
+
+ for (uint64_t y = 0; y < fb.height; y++) {
+ uint32_t* row = (uint32_t*)((uint8_t*)pixels + y * fb.pitch);
+ for (uint64_t x = 0; x < fb.width; x++) {
+ row[x] = 0x000000FF;
+ }
+ }
+
+NOTES
+ After mapping, the cursor overlay is not composited. Programs
+ that use the framebuffer take full control of screen output.
+
+ Only one mapping per process is supported. Calling fb_map()
+ multiple times returns the same address.
+
+SEE ALSO
+ syscalls(2), malloc(3)
NAME
+ init - MontaukOS init system
+
+SYNOPSIS
+ Spawned automatically by the kernel as PID 0.
+
+DESCRIPTION
+ init is the first userspace process started by the MontaukOS
+ kernel. It chains system services in sequence, then launches
+ the interactive shell.
+
+ Each service is spawned as a child process. init waits for it
+ to exit before starting the next one. If a service fails to
+ spawn, init logs an error and continues to the next stage.
+
+ Log output is timestamped and color-coded:
+
+ HH:MM:SS INFO init Starting dhcp
+ HH:MM:SS OK init dhcp finished (pid 1)
+
+BOOT SEQUENCE
+ The following services are started in order:
+
+ 1. 0:/os/dhcp.elf Obtain network configuration via DHCP
+ 2. 0:/os/shell.elf Launch the interactive shell
+
+ After the shell exits, init enters an idle loop.
+
+LOG LEVELS
+ init uses four log levels, each with a distinct color:
+
+ OK Green Service completed successfully
+ INFO Cyan Informational (service starting, etc.)
+ WARN Yellow Non-fatal warning
+ FAIL Red Service failed to start
+
+SEE ALSO
+ dhcp(1), shell(1), syscalls(2)
NAME
+ intro - introduction to MontaukOS userspace
+
+DESCRIPTION
+ MontaukOS is a hobbyist 64-bit operating system written in C++20,
+ currently at version 0.1.7 (API version 8). Userspace programs
+ run in Ring 3, are loaded as static ELF64 binaries, and
+ communicate with the kernel through the x86-64 SYSCALL/SYSRET
+ mechanism (150 syscalls -- see syscalls(2)).
+
+ Programs are compiled with a freestanding cross-compiler and
+ linked at virtual address 0x400000. There is no standard C
+ library for C++ programs -- all system interaction goes through
+ the montauk:: syscall wrappers. A desktop environment with a
+ window server, GUI apps, and Bluetooth/audio/networking stacks
+ runs on top of the same syscall API.
+
+GETTING STARTED
+ To write a new system/CLI program, create a directory under
+ programs/src/ with a main.cpp file. The entry point is:
+
+ extern "C" void _start() { ... }
+
+ There is no argc/argv. Use montauk::getargs() to retrieve any
+ arguments passed by the parent process. Include <montauk/syscall.h>
+ for the full typed syscall API. GUI apps additionally use
+ win_create()/win_poll()/win_present() from montauk/Window.hpp
+ (see framebuffer(2)).
+
+ Build with:
+
+ cd programs && make
+
+ System/CLI binaries appear in programs/bin/os/; GUI app bundles
+ (ELF + manifest.toml + icon) appear under programs/bin/apps/<name>/.
+
+RAMDISK LAYOUT
+ The boot ramdisk is mounted as drive 0 with the following
+ directory structure:
+
+ 0:/os/ System/CLI binaries (shell, init, man, etc.),
+ plus os-owned data: certs/, firmware/,
+ licenses/, wallpapers/
+ 0:/apps/ GUI app bundles, one directory per app
+ (<app>.elf + manifest.toml + icon)
+ 0:/config/ System-wide config TOMLs
+ 0:/users/<name>/ Per-user home directories (created at
+ login), with Music/, Videos/, Pictures/,
+ config/ subdirectories
+ 0:/fonts/ Shared fonts
+ 0:/icons/ Shared icons
+ 0:/man/ Manual pages
+ 0:/www/ Web server content
+ 0:/lib/ Lua and TinyCC toolchain payloads
+ 0:/boot/ Kernel, bootloader, ramdisk image
+
+ There is no 0:/games/, 0:/common/, 0:/home/, or 0:/etc/ --
+ these were used by earlier single-user releases and no longer
+ exist. Games and other GUI programs (including doom) ship as
+ bundles under 0:/apps/.
+
+SHELL
+ The interactive shell is the primary way to interact with
+ MontaukOS. Commands are resolved against the current directory
+ first, then 0:/os/. Type 'help' at the shell prompt for a list
+ of commands. Use 'man shell' for detailed shell documentation.
+
+MAN PAGES
+ The following man pages are available:
+
+ intro(1) This page
+ shell(1) Shell commands reference
+ init(1) Init system
+ dhcp(1) DHCP client
+ fetch(1) HTTP client
+ ping(1) ICMP ping
+ nslookup(1) DNS lookup
+ fontscale(1) Terminal font scaling
+ edit(1) Text editor
+ man(1) The man command itself
+ printctl(1) Printer control
+ printd(1) Print spooler daemon
+ wiki(1) Wikipedia article viewer
+ legal(7) Copyright and legal information
+ tls-errors(5) TLS/BearSSL error reference
+ syscalls(2) Overview of all syscalls
+ spawn(2) Process spawning
+ file(2) File I/O syscalls
+ framebuffer(2) Framebuffer access
+ malloc(3) Memory allocation
+
+SEE ALSO
+ shell(1), syscalls(2), malloc(3)
NAME
+ MontaukOS legal/copyright information
+
+DESCRIPTION
+ Copyright (c) 2025-2026 Daniel Hammer, et al.
+ (includes contributors to other projects, i.e. The Limine Bootloader. Please refer to any other project's own license.)
+
+ MontaukOS is source-available software, provided under the terms of the
+ MontaukOS Software License. The full license text is on this system at
+ 0:/os/licenses/LICENSE.txt.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ == License for the Limine C++ template (certain portions derive therefrom) ==
+ Copyright (C) 2023-2026 Mintsuki and contributors.
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
+
+THIRD-PARTY COMPONENTS
+ MontaukOS is distributed together with third-party components that remain
+ under their own licenses, including:
+
+ * Flat Remix icon theme, Copyright (C) Daniel Ruiz de Alegria - GPLv3
+ * DOOM engine (doom.elf, via doomgeneric), Copyright (C) id Software, Inc.
+ and contributors - GPLv2
+ * Limine bootloader, Copyright (C) Mintsuki and contributors - BSD 2-Clause
+ * BearSSL, Copyright (c) Thomas Pornin - MIT
+ * stb_image, Copyright (c) Sean Barrett - MIT
+ * JetBrains Mono font, Copyright The JetBrains Mono Project Authors - OFL-1.1
+ * Noto Serif font, Copyright The Noto Project Authors - OFL-1.1
+ * Roboto font, Copyright The Roboto Project Authors - OFL-1.1
+ * C059 font (URW Base 35), Copyright (C) (URW)++ Design and Development
+ GmbH - AGPLv3 with font-embedding exception
+ * Tiny C Compiler (tcc.elf, 0:/lib/tcc), Copyright (c) Fabrice Bellard and
+ contributors - LGPL-2.1
+ * Lua (lua.elf, 0:/lib/lua), Copyright (C) Lua.org, PUC-Rio - MIT
+ * Mozilla CA certificate bundle (0:/os/certs), Mozilla CA Certificate
+ Program - MPL-2.0
+ * Intel Bluetooth firmware (0:/os/firmware/intel), Copyright (c) Intel
+ Corporation - Intel redistributable firmware license
+ * Default wallpaper photo (0:/os/wallpapers), by Nikhil Kumar -
+ Unsplash License
+
+ Full license texts and notices are on this system in 0:/os/licenses/.
NAME
+ malloc, mfree, realloc - userspace heap allocation
+
+SYNOPSIS
+ void* montauk::malloc(uint64_t size);
+ void montauk::mfree(void* ptr);
+ void* montauk::realloc(void* ptr, uint64_t size);
+
+DESCRIPTION
+ The userspace heap provides dynamic memory allocation on top of
+ the kernel's page-mapping syscall (SYS_ALLOC). Include the
+ header <montauk/heap.h> to use these functions.
+
+ malloc
+ Allocates 'size' bytes from the free list. Returns a 16-byte
+ aligned pointer, or nullptr on failure. When the free list is
+ empty, it requests more pages from the kernel via SYS_ALLOC
+ (minimum 16 KiB growth, initial seed of 64 KiB).
+
+ char* buf = (char*)montauk::malloc(1024);
+
+ mfree
+ Returns the block to the userspace free list. No syscall is
+ made -- the memory stays mapped and is immediately reusable.
+ Passing nullptr is a safe no-op.
+
+ montauk::mfree(buf);
+
+ realloc
+ Resizes the allocation to 'size' bytes. Allocates a new block,
+ copies the smaller of old/new sizes, and frees the old block.
+ If ptr is nullptr, behaves like malloc.
+
+ buf = (char*)montauk::realloc(buf, 2048);
+
+IMPLEMENTATION
+ The allocator uses a linked free-list with first-fit search.
+ Blocks larger than needed are split. The allocation header is
+ 16 bytes (magic + size). All allocations are 16-byte aligned.
+
+ The heap grows by requesting pages from the kernel via
+ SYS_ALLOC. These pages are never returned to the kernel (since
+ SYS_FREE is currently a no-op), but mfree makes them available
+ for future malloc calls within the process.
+
+LOW-LEVEL PAGE API
+ For large allocations or when direct page control is needed:
+
+ void* montauk::alloc(uint64_t size); // SYS_ALLOC
+ void montauk::free(void* ptr); // SYS_FREE (no-op)
+
+ alloc() maps zeroed pages starting at 0x40000000 and growing
+ upward. Size is rounded up to 4 KiB page boundaries.
+
+SEE ALSO
+ syscalls(2), file(2)
NAME
+ man - display manual pages
+
+SYNOPSIS
+ man topic
+ man section topic
+
+DESCRIPTION
+ The man command displays manual pages from the ramdisk in a
+ fullscreen pager. Pages are stored as plain text files with
+ simple formatting directives.
+
+ If no section is specified, sections 1 through 7 are searched
+ in order. If a section number is given, only that section is
+ checked.
+
+KEY BINDINGS
+
+Navigation
+ j, Down Arrow Scroll down one line
+ k, Up Arrow Scroll up one line
+ Space, Page Down Scroll down one page
+ b, Page Up Scroll up one page
+ g, Home Go to top
+ G, End Go to bottom
+ q Quit
+
+SECTIONS
+ 1 User commands and programs
+ 2 System calls (kernel interface)
+ 3 Library functions (userspace libraries)
+ 7 Miscellaneous (legal, conventions)
+
+FILES
+ Man pages are stored on the ramdisk at:
+
+ 0:/man/<topic>.<section>
+
+ For example, man intro reads 0:/man/intro.1
+
+EXAMPLES
+ man intro View the introduction
+ man 2 syscalls View syscall overview (section 2)
+ man malloc View malloc documentation
+ man legal View copyright information
+
+SEE ALSO
+ intro(1), shell(1), syscalls(2)
NAME
+ nslookup - DNS hostname lookup
+
+SYNOPSIS
+ nslookup <hostname>
+
+DESCRIPTION
+ Resolves a hostname to an IPv4 address using the configured
+ DNS server and prints the result.
+
+ The kernel DNS resolver sends a UDP query to port 53 of the
+ configured DNS server and waits up to 5 seconds for a reply.
+ Results are cached in an 8-entry kernel cache with TTL support.
+
+OUTPUT
+ Server: 10.0.68.1
+ Name: example.com
+ Address: 93.184.216.34
+ Time: 3ms
+
+ If the lookup fails:
+
+ Could not resolve: badhost.invalid
+
+DNS CONFIGURATION
+ The DNS server address is obtained automatically via DHCP.
+ It can also be viewed and set with ifconfig. The default
+ is 10.0.68.1 (QEMU user-mode networking).
+
+EXAMPLES
+ nslookup google.com
+ nslookup icanhazip.com
+
+SEE ALSO
+ ping(1), fetch(1), dhcp(1), ifconfig(1), syscalls(2)
NAME
+ ping - send ICMP echo requests
+
+SYNOPSIS
+ ping <host>
+
+DESCRIPTION
+ Sends 4 ICMP echo requests to the specified host and prints
+ the round-trip time for each reply.
+
+ The host may be an IP address or a hostname. Hostnames are
+ resolved via the configured DNS server.
+
+ Each request has a 3-second timeout. Requests are sent at
+ 1-second intervals.
+
+OUTPUT
+ PING example.com (93.184.216.34)
+ Reply from 93.184.216.34: time=12ms
+ Reply from 93.184.216.34: time=11ms
+ Reply from 93.184.216.34: time=13ms
+ Reply from 93.184.216.34: time=11ms
+
+ If a reply is not received within the timeout:
+
+ Request timed out
+
+EXAMPLES
+ ping 10.0.68.1
+ Ping the gateway by IP address.
+
+ ping google.com
+ Ping by hostname (requires DNS).
+
+SEE ALSO
+ nslookup(1), ifconfig(1), shell(1), syscalls(2)
NAME
+printctl - configure printers and submit print jobs
+SYNOPSIS
+printctl
+command
+[options]
+DESCRIPTION
+printctl
+manages the MontaukOS userspace print spooler and submits print jobs to IPP printers.
+COMMANDS
+
+set-printer URI
+ Store the default printer URI.
+
+show-printer
+ Print the configured default printer URI.
+
+print FILE [--printer URI] [--name JOB] [--wait]
+ Queue a file for printing.
+
+test-page [--printer URI] [--wait] [--no-wait]
+ Generate and queue a simple test page.
+
+status [--verbose]
+ Show daemon state and queued, active, completed, and failed jobs.
+
+inspect JOB-ID
+ Show full metadata and debug details for a queued, active, completed, or failed job.
+
+probe [URI]
+ Probe the configured printer, print host and resolution details, and show IPP capability diagnostics.
NAME
+printd - MontaukOS userspace print spooler daemon
+SYNOPSIS
+printd
+DESCRIPTION
+printd
+monitors the print spool directories, claims queued jobs, and delivers them to IPP printers.
+
+It is normally launched automatically by
+init(1)
+and does not require direct user interaction.
NAME
+ shell - MontaukOS interactive command shell
+
+DESCRIPTION
+ The MontaukOS shell is a command interpreter launched by init
+ after system services have started. It provides command
+ execution, file navigation, shell variables, command chaining,
+ tab completion, and command history.
+
+ Commands are either shell builtins or external programs. When
+ a command is not a builtin, the shell searches for a matching
+ ELF binary and executes it as a child process.
+
+COMMAND RESOLUTION
+ When a non-builtin command is entered, the shell searches for
+ a matching binary in the following order:
+
+ 1. <cwd>/<command> (exact name, e.g. "hello.elf")
+ 2. <cwd>/<command>.elf
+ 3. 0:/os/<command>.elf
+ 4. 0:/os/<command> (no extension)
+ 5. If on a non-zero drive, the drive root: <drive>:/<command>[.elf]
+
+ A command containing a "/" (or an explicit drive prefix, or a
+ leading "." or "/") is instead treated as a direct path and
+ resolved by the kernel against the process CWD, trying the
+ path as-is and then with ".elf" appended.
+
+ The first match is spawned and the shell waits for it to exit.
+ If no match is found, the shell prints:
+
+ <command>: command not found
+
+ Arguments after the command name are passed to the spawned
+ process.
+
+BUILTINS
+
+ help
+ Display a categorized list of available commands.
+
+ ls [dir]
+ List files in the current directory, or in the specified
+ directory. Directory entries are shown with a trailing slash.
+ Examples: ls, ls man, ls os
+
+ cd [dir]
+ Change the working directory. With no argument, returns to the
+ logged-in user's home directory (0:/users/<user>); with /,
+ returns to the drive root. Use cd .. to go up one level.
+ The shell prompt reflects the current directory.
+ Examples: cd os, cd .., cd
+
+ pwd
+ Print the current working directory as an absolute path
+ (e.g. "0:/os").
+
+ echo [-n] ...
+ Print the arguments. -n suppresses the trailing newline.
+
+ set [VAR=value]
+ With no argument, list all shell variables (built-in and
+ user-defined). With VAR=value, set a variable. With a bare
+ name, print that variable's value.
+
+ unset VAR
+ Remove a user-defined shell variable.
+
+ true / false
+ Return exit status 0 / 1 without doing anything. Useful with
+ && and ||.
+
+ N:
+ A bare "<number>:" (e.g. "1:") switches the current drive to
+ drive N and resets the working directory to that drive's root.
+
+ exit
+ Terminate the shell process (with the last command's exit code).
+
+SYNTAX
+ Variables
+ NAME=value Set a shell variable (no leading $)
+ $VAR or ${VAR} Expand a variable's value
+ $? Exit status of the last command
+ $USER, $HOME, $PWD Built-in dynamic variables (session user,
+ home directory, current directory)
+ \$ Escape a literal '$'
+
+ Tilde expansion
+ A leading ~ expands to the session home directory
+ (0:/users/<user>) when followed by end-of-string, '/', or a
+ space.
+
+ Command chaining
+ cmd1 ; cmd2 Run cmd2 unconditionally after cmd1
+ cmd1 && cmd2 Run cmd2 only if cmd1 succeeded (exit 0)
+ cmd1 || cmd2 Run cmd2 only if cmd1 failed (nonzero exit)
+
+ Single and double quotes protect ;, &&, and || from being
+ treated as separators.
+
+ Comments
+ A '#' outside of quotes starts a comment; the rest of the line
+ is ignored.
+
+EXTERNAL COMMANDS
+ All external commands live in 0:/os/ (see COMMAND RESOLUTION).
+ Where a dedicated man page exists it is noted below; run
+ 'man <command>' for details.
+
+ File commands
+ cat <file> Display file contents
+ edit [file] Text editor -- see edit(1)
+ copy <src> <dst> Copy a file
+ move <src> <dst> Move/rename a file
+ rm <file> Remove a file
+ touch <file> Create an empty file
+
+ System commands
+ man <topic> View manual pages -- see man(1)
+ whoami Print the current username
+ info / mtkfetch Show system information
+ date Show current date and time
+ uptime Show system uptime
+ proclist List running processes
+ power CPU power/thermal status (power [watch [secs]])
+ clear Clear the screen and framebuffer
+ fontscale [n] Get or set terminal font scale -- see fontscale(1)
+ lua Lua interpreter
+ tcc TinyCC (in-system C compiler)
+ reset Reboot the system
+ shutdown Shut down the system
+
+ Network commands
+ ping <host> Send ICMP echo requests -- see ping(1)
+ nslookup <host> DNS lookup -- see nslookup(1)
+ ifconfig Show/set network configuration
+ tcpconnect <host> <port> Interactive TCP client
+ irc IRC client
+ dhcp DHCP client -- see dhcp(1)
+ fetch <url> HTTP/HTTPS client (TLS 1.2) -- see fetch(1)
+ wiki <title> Wikipedia article viewer -- see wiki(1)
+ httpd HTTP server
+
+ Network commands accept both IP addresses and hostnames.
+ Hostnames are resolved via the configured DNS server.
+
+ Bluetooth
+ btlist List connected Bluetooth devices
+ btbonds List bonded (paired) Bluetooth devices
+
+ Software-defined radio
+ sdr [freqMHz [rateHz]] Receive and report basic signal
+ statistics from an attached RTL-SDR dongle
+
+ GUI applications (window server programs, not run from the
+ shell prompt as text commands) live under 0:/apps/, one bundle
+ per app -- e.g. doom, terminal, texteditor, spreadsheet,
+ wordprocessor, paint, calculator, network, bluetooth, audio,
+ disks, devexplorer, procmgr, powermgr, printers, timezone,
+ weather, wikipedia. There is no 0:/games/ directory.
+
+TAB COMPLETION
+ Pressing Tab completes the word under the cursor against, in
+ order: executable names in 0:/os/, shell builtins, and file/
+ directory entries in the current directory. A single match is
+ completed inline; multiple matches are listed below the prompt.
+
+INPUT
+ The shell uses non-blocking keyboard input via SYS_GETKEY (with
+ SYS_INPUT_WAIT to sleep between events) to support arrow key
+ detection. Lines are limited to 255 characters.
+
+ Editing
+ Backspace Delete character before cursor
+ Tab Tab-complete the current word
+ Enter Execute the command line
+
+ History
+ The shell stores the last 32 unique commands. Duplicate
+ consecutive entries are suppressed.
+
+ Up Arrow Recall previous command
+ Down Arrow Recall next command (or clear line)
+
+PROMPT
+ The prompt displays the current drive and working directory:
+
+ 0:/> _ (at root of drive 0)
+ 0:/os> _ (in os/ directory)
+ 1:/> _ (at root of drive 1)
+
+SEE ALSO
+ man(1), intro(1), syscalls(2)
NAME
+ spawn, waitpid - create and wait for processes
+
+SYNOPSIS
+ int montauk::spawn(const char* path, const char* args = nullptr);
+ void montauk::waitpid(int pid);
+ int montauk::getargs(char* buf, uint64_t maxLen);
+
+DESCRIPTION
+
+ spawn
+ Loads the ELF64 binary at the given VFS path and creates a new
+ process. The path must include the drive prefix, for example:
+
+ int pid = montauk::spawn("0:/os/hello.elf");
+
+ An optional second argument passes a string to the child:
+
+ int pid = montauk::spawn("0:/os/man.elf", "intro");
+
+ The new process gets its own PML4 page table, a 32 KiB stack
+ (at 0x7FFFFF7000-0x7FFFFFF000), and begins executing at the
+ ELF entry point (_start).
+
+ Returns the new process's PID on success, or -1 on failure.
+ Failure occurs when there are no free process slots (max 256),
+ the file cannot be found, or the ELF is invalid.
+
+ waitpid
+ Blocks the calling process until the process with the given PID
+ has exited. Internally, this yields the CPU in a loop:
+
+ montauk::waitpid(pid);
+
+ This is how the shell implements foreground process execution --
+ it spawns a child and waits for it to complete before showing
+ the next prompt.
+
+EXAMPLES
+ Spawn a program and wait for it:
+
+ int pid = montauk::spawn("0:/os/hello.elf");
+ if (pid < 0) {
+ montauk::print("spawn failed\n");
+ } else {
+ montauk::waitpid(pid);
+ montauk::print("child exited\n");
+ }
+
+ getargs
+ Copies the argument string into buf (up to maxLen bytes, always
+ null-terminated). Returns the number of characters copied, or
+ -1 on error.
+
+ char args[256];
+ montauk::getargs(args, sizeof(args));
+
+ The argument string is set by the parent when calling spawn().
+ If no arguments were provided, the buffer will be empty.
+
+NOTES
+ The _start() entry point receives no argc/argv. Use getargs()
+ to retrieve the argument string passed by the parent process.
+
+ Process exit codes are not yet collected by waitpid.
+
+SEE ALSO
+ syscalls(2), file(2)
NAME
+ syscalls - overview of MontaukOS system calls
+
+DESCRIPTION
+ MontaukOS provides 150 system calls (numbers 0-149, sparsely
+ assigned -- not every number in the range is in use) for
+ userspace programs. Syscalls use the x86-64 SYSCALL instruction
+ with the following register convention:
+
+ RAX Syscall number (in) / return value (out)
+ RDI Argument 1
+ RSI Argument 2
+ RDX Argument 3
+ R10 Argument 4
+ R8 Argument 5
+ R9 Argument 6
+
+ Include <Api/Syscall.hpp> for the numeric SYS_* constants and
+ ABI structs, and <montauk/syscall.h> for typed wrappers in the
+ montauk:: namespace. This page groups syscalls the same way the
+ kernel source does (one subsystem header per group).
+
+PROCESS MANAGEMENT
+SYS_EXIT (0)
+ Terminate the calling process.
+ [[noreturn]] void montauk::exit(int code = 0);
+
+SYS_YIELD (1)
+ Yield the remainder of the time slice.
+ void montauk::yield();
+
+SYS_SLEEP_MS (2)
+ Sleep for at least the given number of milliseconds.
+ void montauk::sleep_ms(uint64_t ms);
+
+SYS_GETPID (3)
+ Return the PID of the calling process.
+ int montauk::getpid();
+
+SYS_SPAWN (20)
+ Spawn a new process from an ELF binary on the VFS.
+ int montauk::spawn(const char* path, const char* args = nullptr);
+
+SYS_WAITPID (23)
+ Block until the given process has exited.
+ void montauk::waitpid(int pid);
+
+SYS_GETARGS (25)
+ Get the argument string passed to this process at spawn time.
+ int montauk::getargs(char* buf, uint64_t maxLen);
+
+SYS_PROCLIST (61)
+ List running processes (pid, parent, state, name, heap usage,
+ accumulated CPU time).
+ int montauk::proclist(montauk::abi::ProcInfo* buf, int max);
+
+SYS_KILL (62)
+ Terminate another process by PID.
+ int montauk::kill(int pid);
+
+SYS_CHDIR (96)
+ Change the calling process's current working directory.
+ int montauk::chdir(const char* path);
+
+SYS_GETCWD (95)
+ Get the calling process's current working directory.
+ int montauk::getcwd(char* buf, uint64_t maxLen);
+
+SYS_SETUSER (92)
+ Associate a process with a logged-in user name (used by login/session
+ management).
+ int montauk::setuser(int pid, const char* name);
+
+SYS_GETUSER (93)
+ Get the user name associated with the calling process.
+ int montauk::getuser(char* buf, uint64_t maxLen);
+
+THREADING
+ Threads share the spawning process's address space and heap
+ (see montauk/heap.h for the heap lock). Declared in
+ montauk/thread.h.
+
+SYS_THREAD_SPAWN (130)
+ Spawn a new thread in the calling process. Returns a positive
+ TID on success, -1 on failure.
+ int montauk::thread_spawn(ThreadEntry entry, void* arg,
+ uint64_t stack_bytes = 0);
+
+SYS_THREAD_EXIT (131)
+ Terminate only the calling thread. If it is the main thread,
+ the whole process exits.
+ [[noreturn]] void montauk::thread_exit(int code = 0);
+
+SYS_THREAD_JOIN (132)
+ Block until the given TID exits, then reclaim its kernel state.
+ int montauk::thread_join(int tid, int* out_code = nullptr);
+
+SYS_THREAD_SELF (133)
+ Return the calling thread's TID (equals getpid() for the main
+ thread).
+ int montauk::thread_self();
+
+CONSOLE I/O
+SYS_PRINT (4)
+ Write a null-terminated string to the terminal.
+ void montauk::print(const char* text);
+
+SYS_PUTCHAR (5)
+ Write a single character to the terminal.
+ void montauk::putchar(char c);
+
+FILE I/O
+SYS_OPEN (6)
+ Open a file. Returns a handle or negative on error.
+ int montauk::open(const char* path);
+
+SYS_READ (7)
+ Read bytes from a file at a given offset.
+ int montauk::read(int h, uint8_t* buf, uint64_t off, uint64_t sz);
+
+SYS_GETSIZE (8)
+ Get the size of an open file in bytes.
+ uint64_t montauk::getsize(int handle);
+
+SYS_CLOSE (9)
+ Close a file handle.
+ void montauk::close(int handle);
+
+SYS_READDIR (10)
+ List directory entries (max 256 per call for VFS directories,
+ 128 for driver-backed listings such as 0:/os/). For larger
+ directories use SYS_READDIR_AT.
+ int montauk::readdir(const char* path, const char** names, int max);
+
+SYS_READDIR_AT (136)
+ Paginated directory read. Returns entries starting at
+ startIndex; call repeatedly with startIndex advanced by the
+ returned count until it returns 0 to enumerate directories of
+ any size.
+ int montauk::readdir_at(const char* path, const char** names,
+ int max, int startIndex);
+
+SYS_FWRITE (41)
+ Write bytes to a file at a given offset.
+ int montauk::fwrite(int handle, const uint8_t* buf,
+ uint64_t offset, uint64_t size);
+
+SYS_FCREATE (42)
+ Create a new file on the target volume. Returns a handle or
+ negative on error.
+ int montauk::fcreate(const char* path);
+
+SYS_FDELETE (77)
+ Delete a file.
+ int montauk::fdelete(const char* path);
+
+SYS_FMKDIR (78)
+ Create a directory.
+ int montauk::fmkdir(const char* path);
+
+SYS_FRENAME (94)
+ Rename or move a file/directory (used as the basis for file
+ manager move operations).
+ int montauk::frename(const char* oldPath, const char* newPath);
+
+SYS_DRIVELIST (79)
+ List mounted drive numbers.
+ int montauk::drivelist(int* outDrives, int max);
+
+SYS_DRIVELABEL (124)
+ Get the volume label of a drive.
+ int montauk::drivelabel(int drive, char* outLabel, int maxLen);
+
+SYS_DRIVEKIND (127)
+ Get the block device kind backing a drive: 0=unknown/ramdisk,
+ 1=SATA, 2=SATAPI, 3=NVMe, 4=USB mass storage.
+ int montauk::drivekind(int drive);
+
+MEMORY
+SYS_ALLOC (11)
+ Map zeroed pages into the process address space.
+ void* montauk::alloc(uint64_t size);
+
+SYS_FREE (12)
+ Reserved (currently a no-op).
+ void montauk::free(void* ptr);
+
+SYS_MEMSTATS (67)
+ Get kernel-wide physical memory usage (total/free/used bytes,
+ page size).
+ void montauk::memstats(montauk::abi::MemStats* out);
+
+TIMEKEEPING
+SYS_GETTICKS (13)
+ Get APIC timer ticks since boot.
+ uint64_t montauk::get_ticks();
+
+SYS_GETMILLISECONDS (14)
+ Get milliseconds elapsed since boot.
+ uint64_t montauk::get_milliseconds();
+
+SYS_GETTIME (28)
+ Get the current wall-clock date and time (UTC).
+ Fills a montauk::abi::DateTime struct with Year, Month, Day,
+ Hour, Minute, and Second fields.
+ void montauk::gettime(montauk::abi::DateTime* out);
+
+SYS_SETTZ (90)
+ Set the process/system timezone offset, in minutes from UTC.
+ void montauk::settz(int offset_minutes);
+
+SYS_GETTZ (91)
+ Get the current timezone offset, in minutes from UTC.
+ int montauk::gettz();
+
+SYSTEM
+SYS_GETINFO (15)
+ Get OS name, version string, API version, max process count,
+ and the monotonic kernel build number.
+ void montauk::get_info(montauk::abi::SysInfo* info);
+
+KEYBOARD
+SYS_ISKEYAVAILABLE (16)
+ Check if a key event is pending (non-blocking).
+ bool montauk::is_key_available();
+
+SYS_GETKEY (17)
+ Get the next key event (press or release).
+ void montauk::getkey(montauk::abi::KeyEvent* out);
+
+SYS_GETCHAR (18)
+ Block until a printable character is typed.
+ char montauk::getchar();
+
+SYS_INPUT_WAIT (123)
+ Block until the input serial number differs from
+ observedSerial or the timeout elapses; used to sleep
+ efficiently between input-driven redraws.
+ uint64_t montauk::input_wait(uint64_t observedSerial, uint64_t timeoutMs);
+
+MOUSE
+SYS_MOUSESTATE (47)
+ Get the current mouse position, scroll delta, and button mask.
+ void montauk::mouse_state(montauk::abi::MouseState* out);
+
+SYS_SETMOUSEBOUNDS (48)
+ Set the maximum X/Y the mouse cursor may reach (e.g. framebuffer
+ dimensions).
+ void montauk::set_mouse_bounds(int32_t maxX, int32_t maxY);
+
+NETWORKING
+SYS_PING (19)
+ Send an ICMP echo request and wait for reply.
+ int32_t montauk::ping(uint32_t ip, uint32_t timeoutMs = 3000);
+
+SYS_RESOLVE (44)
+ Resolve a hostname to an IPv4 address via DNS. Sends a UDP
+ query to the configured DNS server and waits up to 5 seconds
+ for a reply. Returns the IP in network byte order, or 0 on
+ failure. IP address strings (e.g. "10.0.0.1") are detected
+ and returned directly without a DNS query.
+ uint32_t montauk::resolve(const char* hostname);
+
+SYS_GETNETCFG (37)
+ Get the current network configuration (IP, mask, gateway, MAC,
+ DNS server).
+ void montauk::get_netcfg(montauk::abi::NetCfg* out);
+
+SYS_SETNETCFG (38)
+ Set the network configuration (IP, mask, gateway, DNS server).
+ int montauk::set_netcfg(const montauk::abi::NetCfg* cfg);
+
+SYS_NETSTATUS (125)
+ Get adapter status including driver name, link state, polling mode,
+ and RX/TX packet counters.
+ int montauk::net_status(montauk::abi::NetStatus* out);
+
+SOCKETS
+SYS_SOCKET (29)
+ Create a socket. type=SOCK_TCP (1) or SOCK_UDP (2).
+ Returns fd or -1.
+ int montauk::socket(int type);
+
+SYS_CONNECT (30)
+ Connect a TCP socket to a remote host.
+ int montauk::connect(int fd, uint32_t ip, uint16_t port);
+
+SYS_BIND (31)
+ Bind a socket to a local port for listening.
+ int montauk::bind(int fd, uint16_t port);
+
+SYS_LISTEN (32)
+ Start listening for incoming TCP connections.
+ int montauk::listen(int fd);
+
+SYS_ACCEPT (33)
+ Accept an incoming connection on a listening socket.
+ Returns a new socket fd for the client connection.
+ int montauk::accept(int fd);
+
+SYS_SEND (34)
+ Send data on a connected socket. Returns bytes sent.
+ int montauk::send(int fd, const void* data, uint32_t len);
+
+SYS_RECV (35)
+ Receive data from a connected socket. Returns bytes
+ received, 0 if no data available, or -1 on close/error.
+ int montauk::recv(int fd, void* buf, uint32_t maxLen);
+
+SYS_CLOSESOCK (36)
+ Close a socket and release its resources.
+ int montauk::closesocket(int fd);
+
+SYS_SENDTO (39)
+ Send a UDP datagram to a specific destination.
+ int montauk::sendto(int fd, const void* data, uint32_t len,
+ uint32_t destIp, uint16_t destPort);
+
+SYS_RECVFROM (40)
+ Receive a UDP datagram. Returns the source address.
+ int montauk::recvfrom(int fd, void* buf, uint32_t maxLen,
+ uint32_t* srcIp, uint16_t* srcPort);
+
+FRAMEBUFFER
+SYS_FBINFO (21)
+ Get framebuffer dimensions and format.
+ void montauk::fb_info(montauk::abi::FbInfo* info);
+
+SYS_FBMAP (22)
+ Map the framebuffer into process memory.
+ void* montauk::fb_map();
+
+TERMINAL
+SYS_TERMSIZE (24)
+ Get terminal dimensions (columns and rows).
+ void montauk::termsize(int* cols, int* rows);
+
+SYS_TERMSCALE (43)
+ Get or set the terminal font scale factor. When scale_x is 0,
+ returns the current scale as (scale_y << 32 | scale_x). When
+ scale_x is non-zero, sets the font scale and returns the new
+ terminal dimensions as (rows << 32 | cols).
+ void montauk::termscale(int scale_x, int scale_y);
+ void montauk::get_termscale(int* scale_x, int* scale_y);
+
+RANDOM
+SYS_GETRANDOM (45)
+ Fill a buffer with random bytes using RDTSC-seeded entropy.
+ Returns the number of bytes written.
+ int64_t montauk::getrandom(void* buf, uint32_t len);
+
+POWER MANAGEMENT
+SYS_RESET (26)
+ Reboot the system.
+ [[noreturn]] void montauk::reset();
+
+SYS_SHUTDOWN (27)
+ Shut down the system.
+ [[noreturn]] void montauk::shutdown();
+
+SYS_SUSPEND (89)
+ Enter ACPI S3 sleep. Returns after wake, 0 on success.
+ int montauk::suspend();
+
+SYS_POWER_REQUEST (135)
+ Cross-process graceful power-off request channel. The desktop
+ posts a pending action (POWER_REQ_SHUTDOWN / POWER_REQ_REBOOT)
+ then exits; login.elf reads it with POWER_REQ_QUERY
+ (read-and-clear), runs the shutdown stages, and finally calls
+ shutdown()/reset(). See montauk::abi::PowerRequestAction.
+ int montauk::power_request(int action);
+
+SYS_POWERINFO (149)
+ Get the CPU power/thermal snapshot (HWP state, throttling,
+ package temperature, base/max/effective frequency). Returns 0
+ on success, -1 if unsupported by the running hardware.
+ int montauk::syscall1(SYS_POWERINFO, (uint64_t)&out);
+ // out: montauk::abi::PowerInfo*
+
+KERNEL LOG
+SYS_KLOG (46)
+ Read from the kernel ring log buffer.
+ int64_t montauk::read_klog(char* buf, uint64_t size);
+
+I/O REDIRECTION
+ Used by the terminal app and similar programs to run a child
+ process with its console I/O captured instead of going directly
+ to the framebuffer console.
+
+SYS_SPAWN_REDIR (49)
+ Spawn a process with its console I/O redirected to the caller.
+ int montauk::spawn_redir(const char* path, const char* args = nullptr);
+
+SYS_CHILDIO_READ (50)
+ Read buffered output produced by a redirected child.
+ int montauk::childio_read(int childPid, char* buf, int maxLen);
+
+SYS_CHILDIO_WRITE (51)
+ Write text input to a redirected child's stdin.
+ int montauk::childio_write(int childPid, const char* data, int len);
+
+SYS_CHILDIO_WRITEKEY (52)
+ Forward a raw key event to a redirected child.
+ int montauk::childio_writekey(int childPid, const montauk::abi::KeyEvent* key);
+
+SYS_CHILDIO_SETTERMSZ (53)
+ Tell a redirected child its terminal dimensions changed.
+ int montauk::childio_settermsz(int childPid, int cols, int rows);
+
+WINDOW SERVER
+ Window server syscalls are used by GUI programs to create and
+ drive an on-screen window (see montauk/Window.hpp for the
+ higher-level win_create/win_poll/win_present wrappers built on
+ top of these).
+
+SYS_WINCREATE (54)
+ Create a window and get its pixel buffer.
+ int montauk::win_create(const char* title, int w, int h,
+ montauk::abi::WinCreateResult* result);
+
+SYS_WINDESTROY (55)
+ Destroy a window.
+ int montauk::win_destroy(int id);
+
+SYS_WINPRESENT (56)
+ Flush the pixel buffer to the screen.
+ uint64_t montauk::win_present(int id);
+
+SYS_WINPOLL (57)
+ Poll the next event (key, mouse, resize, close, scale) for a
+ window.
+ int montauk::win_poll(int id, montauk::abi::WinEvent* event);
+
+SYS_WINENUM (58)
+ Enumerate all windows currently managed by the window server.
+ int montauk::win_enumerate(montauk::abi::WinInfo* info, int max);
+
+SYS_WINMAP (59)
+ Map (or re-map) a window's pixel buffer into the caller's
+ address space.
+ uint64_t montauk::win_map(int id);
+
+SYS_WINUNMAP (97)
+ Unmap a window's pixel buffer from the caller's address space.
+ int montauk::win_unmap(int id);
+
+SYS_WINSENDEVENT (60)
+ Inject an event into a window's event queue.
+ int montauk::win_sendevent(int id, const montauk::abi::WinEvent* event);
+
+SYS_WINRESIZE (64)
+ Resize a window and its pixel buffer.
+ uint64_t montauk::win_resize(int id, int w, int h);
+
+SYS_WINSETSCALE (65)
+ Set the desktop-wide UI scale factor.
+ int montauk::win_setscale(int scale);
+
+SYS_WINGETSCALE (66)
+ Get the desktop-wide UI scale factor.
+ int montauk::win_getscale();
+
+SYS_WINSETCURSOR (68)
+ Set the mouse cursor shown while over a window (0=arrow,
+ 1=resize_h, 2=resize_v).
+ int montauk::win_setcursor(int id, int cursor);
+
+SYS_WINSETFLAGS (126)
+ Set window flags (e.g. WIN_FLAG_FULLSCREEN).
+ int montauk::win_setflags(int id, uint32_t flags);
+
+DEVICES
+SYS_DEVLIST (63)
+ Enumerate detected devices (CPU, interrupts, timers, input,
+ USB, network, display, storage, PCI, audio, ACPI) for the
+ device explorer app.
+ int montauk::devlist(montauk::abi::DevInfo* buf, int max);
+
+SYS_DISKINFO (69)
+ Get detailed info for one block device (model, serial, sector
+ size, NCQ/TRIM/SMART support, etc.).
+ int montauk::diskinfo(montauk::abi::DiskInfo* buf, int port);
+
+STORAGE
+SYS_PARTLIST (70)
+ Enumerate GPT partitions across all block devices.
+ int montauk::partlist(montauk::abi::PartInfo* buf, int max);
+
+SYS_DISKREAD (71)
+ Raw, driver-agnostic sector read from a block device.
+ int64_t montauk::disk_read(int blockDev, uint64_t lba,
+ uint32_t sectorCount, void* buf);
+
+SYS_DISKWRITE (72)
+ Raw, driver-agnostic sector write to a block device.
+ int64_t montauk::disk_write(int blockDev, uint64_t lba,
+ uint32_t sectorCount, const void* buf);
+
+SYS_GPTINIT (73)
+ Initialize a fresh GPT partition table on a block device.
+ int montauk::gpt_init(int blockDev);
+
+SYS_GPTADD (74)
+ Add a partition to an existing GPT table.
+ int montauk::gpt_add(const montauk::abi::GptAddParams* params);
+
+SYS_FSMOUNT (75)
+ Mount a partition's filesystem onto a drive number.
+ int montauk::fs_mount(int partIndex, int driveNum);
+
+SYS_FSFORMAT (76)
+ Format a partition with a filesystem (FS_TYPE_FAT32 or
+ FS_TYPE_EXT2).
+ int montauk::fs_format(const montauk::abi::FsFormatParams* params);
+
+SYS_FS_SYNC (134)
+ Flush all block-device write caches and cleanly unmount
+ disk-backed volumes ahead of power-off. Returns the number of
+ volumes unmounted. Part of the graceful shutdown sequence
+ (see SYS_POWER_REQUEST).
+ int montauk::fs_sync();
+
+AUDIO
+SYS_AUDIOOPEN (80)
+ Open a mixer output stream at the given sample rate, channel
+ count, and bit depth. Returns a stream handle.
+ int montauk::audio_open(uint32_t sampleRate, uint8_t channels,
+ uint8_t bitsPerSample);
+
+SYS_AUDIOCLOSE (81)
+ Close an audio stream.
+ void montauk::audio_close(int handle);
+
+SYS_AUDIOWRITE (82)
+ Write PCM samples to an audio stream.
+ int montauk::audio_write(int handle, const void* data, uint32_t size);
+
+SYS_AUDIOCTL (83)
+ Control an audio stream or the global mixer. Commands 0-3 act
+ on the stream named by the handle argument; commands 4-12 act
+ on that stream's routing/mute state or the global master and
+ ignore or reuse the handle as documented below.
+ int montauk::audio_ctl(int handle, int cmd, int value);
+
+ Convenience wrappers (all thin calls onto audio_ctl):
+ audio_set_volume, audio_get_volume AUDIO_CTL_{SET,GET}_VOLUME (0/1)
+ audio_get_pos AUDIO_CTL_GET_POS (2)
+ audio_pause, audio_resume AUDIO_CTL_PAUSE (3)
+ audio_get_output AUDIO_CTL_GET_OUTPUT (4): 0=HDA, 1=Bluetooth
+ (SET_OUTPUT, 5) switch a stream's output route
+ audio_bt_status AUDIO_CTL_BT_STATUS (6)
+ audio_set_master_volume, _get_ AUDIO_CTL_{SET,GET}_MASTER_VOLUME (7/8), 0-100
+ audio_set_mute, audio_get_mute AUDIO_CTL_{SET,GET}_MUTE (9/10), per-stream
+ audio_set_master_mute, _get_ AUDIO_CTL_{SET,GET}_MASTER_MUTE (11/12)
+
+SYS_AUDIOLIST (128)
+ Enumerate active mixer streams (owner PID, name, format,
+ volume, mute/pause state).
+ int montauk::audio_list(montauk::abi::AudioStreamInfo* buf, int maxCount);
+
+SYS_AUDIOWAIT (129)
+ Return the current mixer state serial. With timeoutMs > 0,
+ blocks until the serial differs from prevSerial or the timeout
+ elapses; with timeoutMs == 0 it returns immediately.
+ uint64_t montauk::audio_wait(uint64_t prevSerial, uint64_t timeoutMs);
+
+BLUETOOTH
+SYS_BTSCAN (84)
+ Scan for discoverable Bluetooth devices for up to timeoutMs.
+ int montauk::bt_scan(montauk::abi::BtScanResult* buf, int maxCount,
+ uint32_t timeoutMs);
+
+SYS_BTCONNECT (85)
+ Connect (and pair/bond if needed) to a device by BD_ADDR.
+ int montauk::bt_connect(const uint8_t* bdAddr);
+
+SYS_BTDISCONNECT (86)
+ Disconnect from a device by BD_ADDR.
+ int montauk::bt_disconnect(const uint8_t* bdAddr);
+
+SYS_BTLIST (87)
+ List currently connected devices.
+ int montauk::bt_list(montauk::abi::BtDevInfo* buf, int maxCount);
+
+SYS_BTINFO (88)
+ Get local adapter info (BD_ADDR, name, init/scanning state).
+ int montauk::bt_info(montauk::abi::BtAdapterInfo* buf);
+
+SYS_BTSETADDR (137)
+ Change the adapter's BD_ADDR (6-byte buffer, byte 0 is the
+ least-significant octet). Volatile -- apply after the last
+ controller reset and persist separately to bluetooth.toml.
+ int montauk::bt_set_addr(const uint8_t* bdAddr);
+
+SYS_BTBONDS (138)
+ List bonded (paired) devices.
+ int montauk::bt_bonds(montauk::abi::BtBondInfo* buf, int maxCount);
+
+SYS_BTFORGET (139)
+ Forget a paired device; it must re-pair next time.
+ int montauk::bt_forget(const uint8_t* bdAddr);
+
+SOFTWARE-DEFINED RADIO
+ Receive-only SDR API. Receivers are enumerated by index in
+ [0, SYS_SDR_COUNT); SYS_SDR_OPEN returns a handle used by the
+ rest of the calls. Samples are delivered as interleaved 8-bit
+ unsigned I/Q (CU8, SDR_FORMAT_CU8) from the device's ring
+ buffer. Backed by an RTL-SDR (RTL2832U + R820T2) driver.
+
+SYS_SDR_COUNT (140)
+ Number of available SDR receivers.
+ int montauk::sdr_count();
+
+SYS_SDR_INFO (141)
+ Get static/dynamic info for one receiver by index (name, tuner,
+ frequency/sample-rate ranges, gain steps, present/streaming
+ flags).
+ int montauk::sdr_info(int index, montauk::abi::SdrDeviceInfo* out);
+
+SYS_SDR_OPEN (142)
+ Open a receiver by index. Returns a handle.
+ int montauk::sdr_open(int index);
+
+SYS_SDR_CLOSE (143)
+ Close a receiver handle.
+ int montauk::sdr_close(int handle);
+
+SYS_SDR_START (144)
+ Begin streaming samples.
+ int montauk::sdr_start(int handle);
+
+SYS_SDR_STOP (145)
+ Stop streaming samples.
+ int montauk::sdr_stop(int handle);
+
+SYS_SDR_READ (146)
+ Non-blocking read of queued I/Q samples. Returns bytes copied.
+ int montauk::sdr_read(int handle, void* buf, uint32_t len);
+
+SYS_SDR_SETPARAM (147)
+ Set a tunable parameter (see SDR_PARAM_* below).
+ int montauk::sdr_set_param(int handle, int param, uint64_t value);
+
+SYS_SDR_GETPARAM (148)
+ Get a tunable parameter's current value.
+ int64_t montauk::sdr_get_param(int handle, int param);
+
+ Parameters (montauk::abi::SDR_PARAM_*): FREQ (center frequency,
+ Hz), SAMPLE_RATE (Hz), GAIN_MODE (0=auto/AGC, 1=manual), GAIN
+ (tenths of dB), FREQ_CORR (ppm), AGC (demod digital AGC, 0/1),
+ DIRECT_SAMP (0=off, 1=I, 2=Q). Convenience wrappers exist for
+ each: sdr_set_freq/sdr_get_freq, sdr_set_sample_rate/
+ sdr_get_sample_rate, sdr_set_gain_mode, sdr_set_gain,
+ sdr_set_freq_correction, sdr_set_agc.
+
+CLIPBOARD
+SYS_CLIPBOARD_SET_TEXT (119)
+ Set the system clipboard's text contents (max
+ CLIPBOARD_MAX_TEXT_BYTES, 256 KiB).
+ int montauk::clipboard_set_text(const char* data, uint32_t len);
+
+SYS_CLIPBOARD_GET_INFO (120)
+ Get the clipboard's current size and serial number (for
+ change detection).
+ int montauk::clipboard_get_info(montauk::abi::ClipboardInfo* out);
+
+SYS_CLIPBOARD_GET_TEXT (121)
+ Read the clipboard's text contents.
+ int montauk::clipboard_get_text(char* buf, uint32_t bufLen,
+ uint32_t* outLen, uint64_t* outSerial = nullptr);
+
+SYS_CLIPBOARD_CLEAR (122)
+ Clear the clipboard.
+ int montauk::clipboard_clear();
+
+GENERIC IPC
+ Handle-based IPC primitives underlying streams, mailboxes,
+ waitsets, and shared-memory surfaces (see kernel/src/Ipc/Ipc.hpp).
+ All are accessed via numeric handles with rights-based security
+ and can be waited on with SYS_WAIT_HANDLE or a waitset.
+
+SYS_DUPHANDLE (98)
+ Duplicate a handle (e.g. to hand a copy to a child process).
+ int montauk::dup_handle(int handle);
+
+SYS_WAIT_HANDLE (99)
+ Block until a handle's signals intersect wantedSignals, or
+ timeoutMs elapses. See IPC_SIGNAL_* (READABLE, WRITABLE,
+ PEER_CLOSED, EXITED, READY).
+ uint32_t montauk::wait_handle(int handle, uint32_t wantedSignals,
+ uint64_t timeoutMs = ~0ULL);
+
+SYS_STREAM_CREATE (100)
+ Create a byte-pipe stream, returning a read handle and a write
+ handle.
+ int montauk::stream_create(int* outReadHandle, int* outWriteHandle,
+ uint32_t capacity = 0);
+
+SYS_STREAM_READ (101)
+ Read bytes from a stream handle.
+ int montauk::stream_read(int handle, void* buf, int maxLen);
+
+SYS_STREAM_WRITE (102)
+ Write bytes to a stream handle.
+ int montauk::stream_write(int handle, const void* data, int len);
+
+SYS_MAILBOX_CREATE (103)
+ Create a message-queue mailbox, returning a send handle and a
+ receive handle.
+ int montauk::mailbox_create(int* outSendHandle, int* outRecvHandle);
+
+SYS_MAILBOX_SEND (104)
+ Send a typed message, optionally attaching a handle to
+ transfer to the receiver.
+ int montauk::mailbox_send(int handle, uint32_t msgType, const void* data,
+ uint16_t len, int attachHandle = -1);
+
+SYS_MAILBOX_RECV (105)
+ Receive a message.
+ int montauk::mailbox_recv(int handle, uint32_t* outMsgType, void* data,
+ uint16_t* inOutLen, int* outAttachHandle = nullptr);
+
+SYS_WAITSET_CREATE (106)
+ Create a waitset for multiplexing waits across many handles.
+ int montauk::waitset_create();
+
+SYS_WAITSET_ADD (107)
+ Add a handle and its signal mask to a waitset.
+ int montauk::waitset_add(int waitsetHandle, int targetHandle,
+ uint32_t signals);
+
+SYS_WAITSET_REMOVE (108)
+ Remove an entry from a waitset by index.
+ int montauk::waitset_remove(int waitsetHandle, int index);
+
+SYS_WAITSET_WAIT (109)
+ Block until any member handle's watched signals fire, or
+ timeoutMs elapses.
+ int montauk::waitset_wait(int waitsetHandle, montauk::abi::IpcWaitResult* outReady,
+ uint64_t timeoutMs = ~0ULL);
+
+SYS_PROC_OPEN (110)
+ Open a handle to another process by PID (for waiting on its
+ exit via IPC_SIGNAL_EXITED, etc.).
+ int montauk::proc_open(int pid);
+
+SYS_SURFACE_CREATE (111)
+ Create a shared pixel-buffer surface of byteSize bytes.
+ int montauk::surface_create(uint64_t byteSize);
+
+SYS_SURFACE_MAP (112)
+ Map a surface into the caller's address space.
+ void* montauk::surface_map(int handle);
+
+SYS_SURFACE_RESIZE (113)
+ Resize a surface.
+ int montauk::surface_resize(int handle, uint64_t newSize);
+
+SHARED LIBRARIES
+SYS_LOAD_LIB (114)
+ Load a shared library ELF (.lib) into the caller's address
+ space.
+ int montauk::load_lib(const char* path);
+
+SYS_UNLOAD_LIB (115)
+ Unload a previously loaded library.
+ int montauk::unload_lib(int handle);
+
+SYS_DLSYM (116)
+ Resolve a symbol offset within a loaded library to a callable
+ address.
+ void* montauk::dlsym(int handle, uint64_t symbolOffset);
+
+SYS_GETLIBBASE (117)
+ Get the base virtual address a loaded library was mapped at.
+ uint64_t montauk::get_libbase(int handle);
+
+CRASH REPORTING
+SYS_CRASH_REPORT (118)
+ Retrieve the kernel-filled crash report for the last faulting
+ process (exception vector/name, faulting address, register
+ state, page-fault error bits). Used by the crashpad app.
+ int montauk::crash_report(montauk::abi::CrashReportInfo* out);
+
+SEE ALSO
+ spawn(2), file(2), framebuffer(2), malloc(3), intro(1)
NAME
+ tls-errors - BearSSL TLS and X.509 error codes
+
+DESCRIPTION
+ MontaukOS uses BearSSL for TLS 1.2 connections. When a TLS
+ operation fails, an integer error code is reported. This page
+ lists all possible error codes.
+
+SSL/TLS ENGINE ERRORS
+
+0 BR_ERR_OK
+ No error.
+
+1 BR_ERR_BAD_PARAM
+ Caller-provided parameter is incorrect.
+
+2 BR_ERR_BAD_STATE
+ Operation cannot be applied in the current engine state.
+
+3 BR_ERR_UNSUPPORTED_VERSION
+ Incoming protocol or record version is unsupported.
+
+4 BR_ERR_BAD_VERSION
+ Incoming record version does not match the expected version.
+
+5 BR_ERR_BAD_LENGTH
+ Incoming record length is invalid.
+
+6 BR_ERR_TOO_LARGE
+ Incoming record is too large, or buffer is too small for the
+ handshake message to send.
+
+7 BR_ERR_BAD_MAC
+ Decryption found invalid padding, or the record MAC is
+ not correct.
+
+8 BR_ERR_NO_RANDOM
+ No initial entropy was provided and none could be obtained
+ from the OS.
+
+9 BR_ERR_UNKNOWN_TYPE
+ Incoming record type is unknown.
+
+10 BR_ERR_UNEXPECTED
+ Incoming record or message has wrong type for the current
+ engine state.
+
+12 BR_ERR_BAD_CCS
+ ChangeCipherSpec message from the peer has invalid contents.
+
+13 BR_ERR_BAD_ALERT
+ Alert message from the peer has invalid contents (odd length).
+
+14 BR_ERR_BAD_HANDSHAKE
+ Incoming handshake message decoding failed.
+
+15 BR_ERR_OVERSIZED_ID
+ ServerHello contains a session ID larger than 32 bytes.
+
+16 BR_ERR_BAD_CIPHER_SUITE
+ Server wants to use a cipher suite that we did not advertise,
+ or we tried to advertise a cipher suite that we do not support.
+
+17 BR_ERR_BAD_COMPRESSION
+ Server wants to use a compression method that we did not
+ advertise.
+
+18 BR_ERR_BAD_FRAGLEN
+ Server's max fragment length does not match client's.
+
+19 BR_ERR_BAD_SECRENEG
+ Secure renegotiation failed.
+
+20 BR_ERR_EXTRA_EXTENSION
+ Server sent an extension type that we did not announce, or
+ used the same extension type more than once in ServerHello.
+
+21 BR_ERR_BAD_SNI
+ Invalid Server Name Indication contents (when used by the
+ server, this extension shall be empty).
+
+22 BR_ERR_BAD_HELLO_DONE
+ Invalid ServerHelloDone from the server (length is not 0).
+
+23 BR_ERR_LIMIT_EXCEEDED
+ Internal limit exceeded (e.g. server's public key is too
+ large).
+
+24 BR_ERR_BAD_FINISHED
+ Finished message from peer does not match the expected value.
+
+25 BR_ERR_RESUME_MISMATCH
+ Session resumption attempted with a different version or
+ cipher suite.
+
+26 BR_ERR_INVALID_ALGORITHM
+ Unsupported or invalid algorithm (ECDHE curve, signature
+ algorithm, hash function).
+
+27 BR_ERR_BAD_SIGNATURE
+ Invalid signature on ServerKeyExchange or CertificateVerify.
+
+28 BR_ERR_WRONG_KEY_USAGE
+ Peer's public key does not have the proper type or is not
+ allowed for the requested operation.
+
+29 BR_ERR_NO_CLIENT_AUTH
+ Client did not send a certificate upon request, or the client
+ certificate could not be validated.
+
+31 BR_ERR_IO
+ I/O error or premature close on the underlying transport.
+
+X.509 CERTIFICATE ERRORS
+
+32 BR_ERR_X509_OK
+ X.509 validation was successful (not an error).
+
+33 BR_ERR_X509_INVALID_VALUE
+ Invalid value in an ASN.1 structure.
+
+34 BR_ERR_X509_TRUNCATED
+ Truncated certificate.
+
+35 BR_ERR_X509_EMPTY_CHAIN
+ Empty certificate chain (no certificate at all).
+
+36 BR_ERR_X509_INNER_TRUNC
+ Inner element extends beyond outer element size.
+
+37 BR_ERR_X509_BAD_TAG_CLASS
+ Unsupported tag class (application or private).
+
+38 BR_ERR_X509_BAD_TAG_VALUE
+ Unsupported tag value.
+
+39 BR_ERR_X509_INDEFINITE_LENGTH
+ Indefinite length encoding found.
+
+40 BR_ERR_X509_EXTRA_ELEMENT
+ Extraneous element in certificate.
+
+41 BR_ERR_X509_UNEXPECTED
+ Unexpected element in certificate.
+
+42 BR_ERR_X509_NOT_CONSTRUCTED
+ Expected constructed element, but found primitive.
+
+43 BR_ERR_X509_NOT_PRIMITIVE
+ Expected primitive element, but found constructed.
+
+44 BR_ERR_X509_PARTIAL_BYTE
+ BIT STRING length is not a multiple of 8.
+
+45 BR_ERR_X509_BAD_BOOLEAN
+ BOOLEAN value has invalid length.
+
+46 BR_ERR_X509_OVERFLOW
+ Value is off-limits (overflow).
+
+47 BR_ERR_X509_BAD_DN
+ Invalid distinguished name.
+
+48 BR_ERR_X509_BAD_TIME
+ Invalid date/time representation in certificate.
+
+49 BR_ERR_X509_UNSUPPORTED
+ Certificate contains unsupported features that cannot be
+ ignored.
+
+50 BR_ERR_X509_LIMIT_EXCEEDED
+ Key or signature size exceeds internal limits.
+
+51 BR_ERR_X509_WRONG_KEY_TYPE
+ Key type does not match that which was expected.
+
+52 BR_ERR_X509_BAD_SIGNATURE
+ Signature is invalid.
+
+53 BR_ERR_X509_TIME_UNKNOWN
+ Validation time is unknown (no time was set).
+
+54 BR_ERR_X509_EXPIRED
+ Certificate is expired or not yet valid.
+
+55 BR_ERR_X509_DN_MISMATCH
+ Issuer/subject DN mismatch in the chain.
+
+56 BR_ERR_X509_BAD_SERVER_NAME
+ Expected server name was not found in the chain.
+
+57 BR_ERR_X509_CRITICAL_EXTENSION
+ Unknown critical extension in certificate.
+
+58 BR_ERR_X509_NOT_CA
+ Not a CA, or path length constraint violation.
+
+59 BR_ERR_X509_FORBIDDEN_KEY_USAGE
+ Key Usage extension prohibits the intended usage.
+
+60 BR_ERR_X509_WEAK_PUBLIC_KEY
+ Public key found in certificate is too small.
+
+62 BR_ERR_X509_NOT_TRUSTED
+ Chain could not be linked to a trust anchor.
+
+FATAL ALERTS
+ When a fatal alert is received from the peer, the error code
+ is 256 + the TLS alert value. When a fatal alert is sent to
+ the peer, the error code is 512 + the TLS alert value.
+
+ Common alert values:
+ 0 close_notify
+ 10 unexpected_message
+ 20 bad_record_mac
+ 40 handshake_failure
+ 42 bad_certificate
+ 43 unsupported_certificate
+ 44 certificate_revoked
+ 45 certificate_expired
+ 46 certificate_unknown
+ 47 illegal_parameter
+ 48 unknown_ca
+ 50 decode_error
+ 51 decrypt_error
+ 70 protocol_version
+ 71 insufficient_security
+ 80 internal_error
+ 86 unrecognized_name
+ 112 no_application_protocol
+
+ For example, error 296 means a handshake_failure alert was
+ received (256 + 40 = 296).
+
+SEE ALSO
+ fetch(1), syscalls(2)
NAME
+ wiki - Wikipedia article viewer for MontaukOS
+
+SYNOPSIS
+ wiki <title>
+ wiki -f <title>
+ wiki -s <query>
+
+DESCRIPTION
+ wiki fetches and displays Wikipedia articles in the terminal.
+ It connects to en.wikipedia.org over HTTPS (TLS 1.2) and
+ uses the Wikipedia REST and Action APIs to retrieve article
+ content as plain text.
+
+ Articles are displayed in a fullscreen interactive pager with
+ color-coded headings and word-wrapped text. Multi-word titles
+ are accepted as separate arguments and joined automatically.
+
+OPTIONS
+-f
+ Full article mode. Display the complete article text instead
+ of just the summary. Section headings are color-coded.
+
+-s
+ Search mode. Search Wikipedia for articles matching the
+ query and display a numbered list of up to 10 results.
+ Press a number key to view that article's summary.
+
+EXAMPLES
+ wiki Linux
+ Show a summary of the Linux article.
+
+ wiki -f C programming language
+ Show the full text of the C programming language article.
+
+ wiki -s operating system
+ Search for articles related to "operating system".
+
+TLS SUPPORT
+ Connections use BearSSL for TLS 1.2. Server certificates
+ are validated against the system CA bundle at
+ 0:/os/certs/ca-certificates.crt.
+
+KEYBOARD
+
+ Article pager
+ j / Down Scroll down one line
+ k / Up Scroll up one line
+ Space / PgDn Scroll down one page
+ b / PgUp Scroll up one page
+ g / Home Jump to top
+ G / End Jump to bottom
+ q Quit pager
+
+ Search results
+ 1-9, 0 View article (0 = result 10)
+ q Quit search
+
+ General
+ Ctrl+Q Abort during network request
+
+SEE ALSO
+ fetch(1), ping(1), nslookup(1), shell(1)