package core:os

Source

ADDRESS_FAMILY :: u16

Dir :: distinct rawptr

Dirent :: struct {
	ino:    u64,
	off:    u64,
	reclen: u16,
	type:   u8,
	name:   [256]u8,
}

Errno :: Error

Error :: union {
	General_Error, 
	io.Error, 
	runtime.Allocator_Error, 
	linux.Errno, 
}

File_Info :: struct {
	fullpath:          string,
	// allocated
	name:              string,
	// uses `fullpath` as underlying data
	size:              i64,
	mode:              File_Mode,
	is_dir:            bool,
	creation_time:     time.Time,
	modification_time: time.Time,
	access_time:       time.Time,
}

File_Mode :: distinct u32

File_Time :: distinct u64

General_Error :: enum u32 {
	None, 
	Exist, 
	Not_Exist, 
	Timeout, 
	Broken_Pipe, 
	Invalid_File, 
	Invalid_Dir, 
	Invalid_Path, 
	Invalid_Callback, 
	Pattern_Has_Separator, 
	File_Is_Pipe, 
	Not_Dir, 
	// Environment variable not found.
	Env_Var_Not_Found, 
}

Handle :: distinct i32

OS_Stat :: struct {
	device_id:     u64,
	// ID of device containing file
	serial:        u64,
	// File serial number
	nlink:         u64,
	// Number of hard links
	mode:          u32,
	// Mode of the file
	uid:           u32,
	// User ID of the file's owner
	gid:           u32,
	// Group ID of the file's group
	_:             i32,
	// 32 bits of padding
	rdev:          u64,
	// Device ID, if device
	size:          i64,
	// Size of the file, in bytes
	block_size:    i64,
	// Optimal bllocksize for I/O
	blocks:        i64,
	// Number of 512-byte blocks allocated
	last_access:   Unix_File_Time,
	// Time of last access
	modified:      Unix_File_Time,
	// Time of last modification
	status_change: Unix_File_Time,
	// Time of last status change
	_reserved:     [3]i64,
}

Pid :: distinct i32

Platform_Error :: linux.Errno

SIOCGIFFLAG :: enum i32 {
	UP             = 0,  // Interface is up.
	BROADCAST      = 1,  // Broadcast address valid.
	DEBUG          = 2,  // Turn on debugging.
	LOOPBACK       = 3,  // Is a loopback net.
	POINT_TO_POINT = 4,  // Interface is point-to-point link.
	NO_TRAILERS    = 5,  // Avoid use of trailers.
	RUNNING        = 6,  // Resources allocated.
	NOARP          = 7,  // No address resolution protocol.
	PROMISC        = 8,  // Receive all packets.
	ALL_MULTI      = 9,  // Receive all multicast packets. Unimplemented.
	MASTER         = 10, // Master of a load balancer.
	SLAVE          = 11, // Slave of a load balancer.
	MULTICAST      = 12, // Supports multicast.
	PORTSEL        = 13, // Can set media type.
	AUTOMEDIA      = 14, // Auto media select active.
	DYNAMIC        = 15, // Dialup device with changing addresses.
	LOWER_UP       = 16, 
	DORMANT        = 17, 
	ECHO           = 18, 
}

SIOCGIFFLAGS :: bit_set[SIOCGIFFLAG; i32]

SOCKADDR :: struct #packed {
	sa_family: u16,
	sa_data:   [14]u8,
}

SOCKADDR_STORAGE_LH :: struct #packed {
	ss_family:  u16,
	__ss_pad1:  [6]u8,
	__ss_align: i64,
	__ss_pad2:  [112]u8,
}

Socket :: distinct int

Timeval :: struct {
	seconds:      i64,
	microseconds: int,
}

Unix_File_Time :: struct {
	seconds:     i64,
	nanoseconds: i64,
}

