# API
## Functions
### system
#### spawn(*name*, *function*, *environment*)
Spawns a process from *function* called *name* with *environment*.
#### log(*messages...*, *severity*, *facility*, *meta*)
Writes messages to the system log, optionally, if *meta* is true, with *severity* and *facility*, which default to 6 and 2, respectively.

### os
#### os.getenv(*k*)
Gets the *k* environment variable for the current process.
#### os.setenv(*k*, *v*)
Sets the *k* environment variable to *v* for the current process.
#### os.tasks()
Returns a list of current processes running, the key being the pid and the value being the name.
#### os.taskinfo(*pid*)
Returns the name, parent process, and user ID for process *pid*.
#### os.genenv()
Generates an insulated environment table for running processes in.
#### os.getuid(*pid*)
Returns the user ID for process *pid*, or if *pid* is not specified, the current process.
#### os.setuid(*user*)
Only if the current user ID is "superuser": Sets the user ID for the process to *user*.
#### os.verifyuser(*user*,*pass*)
Returns true or false if *pass* is the correct password for *user*.
#### os.gensalt(*len*)
Generates *len* random printable characters and returns them.
#### os.su(*user*,*pass*)
Sets the user ID of the current process to *user* if *user* and *password* are verified by `os.verifyuser`.
#### os.setuattr(*user*,*field*,*value*)
Sets the *field* attribute of *user* to *value*.
#### os.getuattr(*user*,*field*)
Returns the value of *field* for *user*.

### event
#### event.get()
Gets the next event in the event queue for the process.
#### event.pull(*type*,*timeout*)
Gets, and possibly waits for up to *timeout* seconds, for an event, optionally with *type*.

### buffer
#### buffer.create(*w*, *c*)
**DEPRECEATED.** Creates a buffer with worker function *w* and close function *c*. *w* is called on creation with the buffer as the argument.
#### buffer.ucreate()
Creates a unidirectional buffer and returns it.
#### buffer.bcreate()
Creates a bidiretional buffer and returns both ends.

### filesystem
#### fs.mount(*mp*, *pr*)
Mounts the component proxy *pr* to mountpoint *mp*.
#### fs.simplify(*path*)
Simplifies *path* by resolving .. and . and similar.
#### fs.resolve(*path*)
Resolves *path* to a table of path elements, a mountpoint and a relative filesystem path.
#### fs.open(*path*,*mode*)
Returns a system file handle usable by other fs functions for *path* in *mode*. Modes can be r, w, a, rb, wb, ab.
#### fs.close(*handle*)
Closes a system file handle.
#### fs.read(*handle*,*length*)
Reads *length* bytes of data from *handle*. *length* is usually limited to 2048.
#### fs.write(*handle*,*data*)
Writes *data* to *handle*.
#### fs.readall(*handle*)
Returns as much data as can be read from *handle*.
#### fs.list(*path*)
Returns a table of files contained in directory *path*
#### fs.mkdir(*path*)
Creates a directory at *path*
#### fs.rm(*path*)
Removes a file or (empty) directory at *path*.
#### fs.exists(*path*)
Returns true if a file or directory *path* exists.
#### fs.isdir(*path*)
Returns true if *path* is a directory.
#### fs.cd(*path*)
Changes the current directory to either *path* or *os.getenv("PWD")*/*path*.
#### fs.cp(*source*, *destination*)
Copies a file from *source* to *destination*.
#### fs.mv(*source*, *destination*)
Same as fs.cp but deletes *source* afterwards.
#### fs.getattr(*path*,*key*)
Returns the value of *path*'s extended attribute *key*, assuming your user ID is in the read attribute.
#### fs.setattr(*path*,*key*,*value*)
Set *path*'s extended attribute *key* to *value*, assuming your user ID is in the write attribute

### io
#### write(...) or io.write(...)
Writes its arguments to the I/O device.
#### print(...)
Writes its arguments to the I/O device, with a newline after each.
#### readln(*rch*) or io.read(...)
Reads a line from the I/O device, optionally replacing the echoed characters with *rch*.a
#### io.open(*path*,*mode*)
Returns a file object for *path* in *mode*.
##### fobj:read(*len*)
If *len* is a number, reads *len* bytes from *fobj*. If *len* is "\*a", it reads all the data from *fobj*. If *len* is "\*l", it reads a line from *fobj*.
##### fobj:write(*data*)
Writes *data* to *fobj* (if in write mode)
##### fobj:close()
Closes *fobj*, flushing buffers and removing the object from memory.

### shutil
#### exec(*command*)
Executes *command* as if it had been typed into a shell (lush, specifically).
#### cd(*path*)
Alias to fs.cd
#### rm(*path*)
Alias to fs.rm
#### mkdir(*path*)
Alias to fs.mkdir
#### ls(*path*)
Wrapper for fs.list that prints the contents of *path*.
#### cat(*path*)
Prints the contents of the file *path*.
#### ps(*filter*)
Prints running processes, optionally matching *filter*.
#### mem()
Print out some memory info.

### net
#### net.send(*addr*,*port*,*msg*)
Sends *msg* to *addr* on *port*.
#### net.sendstring(*addr*,*port*,*msg*)
Sends *msg* to *addr* on *port* in *net.mtu* sized chunks.
#### net.recvstring(*addr*,*port*)

### cdlib
cdlib is the Copper Data Library
#### cdlib.encode(*hops*, *source*, *destination*, *data*)
Encodes a copper packet with *hops* from *source* to *destination* with *data*.
#### cdlib.decode(*data*)
Decodes a copper packet. Returns the same data cdlib.encode takes as input.
#### cdlib.encodeName(*name*)
Encodes a name for use in a copper packet.
#### cdlib.decodeName(*message*)
Returns just the name from an encoded copper packet.
#### cdlib.decodeNoHops(*data*)
Decodes a copper packet minus the hops.

### relib
relib is the Copper reliability layer library.
#### relib.encode(*packet*)
Encodes *packet* passed as a table as a relib packet.
#### relib.decode(*data*)
Decodes *data* into a relib packet table.

### drivers
#### tty(*gA*, *sA*, *sI*, *fg*, *bg*)
Creates a GPU driver instance for GPU *gA* and screen *sA* attached to session *sI*, optionally with foreground and background colours *fg* and *bg*.
#### kbd(*kA*, *sI*)
Creates a keyboard driver instance for keyboard *kA* attached to session *sI*.


## Events
### Network
#### net\_msg, *from*, *port*, *message*
Queued when the system receives message *message* from *from* on port *port*.

### Terminal I/O
#### key, *session*, *char*, *code*
A key with value *char* and code *code* was pressed and parsed by a keyboard handler attached to session *session*
#### display, *session*, *text*
This is triggered to make a tty driver attached to *session* write *text* to the screen. Ideally, use write(), not the raw event.


## Applications
### login()
Displays a login screen allowing for changing user.  
### loginmanager(*sI*)
Runs a program that will repeatedly display a login screen and spawn a shell on login.  
### lush(*sI*)
Spawns a lush instance for session *sI*
### skex(*fname*)
Launches an instance of the skex text editor, optionally reading *fname* at startup.  
May actually spawn skex2.
### skex2(*fname*)
Launches an instance of the skex2 text editor, optionally reading *fname* at startup.
### nsh(*host*, *port*)
Spawns the network shell client and attempts to connect to *host* on *port* for a remote login session.  
ctrl-shift-c to exit.
### nshd(*port*)
Spawns a networh shell server listening on *port.*