ifaddrs :: struct {
	next:              ^ifaddrs,
	name:              cstring,
	flags:             bit_set[SIOCGIFFLAG; i32],
	address:           ^SOCKADDR,
	netmask:           ^SOCKADDR,
	broadcast_or_dest: ^SOCKADDR,
	// Broadcast or Point-to-Point address
	data:              rawptr,
}

in6_addr :: struct #packed {
	s6_addr: [16]u8,
}

in_addr :: struct #packed {
	s_addr: u32,
}

pollfd :: struct {
	fd:      i32,
	events:  i16,
	revents: i16,
}

rtnl_link_stats :: struct #packed {
	rx_packets:          u32,
	tx_packets:          u32,
	rx_bytes:            u32,
	tx_bytes:            u32,
	rx_errors:           u32,
	tx_errors:           u32,
	rx_dropped:          u32,
	tx_dropped:          u32,
	multicast:           u32,
	collisions:          u32,
	rx_length_errors:    u32,
	rx_over_errors:      u32,
	rx_crc_errors:       u32,
	rx_frame_errors:     u32,
	rx_fifo_errors:      u32,
	rx_missed_errors:    u32,
	tx_aborted_errors:   u32,
	tx_carrier_errors:   u32,
	tx_fifo_errors:      u32,
	tx_heartbeat_errors: u32,
	tx_window_errors:    u32,
	rx_compressed:       u32,
	tx_compressed:       u32,
	rx_nohandler:        u32,
}

sigset_t :: distinct u64

sockaddr_in :: struct #packed {
	sin_family: u16,
	sin_port:   u16be,
	sin_addr:   in_addr,
	sin_zero:   [8]u8,
}

sockaddr_in6 :: struct #packed {
	sin6_family:   u16,
	sin6_port:     u16be,
	sin6_flowinfo: u64,
	sin6_addr:     in6_addr,
	sin6_scope_id: u64,
}

socklen_t :: i32

ADDR_NO_RANDOMIZE: int : 0x40000

AF_BLUETOOTH: int : 31

AF_INET: int : 2

AF_INET6: int : 10

AF_LOCAL: int : AF_UNIX

AF_PACKET: int : 17

AF_UNIX: int : 1

AF_UNSPEC: int : 0

ARCH: .Odin_Arch_Type : ODIN_ARCH

AT_FDCWD: uintptr : ~uintptr(99)

AT_REMOVEDIR :: uintptr(0x200)

AT_SYMLINK_NOFOLLOW :: uintptr(0x100)

EACCES: linux.Errno : Platform_Error.EACCES

EADDRINUSE: linux.Errno : Platform_Error.EADDRINUSE

EADDRNOTAVAIL: linux.Errno : Platform_Error.EADDRNOTAVAIL

EADV: linux.Errno : Platform_Error.EADV

EAFNOSUPPORT: linux.Errno : Platform_Error.EAFNOSUPPORT

EAGAIN: linux.Errno : Platform_Error.EAGAIN

EALREADY: linux.Errno : Platform_Error.EALREADY

EBADE: linux.Errno : Platform_Error.EBADE

EBADF: linux.Errno : Platform_Error.EBADF

EBADFD: linux.Errno : Platform_Error.EBADFD

EBADMSG: linux.Errno : Platform_Error.EBADMSG

EBADR: linux.Errno : Platform_Error.EBADR

EBADRQC: linux.Errno : Platform_Error.EBADRQC

EBADSLT: linux.Errno : Platform_Error.EBADSLT

EBFONT: linux.Errno : Platform_Error.EBFONT

ECANCELED: linux.Errno : Platform_Error.ECANCELED

ECHRNG: linux.Errno : Platform_Error.ECHRNG

ECOMM: linux.Errno : Platform_Error.ECOMM

ECONNABORTED: linux.Errno : Platform_Error.ECONNABORTED

ECONNREFUSED: linux.Errno : Platform_Error.ECONNREFUSED

ECONNRESET: linux.Errno : Platform_Error.ECONNRESET

EDEADLK: linux.Errno : Platform_Error.EDEADLK

EDEADLOCK: linux.Errno : Platform_Error.EDEADLOCK

EDESTADDRREQ: linux.Errno : Platform_Error.EDESTADDRREQ

EDOTDOT: linux.Errno : Platform_Error.EDOTDOT

EDQUOT: linux.Errno : Platform_Error.EDQUOT

EEXIST: linux.Errno : Platform_Error.EEXIST

EFAULT: linux.Errno : Platform_Error.EFAULT

EFBIG: linux.Errno : Platform_Error.EFBIG

EHOSTDOWN: linux.Errno : Platform_Error.EHOSTDOWN

EHOSTUNREACH: linux.Errno : Platform_Error.EHOSTUNREACH

EHWPOISON: linux.Errno : Platform_Error.EHWPOISON

EIDRM: linux.Errno : Platform_Error.EIDRM

EILSEQ: linux.Errno : Platform_Error.EILSEQ

EINPROGRESS: linux.Errno : Platform_Error.EINPROGRESS

EINTR: linux.Errno : Platform_Error.EINTR

EINVAL: linux.Errno : Platform_Error.EINVAL

EIO: linux.Errno : Platform_Error.EIO

EISCONN: linux.Errno : Platform_Error.EISCONN

EISDIR: linux.Errno : Platform_Error.EISDIR

EISNAM: linux.Errno : Platform_Error.EISNAM

EKEYEXPIRED: linux.Errno : Platform_Error.EKEYEXPIRED

EKEYREJECTED: linux.Errno : Platform_Error.EKEYREJECTED

EKEYREVOKED: linux.Errno : Platform_Error.EKEYREVOKED

EL2HLT: linux.Errno : Platform_Error.EL2HLT

EL2NSYNC: linux.Errno : Platform_Error.EL2NSYNC

EL3HLT: linux.Errno : Platform_Error.EL3HLT

EL3RST: linux.Errno : Platform_Error.EL3RST

ELIBACC: linux.Errno : Platform_Error.ELIBACC

ELIBBAD: linux.Errno : Platform_Error.ELIBBAD

ELIBEXEC: linux.Errno : Platform_Error.ELIBEXEC

ELIBMAX: linux.Errno : Platform_Error.ELIBMAX

ELIBSCN: linux.Errno : Platform_Error.ELIBSCN

ELNRNG: linux.Errno : Platform_Error.ELNRNG

ELOOP: linux.Errno : Platform_Error.ELOOP

EMEDIUMTYPE: linux.Errno : Platform_Error.EMEDIUMTYPE

EMFILE: linux.Errno : Platform_Error.EMFILE

EMSGSIZE: linux.Errno : Platform_Error.EMSGSIZE

EMULTIHOP: linux.Errno : Platform_Error.EMULTIHOP

ENAMETOOLONG: linux.Errno : Platform_Error.ENAMETOOLONG

ENAVAIL: linux.Errno : Platform_Error.ENAVAIL

ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

ENETDOWN: linux.Errno : Platform_Error.ENETDOWN

ENETRESET: linux.Errno : Platform_Error.ENETRESET

ENETUNREACH: linux.Errno : Platform_Error.ENETUNREACH

ENFILE: linux.Errno : Platform_Error.ENFILE

ENOANO: linux.Errno : Platform_Error.ENOANO

ENOBUFS: linux.Errno : Platform_Error.ENOBUFS

ENOCSI: linux.Errno : Platform_Error.ENOCSI

ENODATA: linux.Errno : Platform_Error.ENODATA

ENODEV: linux.Errno : Platform_Error.ENODEV

ENOENT: linux.Errno : Platform_Error.ENOENT

ENOKEY: linux.Errno : Platform_Error.ENOKEY

ENOLCK: linux.Errno : Platform_Error.ENOLCK

ENOLINK: linux.Errno : Platform_Error.ENOLINK

ENOMEDIUM: linux.Errno : Platform_Error.ENOMEDIUM

ENOMEM: linux.Errno : Platform_Error.ENOMEM

ENOMSG: linux.Errno : Platform_Error.ENOMSG

ENONET: linux.Errno : Platform_Error.ENONET

ENOPKG: linux.Errno : Platform_Error.ENOPKG

ENOPROTOOPT: linux.Errno : Platform_Error.ENOPROTOOPT

ENOSPC: linux.Errno : Platform_Error.ENOSPC

ENOSR: linux.Errno : Platform_Error.ENOSR

ENOSTR: linux.Errno : Platform_Error.ENOSTR

ENOSYS: linux.Errno : Platform_Error.ENOSYS

ENOTCONN: linux.Errno : Platform_Error.ENOTCONN

ENOTDIR: linux.Errno : Platform_Error.ENOTDIR

ENOTEMPTY: linux.Errno : Platform_Error.ENOTEMPTY

ENOTNAM: linux.Errno : Platform_Error.ENOTNAM

ENOTRECOVERABLE: linux.Errno : Platform_Error.ENOTRECOVERABLE

ENOTSOCK: linux.Errno : Platform_Error.ENOTSOCK

ENOTUNIQ: linux.Errno : Platform_Error.ENOTUNIQ

ENXIO: linux.Errno : Platform_Error.ENXIO

EOPNOTSUPP: linux.Errno : Platform_Error.EOPNOTSUPP

EOVERFLOW: linux.Errno : Platform_Error.EOVERFLOW

EOWNERDEAD: linux.Errno : Platform_Error.EOWNERDEAD

EPERM: linux.Errno : Platform_Error.EPERM

EPFNOSUPPORT: linux.Errno : Platform_Error.EPFNOSUPPORT

EPIPE: linux.Errno : Platform_Error.EPIPE

EPROTO: linux.Errno : Platform_Error.EPROTO

EPROTONOSUPPOR: linux.Errno : Platform_Error.EPROTONOSUPPORT

EPROTOTYPE: linux.Errno : Platform_Error.EPROTOTYPE

ERANGE: linux.Errno : Platform_Error.ERANGE

EREMCHG: linux.Errno : Platform_Error.EREMCHG

EREMOTE: linux.Errno : Platform_Error.EREMOTE

EREMOTEIO: linux.Errno : Platform_Error.EREMOTEIO

ERESTART: linux.Errno : Platform_Error.ERESTART

ERFKILL: linux.Errno : Platform_Error.ERFKILL

EROFS: linux.Errno : Platform_Error.EROFS

ERROR_EOF: io.Error : io.Error.EOF

ERROR_NONE :: Error{}

ESHUTDOWN: linux.Errno : Platform_Error.ESHUTDOWN

ESOCKTNOSUPPOR: linux.Errno : Platform_Error.ESOCKTNOSUPPORT

ESPIPE: linux.Errno : Platform_Error.ESPIPE

ESRCH: linux.Errno : Platform_Error.ESRCH

ESRMNT: linux.Errno : Platform_Error.ESRMNT

ESTALE: linux.Errno : Platform_Error.ESTALE

ESTRPIPE: linux.Errno : Platform_Error.ESTRPIPE

ETIME: linux.Errno : Platform_Error.ETIME

ETIMEDOUT: linux.Errno : Platform_Error.ETIMEDOUT

ETOOMANYREFS: linux.Errno : Platform_Error.ETOOMANYREFS

ETXTBSY: linux.Errno : Platform_Error.ETXTBSY

EUCLEAN: linux.Errno : Platform_Error.EUCLEAN

EUNATCH: linux.Errno : Platform_Error.EUNATCH

EUSERS: linux.Errno : Platform_Error.EUSERS

EWOULDBLOCK: linux.Errno : Platform_Error.EWOULDBLOCK

EXFULL: linux.Errno : Platform_Error.EXFULL

F_GETFL: int : 3

F_OK: int : 0

F_SETFL: int : 4

File_Mode_Char_Device :: File_Mode(1 << 19)

File_Mode_Device :: File_Mode(1 << 18)

File_Mode_Dir :: File_Mode(1 << 16)

File_Mode_Named_Pipe :: File_Mode(1 << 17)

File_Mode_Sym_Link :: File_Mode(1 << 20)

INADDR_ANY: u64 : 0

INADDR_BROADCAST: u64 : 0xffffffff

INADDR_DUMMY: u64 : 0xc0000008

INADDR_NONE: u64 : 0xffffffff

INVALID_HANDLE: Handle : ~Handle(0)

IPPROTO_ETHERNET: int : 143

IPPROTO_ICMP: int : 1

IPPROTO_IP: int : 0

IPPROTO_IPV6: int : 41

IPPROTO_RAW: int : 255

IPPROTO_TCP: int : 6

IPPROTO_UDP: int : 17

MSG_TRUNC: int : 0x20

OS: .Odin_OS_Type : ODIN_OS

O_APPEND: int : 0x00400

O_ASYNC: int : 0x02000

O_CLOEXEC: int : 0x80000

O_CREATE: int : 0x00040

O_EXCL: int : 0x00080

O_NOCTTY: int : 0x00100

O_NONBLOCK: int : 0x00800

O_RDONLY: int : 0x00000

O_RDWR: int : 0x00002

O_SYNC: int : 0x01000

O_TRUNC: int : 0x00200

O_WRONLY: int : 0x00001

RTLD_BINDING_MASK: int : 0x0003

RTLD_DEEPBIND: int : 0x0008

RTLD_GLOBAL: int : 0x0100

RTLD_LAZY: int : 0x0001

RTLD_NODELETE: int : 0x1000

RTLD_NOLOAD: int : 0x0004

RTLD_NOW: int : 0x0002

R_OK: int : 4

SEEK_CUR: int : 1

SEEK_DATA: int : 3

SEEK_END: int : 2

SEEK_HOLE: int : 4

SEEK_MAX: int : SEEK_HOLE

SEEK_SET: int : 0

SHUT_RD: int : 0

SHUT_RDWR: int : 2

SHUT_WR: int : 1

SOCK_DGRAM: int : 2

SOCK_PACKET: int : 10

SOCK_RAW: int : 3

SOCK_RDM: int : 4

SOCK_SEQPACKET: int : 5

SOCK_STREAM: int : 1

SOL_SOCKET: int : 1

SO_BROADCAST: int : 6

SO_DEBUG: int : 1

SO_DONTROUTE: int : 5

SO_KEEPALIVE: int : 9

SO_LINGER: int : 13

SO_OOBINLINE: int : 10

SO_RCVBUF: int : 8

SO_RCVTIMEO_NEW: int : 66

SO_REUSEADDR: int : 2

SO_REUSEPORT: int : 15

SO_SNDBUF: int : 7

SO_SNDTIMEO_NEW: int : 67

S_IFBLK: int : 0o060000

S_IFCHR: int : 0o020000

S_IFDIR: int : 0o040000

S_IFIFO: int : 0o010000

S_IFLNK: int : 0o120000

S_IFMT: int : 0o170000

S_IFREG: int : 0o100000

S_IFSOCK: int : 0o140000

S_IRGRP: int : 0o0040

S_IROTH: int : 0o0004

S_IRUSR: int : 0o0400

S_IRWXG: int : 0o0070

S_IRWXO: int : 0o0007

S_IRWXU: int : 0o0700

S_ISGID: int : 0o2000

S_ISUID: int : 0o4000

S_ISVTX: int : 0o1000

S_IWGRP: int : 0o0020

S_IWOTH: int : 0o0002

S_IWUSR: int : 0o0200

S_IXGRP: int : 0o0010

S_IXOTH: int : 0o0001

S_IXUSR: int : 0o0100

TCP_CORK: int : 3

TCP_NODELAY: int : 1

W_OK: int : 2

X_OK: int : 1

args: []string = …

stderr: Handle = …

stdin: Handle = …

stdout: Handle = …

S_ISBLK :: proc(m: u32) -> bool {…}

S_ISCHR :: proc(m: u32) -> bool {…}

S_ISDIR :: proc(m: u32) -> bool {…}

S_ISFIFO :: proc(m: u32) -> bool {…}

S_ISLNK :: proc(m: u32) -> bool {…}

S_ISREG :: proc(m: u32) -> bool {…}

S_ISSOCK :: proc(m: u32) -> bool {…}

absolute_path_from_handle :: proc(fd: Handle) -> (string, Error) {…}

absolute_path_from_relative :: proc(rel: string, allocator := context.allocator) -> (path: string, err: Error) {…}

accept :: proc(sd: Socket, addr: ^SOCKADDR, len: rawptr) -> (Socket, Error) {…}

access :: proc(path: string, mask: int) -> (bool, Error) {…}

bind :: proc(sd: Socket, addr: ^SOCKADDR, len: i32) -> Error {…}

close :: proc(fd: Handle) -> Error {…}

connect :: proc(sd: Socket, addr: ^SOCKADDR, len: i32) -> Error {…}

current_thread_id :: proc "contextless" () -> int {…}

dlclose :: proc(handle: rawptr) -> bool {…}

dlerror :: proc() -> string {…}

dlopen :: proc(filename: string, flags: int) -> rawptr {…}

dlsym :: proc(handle: rawptr, symbol: string) -> rawptr {…}

error_string :: proc "contextless" (ferr: Error) -> string {…}

execvp :: proc(path: string, args: []string) -> Error {…}

exists :: proc(path: string) -> bool {…}

exit :: proc "contextless" (code: int) -> ! {…}

fcntl :: proc(fd: int, cmd: int, arg: int) -> (int, Error) {…}

file_info_delete :: proc(fi: File_Info, allocator := context.allocator) {…}

file_info_slice_delete :: proc(infos: []File_Info, allocator := context.allocator) {…}

file_size :: proc(fd: Handle) -> (i64, Error) {…}

file_size_from_path :: proc(path: string) -> i64 {…}

flush :: proc(fd: Handle) -> Error {…}

fork :: proc() -> (Pid, Error) {…}

fstat :: proc(fd: Handle, allocator := context.allocator) -> (fi: File_Info, err: Error) {…}

get_current_directory :: proc(allocator := context.allocator) -> string {…}

get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {…}

get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {…}

get_last_error :: proc "contextless" () -> Error {…}

get_page_size :: proc() -> int {…}

is_dir_handle :: proc(fd: Handle) -> bool {…}

is_dir_path :: proc(path: string, follow_links: bool = true) -> bool {…}

is_file_handle :: proc(fd: Handle) -> bool {…}

is_file_path :: proc(path: string, follow_links: bool = true) -> bool {…}

is_path_separator :: proc(r: untyped rune) -> bool {…}

is_platform_error :: proc "contextless" (ferr: Error) -> (err: i32, ok: bool) {…}

last_write_time :: proc(fd: Handle) -> (time: File_Time, err: Error) {…}

last_write_time_by_name :: proc(name: string) -> (time: File_Time, err: Error) {…}

listen :: proc(sd: Socket, backlog: int) -> Error {…}

lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {…}

lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {…}

lstat :: proc(name: string, allocator := context.allocator) -> (fi: File_Info, err: Error) {…}

make_directory :: proc(path: string, mode: u32 = 0o775) -> Error {…}

open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0o000) -> (Handle, Error) {…}

personality :: proc(persona: u64) -> Error {…}

poll :: proc(fds: []pollfd, timeout: int) -> (int, Error) {…}

ppoll :: proc(fds: []pollfd, timeout: ^unix.timespec, sigmask: ^sigset_t) -> (int, Error) {…}

print_error :: proc(f: Handle, ferr: Error, msg: string) -> (n: int, err: Error) {…}

processor_core_count :: proc() -> int {…}

read :: proc(fd: Handle, data: []u8) -> (int, Error) {…}

read_at :: proc(fd: Handle, data: []u8, offset: i64) -> (int, Error) {…}

read_at_least :: proc(fd: Handle, buf: []u8, min: int) -> (n: int, err: Error) {…}

read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Error) {…}

read_entire_file_from_filename :: proc(name: string, allocator := context.allocator, loc := #caller_location) -> (data: []u8, success: bool) {…}

read_entire_file_from_filename_or_err :: proc(name: string, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: Error) {…}

read_entire_file_from_handle :: proc(fd: Handle, allocator := context.allocator, loc := #caller_location) -> (data: []u8, success: bool) {…}

read_entire_file_from_handle_or_err :: proc(fd: Handle, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: Error) {…}

read_full :: proc(fd: Handle, buf: []u8) -> (n: int, err: Error) {…}

read_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Error) {…}

recv :: proc(sd: Socket, data: []u8, flags: int) -> (u32, Error) {…}

recvfrom :: proc(sd: Socket, data: []u8, flags: int, addr: ^SOCKADDR, addr_size: ^i32) -> (u32, Error) {…}

remove :: proc(path: string) -> Error {…}

remove_directory :: proc(path: string) -> Error {…}

rename :: proc(old_path, new_path: string) -> Error {…}

replace_environment_placeholders :: proc(path: string, allocator := context.allocator) -> (res: string) {…}

seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Error) {…}

send :: proc(sd: Socket, data: []u8, flags: int) -> (u32, Error) {…}

sendto :: proc(sd: Socket, data: []u8, flags: int, addr: ^SOCKADDR, addrlen: i32) -> (u32, Error) {…}

set_current_directory :: proc(path: string) -> (err: Error) {…}

set_env :: proc(key, value: string) -> Error {…}

setsockopt :: proc(sd: Socket, level: int, optname: int, optval: rawptr, optlen: i32) -> Error {…}

shutdown :: proc(sd: Socket, how: int) -> Error {…}

socket :: proc(domain: int, type: int, protocol: int) -> (Socket, Error) {…}

stat :: proc(name: string, allocator := context.allocator) -> (fi: File_Info, err: Error) {…}

stream_from_handle :: proc(fd: Handle) -> io.Stream {…}

unset_env :: proc(key: string) -> Error {…}

write :: proc(fd: Handle, data: []u8) -> (int, Error) {…}

write_at :: proc(fd: Handle, data: []u8, offset: i64) -> (int, Error) {…}

write_byte :: proc(fd: Handle, b: u8) -> (int, Error) {…}

write_encoded_rune :: proc(f: Handle, r: untyped rune) -> (n: int, err: Error) {…}

write_entire_file :: proc(name: string, data: []u8, truncate: bool = true) -> (success: bool) {…}

write_entire_file_or_err :: proc(name: string, data: []u8, truncate: bool = true) -> Error {…}

write_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Error) {…}

write_rune :: proc(fd: Handle, r: untyped rune) -> (int, Error) {…}

write_string :: proc(fd: Handle, str: string) -> (int, Error) {…}

get_env :: proc{
	get_env_alloc,
	get_env_buf,
}

is_dir :: proc{
	is_dir_path,
	is_dir_handle,
}

is_file :: proc{
	is_file_path,
	is_file_handle,
}

lookup_env :: proc{
	lookup_env_alloc,
	lookup_env_buffer,
}

read_entire_file :: proc{
	read_entire_file_from_filename,
	read_entire_file_from_handle,
}

read_entire_file_or_err :: proc{
	read_entire_file_from_filename_or_err,
	read_entire_file_from_handle_or_err,
}