Skip to content

Latest commit

 

History

History
3063 lines (3063 loc) · 172 KB

imports.md

File metadata and controls

3063 lines (3063 loc) · 172 KB

World imports

Import interface wasi:cli/[email protected]

Functions

get-environment: func

Get the POSIX-style environment variables.

Each environment variable is provided as a pair of string variable names and string value.

Morally, these are a value import, but until value imports are available in the component model, this import function should return the same values each time it is called.

Return values
  • list<(string, string)>

get-arguments: func

Get the POSIX-style arguments to the program.

Return values
  • list<string>

initial-cwd: func

Return a path that programs should use as their initial current working directory, interpreting . as shorthand for this.

Return values
  • option<string>

Import interface wasi:cli/[email protected]

Functions

exit: func

Exit the current instance and any linked instances.

Params
  • status: result

exit-with-code: func

Exit the current instance and any linked instances, reporting the specified status code to the host.

The meaning of the code depends on the context, with 0 usually meaning "success", and other values indicating various types of failure.

This function does not return; the effect is analogous to a trap, but without the connotation that something bad has happened.

Params
  • status-code: u8

Import interface wasi:io/[email protected]

Types

resource error

A resource which represents some error information.

The only method provided by this resource is to-debug-string, which provides some human-readable information about the error.

In the wasi:io package, this resource is returned through the wasi:io/streams/stream-error type.

To provide more specific error information, other interfaces may offer functions to "downcast" this error into more specific types. For example, errors returned from streams derived from filesystem types can be described using the filesystem's own error-code type. This is done using the function wasi:filesystem/types/filesystem-error-code, which takes a borrow<error> parameter and returns an option<wasi:filesystem/types/error-code>.

The set of functions which can "downcast" an error into a more concrete type is open.

Functions

[method]error.to-debug-string: func

Returns a string that is suitable to assist humans in debugging this error.

WARNING: The returned string should not be consumed mechanically! It may change across platforms, hosts, or other implementation details. Parsing this string is a major platform-compatibility hazard.

Params
Return values
  • string

Import interface wasi:io/[email protected]

A poll API intended to let users wait for I/O events on multiple handles at once.

Types

resource pollable

pollable represents a single I/O event which may be ready, or not.

Functions

[method]pollable.ready: func

Return the readiness of a pollable. This function never blocks.

Returns true when the pollable is ready, and false otherwise.

Params
Return values
  • bool

[method]pollable.block: func

block returns immediately if the pollable is ready, and otherwise blocks until ready.

This function is equivalent to calling poll.poll on a list containing only this pollable.

Params

poll: func

Poll for completion on a set of pollables.

This function takes a list of pollables, which identify I/O sources of interest, and waits until one or more of the events is ready for I/O.

The result list<u32> contains one or more indices of handles in the argument list that is ready for I/O.

This function traps if either:

  • the list is empty, or:
  • the list contains more elements than can be indexed with a u32 value.

A timeout can be implemented by adding a pollable from the wasi-clocks API to the list.

This function does not return a result; polling in itself does not do any I/O so it doesn't fail. If any of the I/O sources identified by the pollables has an error, it is indicated by marking the source as being ready for I/O.

Params
Return values
  • list<u32>

Import interface wasi:io/[email protected]

WASI I/O is an I/O abstraction API which is currently focused on providing stream types.

In the future, the component model is expected to add built-in stream types; when it does, they are expected to subsume this API.

Types

type error

error

#### `type pollable` [`pollable`](#pollable)

#### `variant stream-error`

An error for input-stream and output-stream operations.

Variant Cases

  • last-operation-failed: own<error>

    The last operation (a write or flush) failed before completion.

    More information is available in the error payload.

    After this, the stream will be closed. All future operations return stream-error::closed.

  • closed

    The stream is closed: no more input will be accepted by the stream. A closed output-stream will return this error on all future operations.

resource input-stream

An input bytestream.

input-streams are non-blocking to the extent practical on underlying platforms. I/O operations always return promptly; if fewer bytes are promptly available than requested, they return the number of bytes promptly available, which could even be zero. To wait for data to be available, use the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

resource output-stream

An output bytestream.

output-streams are non-blocking to the extent practical on underlying platforms. Except where specified otherwise, I/O operations also always return promptly, after the number of bytes that can be written promptly, which could even be zero. To wait for the stream to be ready to accept data, the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

Dropping an output-stream while there's still an active write in progress may result in the data being lost. Before dropping the stream, be sure to fully flush your writes.

Functions

[method]input-stream.read: func

Perform a non-blocking read from the stream.

When the source of a read is binary data, the bytes from the source are returned verbatim. When the source of a read is known to the implementation to be text, bytes containing the UTF-8 encoding of the text are returned.

This function returns a list of bytes containing the read data, when successful. The returned list will contain up to len bytes; it may return fewer than requested, but not more. The list is empty when no bytes are available for reading at this time. The pollable given by subscribe will be ready when more bytes are available.

This function fails with a stream-error when the operation encounters an error, giving last-operation-failed, or when the stream is closed, giving closed.

When the caller gives a len of 0, it represents a request to read 0 bytes. If the stream is still open, this call should succeed and return an empty list, or otherwise fail with closed.

The len parameter is a u64, which could represent a list of u8 which is not possible to allocate in wasm32, or not desirable to allocate as as a return value by the callee. The callee may return a list of bytes less than len in size while more bytes are available for reading.

Params
Return values

[method]input-stream.blocking-read: func

Read bytes from a stream, after blocking until at least one byte can be read. Except for blocking, behavior is identical to read.

Params
Return values

[method]input-stream.skip: func

Skip bytes from a stream. Returns number of bytes skipped.

Behaves identical to read, except instead of returning a list of bytes, returns the number of bytes consumed from the stream.

Params
Return values

[method]input-stream.blocking-skip: func

Skip bytes from a stream, after blocking until at least one byte can be skipped. Except for blocking behavior, identical to skip.

Params
Return values

[method]input-stream.subscribe: func

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed. The created pollable is a child resource of the input-stream. Implementations may trap if the input-stream is dropped before all derived pollables created with this function are dropped.

Params
Return values

[method]output-stream.check-write: func

Check readiness for writing. This function never blocks.

Returns the number of bytes permitted for the next call to write, or an error. Calling write with more bytes than this function has permitted will trap.

When this function returns 0 bytes, the subscribe pollable will become ready when this function will report at least 1 byte, or an error.

Params
Return values

[method]output-stream.write: func

Perform a write. This function never blocks.

When the destination of a write is binary data, the bytes from contents are written verbatim. When the destination of a write is known to the implementation to be text, the bytes of contents are transcoded from UTF-8 into the encoding of the destination and then written.

Precondition: check-write gave permit of Ok(n) and contents has a length of less than or equal to n. Otherwise, this function will trap.

returns Err(closed) without writing if the stream has closed since the last call to check-write provided a permit.

Params
Return values

[method]output-stream.blocking-write-and-flush: func

Perform a write of up to 4096 bytes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while !contents.is_empty() {
  // Wait for the stream to become writable
  pollable.block();
  let Ok(n) = this.check-write(); // eliding error handling
  let len = min(n, contents.len());
  let (chunk, rest) = contents.split_at(len);
  this.write(chunk  );            // eliding error handling
  contents = rest;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling
Params
Return values

[method]output-stream.flush: func

Request to flush buffered output. This function never blocks.

This tells the output-stream that the caller intends any buffered output to be flushed. the output which is expected to be flushed is all that has been passed to write prior to this call.

Upon calling this function, the output-stream will not accept any writes (check-write will return ok(0)) until the flush has completed. The subscribe pollable will become ready when the flush has completed and the stream can accept more writes.

Params
Return values

[method]output-stream.blocking-flush: func

Request to flush buffered output, and block until flush completes and stream is ready for writing again.

Params
Return values

[method]output-stream.subscribe: func

Create a pollable which will resolve once the output-stream is ready for more writing, or an error has occurred. When this pollable is ready, check-write will return ok(n) with n>0, or an error.

If the stream is closed, this pollable is always ready immediately.

The created pollable is a child resource of the output-stream. Implementations may trap if the output-stream is dropped before all derived pollables created with this function are dropped.

Params
Return values

[method]output-stream.write-zeroes: func

Write zeroes to a stream.

This should be used precisely like write with the exact same preconditions (must use check-write first), but instead of passing a list of bytes, you simply pass the number of zero-bytes that should be written.

Params
Return values

[method]output-stream.blocking-write-zeroes-and-flush: func

Perform a write of up to 4096 zeroes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write-zeroes, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while num_zeroes != 0 {
  // Wait for the stream to become writable
  pollable.block();
  let Ok(n) = this.check-write(); // eliding error handling
  let len = min(n, num_zeroes);
  this.write-zeroes(len);         // eliding error handling
  num_zeroes -= len;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling
Params
Return values

[method]output-stream.splice: func

Read from one stream and write to another.

The behavior of splice is equivalent to:

  1. calling check-write on the output-stream
  2. calling read on the input-stream with the smaller of the check-write permitted length and the len provided to splice
  3. calling write on the output-stream with that read data.

Any error reported by the call to check-write, read, or write ends the splice and reports that error.

This function returns the number of bytes transferred; it may be less than len.

Params
Return values

[method]output-stream.blocking-splice: func

Read from one stream and write to another, with blocking.

This is similar to splice, except that it blocks until the output-stream is ready for writing, and the input-stream is ready for reading, before performing the splice.

Params
Return values

Import interface wasi:cli/[email protected]

Types

type input-stream

input-stream

----

Functions

get-stdin: func

Return values

Import interface wasi:cli/[email protected]

Types

type output-stream

output-stream

----

Functions

get-stdout: func

Return values

Import interface wasi:cli/[email protected]

Types

type output-stream

output-stream

----

Functions

get-stderr: func

Return values

Import interface wasi:cli/[email protected]

Terminal input.

In the future, this may include functions for disabling echoing, disabling input buffering so that keyboard events are sent through immediately, querying supported features, and so on.

Types

resource terminal-input

The input side of a terminal.

Import interface wasi:cli/[email protected]

Terminal output.

In the future, this may include functions for querying the terminal size, being notified of terminal size changes, querying supported features, and so on.

Types

resource terminal-output

The output side of a terminal.

Import interface wasi:cli/[email protected]

An interface providing an optional terminal-input for stdin as a link-time authority.

Types

type terminal-input

terminal-input

----

Functions

get-terminal-stdin: func

If stdin is connected to a terminal, return a terminal-input handle allowing further interaction with it.

Return values

Import interface wasi:cli/[email protected]

An interface providing an optional terminal-output for stdout as a link-time authority.

Types

type terminal-output

terminal-output

----

Functions

get-terminal-stdout: func

If stdout is connected to a terminal, return a terminal-output handle allowing further interaction with it.

Return values

Import interface wasi:cli/[email protected]

An interface providing an optional terminal-output for stderr as a link-time authority.

Types

type terminal-output

terminal-output

----

Functions

get-terminal-stderr: func

If stderr is connected to a terminal, return a terminal-output handle allowing further interaction with it.

Return values

Import interface wasi:clocks/[email protected]

WASI Monotonic Clock is a clock API intended to let users measure elapsed time.

It is intended to be portable at least between Unix-family platforms and Windows.

A monotonic clock is a clock which has an unspecified initial value, and successive reads of the clock will produce non-decreasing values.

Types

type pollable

pollable

#### `type instant` `u64`

An instant in time, in nanoseconds. An instant is relative to an unspecified initial value, and can only be compared to instances from the same monotonic-clock.

type duration

u64

A duration of time, in nanoseconds.

Functions

now: func

Read the current value of the clock.

The clock is monotonic, therefore calling this function repeatedly will produce a sequence of non-decreasing values.

Return values

resolution: func

Query the resolution of the clock. Returns the duration of time corresponding to a clock tick.

Return values

subscribe-instant: func

Create a pollable which will resolve once the specified instant has occurred.

Params
Return values

subscribe-duration: func

Create a pollable that will resolve after the specified duration has elapsed from the time this function is invoked.

Params
Return values

Import interface wasi:clocks/[email protected]

WASI Wall Clock is a clock API intended to let users query the current time. The name "wall" makes an analogy to a "clock on the wall", which is not necessarily monotonic as it may be reset.

It is intended to be portable at least between Unix-family platforms and Windows.

A wall clock is a clock which measures the date and time according to some external reference.

External references may be reset, so this clock is not necessarily monotonic, making it unsuitable for measuring elapsed time.

It is intended for reporting the current date and time for humans.

Types

record datetime

A time and date in seconds plus nanoseconds.

Record Fields
  • seconds: u64
  • nanoseconds: u32

Functions

now: func

Read the current value of the clock.

This clock is not monotonic, therefore calling this function repeatedly will not necessarily produce a sequence of non-decreasing values.

The returned timestamps represent the number of seconds since 1970-01-01T00:00:00Z, also known as POSIX's Seconds Since the Epoch, also known as Unix Time.

The nanoseconds field of the output is always less than 1000000000.

Return values

resolution: func

Query the resolution of the clock.

The nanoseconds field of the output is always less than 1000000000.

Return values

Import interface wasi:filesystem/[email protected]

WASI filesystem is a filesystem API primarily intended to let users run WASI programs that access their files on their existing filesystems, without significant overhead.

It is intended to be roughly portable between Unix-family platforms and Windows, though it does not hide many of the major differences.

Paths are passed as interface-type strings, meaning they must consist of a sequence of Unicode Scalar Values (USVs). Some filesystems may contain paths which are not accessible by this API.

The directory separator in WASI is always the forward-slash (/).

All paths in WASI are relative paths, and are interpreted relative to a descriptor referring to a base directory. If a path argument to any WASI function starts with /, or if any step of resolving a path, including .. and symbolic link steps, reaches a directory outside of the base directory, or reaches a symlink to an absolute or rooted path in the underlying filesystem, the function fails with error-code::not-permitted.

For more information about WASI path resolution and sandboxing, see WASI filesystem path resolution.

Types

type input-stream

input-stream

#### `type output-stream` [`output-stream`](#output_stream)

#### `type error` [`error`](#error)

#### `type datetime` [`datetime`](#datetime)

#### `type filesize` `u64`

File size or length of a region within a file.

enum descriptor-type

The type of a filesystem object referenced by a descriptor.

Note: This was called filetype in earlier versions of WASI.

Enum Cases

  • unknown

    The type of the descriptor or file is unknown or is different from any of the other types specified.

  • block-device

    The descriptor refers to a block device inode.

  • character-device

    The descriptor refers to a character device inode.

  • directory

    The descriptor refers to a directory inode.

  • fifo

    The descriptor refers to a named pipe.

  • symbolic-link

    The file refers to a symbolic link inode.

  • regular-file

    The descriptor refers to a regular file inode.

  • socket

    The descriptor refers to a socket.

flags descriptor-flags

Descriptor flags.

Note: This was called fdflags in earlier versions of WASI.

Flags members

  • read:

    Read mode: Data can be read.

  • write:

    Write mode: Data can be written to.

  • file-integrity-sync:

    Request that writes be performed according to synchronized I/O file integrity completion. The data stored in the file and the file's metadata are synchronized. This is similar to `O_SYNC` in POSIX.

    The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.

  • data-integrity-sync:

    Request that writes be performed according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized. This is similar to `O_DSYNC` in POSIX.

    The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.

  • requested-write-sync:

    Requests that reads be performed at the same level of integrity requested for writes. This is similar to `O_RSYNC` in POSIX.

    The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.

  • mutate-directory:

    Mutating directories mode: Directory contents may be mutated.

    When this flag is unset on a descriptor, operations using the descriptor which would create, rename, delete, modify the data or metadata of filesystem objects, or obtain another handle which would permit any of those, shall fail with error-code::read-only if they would otherwise succeed.

    This may only be set on directories.

flags path-flags

Flags determining the method of how paths are resolved.

Flags members
  • symlink-follow:

    As long as the resolved path corresponds to a symbolic link, it is expanded.

flags open-flags

Open flags used by open-at.

Flags members

  • create:

    Create file if it does not exist, similar to `O_CREAT` in POSIX.

  • directory:

    Fail if not a directory, similar to `O_DIRECTORY` in POSIX.

  • exclusive:

    Fail if file already exists, similar to `O_EXCL` in POSIX.

  • truncate:

    Truncate file to size 0, similar to `O_TRUNC` in POSIX.

type link-count

u64

Number of hard links to an inode.

record descriptor-stat

File attributes.

Note: This was called filestat in earlier versions of WASI.

Record Fields

  • type: descriptor-type

    File type.

  • link-count: link-count

    Number of hard links to the file.

  • size: filesize

    For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.

  • data-access-timestamp: option<datetime>

    Last data access timestamp.

    If the option is none, the platform doesn't maintain an access timestamp for this file.

  • data-modification-timestamp: option<datetime>

    Last data modification timestamp.

    If the option is none, the platform doesn't maintain a modification timestamp for this file.

  • status-change-timestamp: option<datetime>

    Last file status-change timestamp.

    If the option is none, the platform doesn't maintain a status-change timestamp for this file.

variant new-timestamp

When setting a timestamp, this gives the value to set it to.

Variant Cases

  • no-change

    Leave the timestamp set to its previous value.

  • now

    Set the timestamp to the current time of the system clock associated with the filesystem.

  • timestamp: datetime

    Set the timestamp to the given value.

record directory-entry

A directory entry.

Record Fields

  • type: descriptor-type

    The type of the file referred to by this directory entry.

  • name: string

    The name of the object.

enum error-code

Error codes returned by functions, similar to errno in POSIX. Not all of these error codes are returned by the functions provided by this API; some are used in higher-level library layers, and others are provided merely for alignment with POSIX.

Enum Cases

  • access

    Permission denied, similar to `EACCES` in POSIX.

  • would-block

    Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.

  • already

    Connection already in progress, similar to `EALREADY` in POSIX.

  • bad-descriptor

    Bad descriptor, similar to `EBADF` in POSIX.

  • busy

    Device or resource busy, similar to `EBUSY` in POSIX.

  • deadlock

    Resource deadlock would occur, similar to `EDEADLK` in POSIX.

  • quota

    Storage quota exceeded, similar to `EDQUOT` in POSIX.

  • exist

    File exists, similar to `EEXIST` in POSIX.

  • file-too-large

    File too large, similar to `EFBIG` in POSIX.

  • illegal-byte-sequence

    Illegal byte sequence, similar to `EILSEQ` in POSIX.

  • in-progress

    Operation in progress, similar to `EINPROGRESS` in POSIX.

  • interrupted

    Interrupted function, similar to `EINTR` in POSIX.

  • invalid

    Invalid argument, similar to `EINVAL` in POSIX.

  • io

    I/O error, similar to `EIO` in POSIX.

  • is-directory

    Is a directory, similar to `EISDIR` in POSIX.

  • loop

    Too many levels of symbolic links, similar to `ELOOP` in POSIX.

  • too-many-links

    Too many links, similar to `EMLINK` in POSIX.

  • message-size

    Message too large, similar to `EMSGSIZE` in POSIX.

  • name-too-long

    Filename too long, similar to `ENAMETOOLONG` in POSIX.

  • no-device

    No such device, similar to `ENODEV` in POSIX.

  • no-entry

    No such file or directory, similar to `ENOENT` in POSIX.

  • no-lock

    No locks available, similar to `ENOLCK` in POSIX.

  • insufficient-memory

    Not enough space, similar to `ENOMEM` in POSIX.

  • insufficient-space

    No space left on device, similar to `ENOSPC` in POSIX.

  • not-directory

    Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.

  • not-empty

    Directory not empty, similar to `ENOTEMPTY` in POSIX.

  • not-recoverable

    State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.

  • unsupported

    Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.

  • no-tty

    Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.

  • no-such-device

    No such device or address, similar to `ENXIO` in POSIX.

  • overflow

    Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.

  • not-permitted

    Operation not permitted, similar to `EPERM` in POSIX.

  • pipe

    Broken pipe, similar to `EPIPE` in POSIX.

  • read-only

    Read-only file system, similar to `EROFS` in POSIX.

  • invalid-seek

    Invalid seek, similar to `ESPIPE` in POSIX.

  • text-file-busy

    Text file busy, similar to `ETXTBSY` in POSIX.

  • cross-device

    Cross-device link, similar to `EXDEV` in POSIX.

enum advice

File or memory access pattern advisory information.

Enum Cases

  • normal

    The application has no advice to give on its behavior with respect to the specified data.

  • sequential

    The application expects to access the specified data sequentially from lower offsets to higher offsets.

  • random

    The application expects to access the specified data in a random order.

  • will-need

    The application expects to access the specified data in the near future.

  • dont-need

    The application expects that it will not access the specified data in the near future.

  • no-reuse

    The application expects to access the specified data once and then not reuse it thereafter.

record metadata-hash-value

A 128-bit hash value, split into parts because wasm doesn't have a 128-bit integer type.

Record Fields

  • lower: u64

    64 bits of a 128-bit hash value.

  • upper: u64

    Another 64 bits of a 128-bit hash value.

resource descriptor

A descriptor is a reference to a filesystem object, which may be a file, directory, named pipe, special file, or other object on which filesystem calls may be made.

resource directory-entry-stream

A stream of directory entries.

Functions

[method]descriptor.read-via-stream: func

Return a stream for reading from a file, if available.

May fail with an error-code describing why the file cannot be read.

Multiple read, write, and append streams may be active on the same open file and they do not interfere with each other.

Note: This allows using read-stream, which is similar to read in POSIX.

Params
Return values

[method]descriptor.write-via-stream: func

Return a stream for writing to a file, if available.

May fail with an error-code describing why the file cannot be written.

Note: This allows using write-stream, which is similar to write in POSIX.

Params
Return values

[method]descriptor.append-via-stream: func

Return a stream for appending to a file, if available.

May fail with an error-code describing why the file cannot be appended.

Note: This allows using write-stream, which is similar to write with O_APPEND in POSIX.

Params
Return values

[method]descriptor.advise: func

Provide file advisory information on a descriptor.

This is similar to posix_fadvise in POSIX.

Params
Return values

[method]descriptor.sync-data: func

Synchronize the data of a file to disk.

This function succeeds with no effect if the file descriptor is not opened for writing.

Note: This is similar to fdatasync in POSIX.

Params
Return values

[method]descriptor.get-flags: func

Get flags associated with a descriptor.

Note: This returns similar flags to fcntl(fd, F_GETFL) in POSIX.

Note: This returns the value that was the fs_flags value returned from fdstat_get in earlier versions of WASI.

Params
Return values

[method]descriptor.get-type: func

Get the dynamic type of a descriptor.

Note: This returns the same value as the type field of the fd-stat returned by stat, stat-at and similar.

Note: This returns similar flags to the st_mode & S_IFMT value provided by fstat in POSIX.

Note: This returns the value that was the fs_filetype value returned from fdstat_get in earlier versions of WASI.

Params
Return values

[method]descriptor.set-size: func

Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.

Note: This was called fd_filestat_set_size in earlier versions of WASI.

Params
Return values

[method]descriptor.set-times: func

Adjust the timestamps of an open file or directory.

Note: This is similar to futimens in POSIX.

Note: This was called fd_filestat_set_times in earlier versions of WASI.

Params
Return values

[method]descriptor.read: func

Read from a descriptor, without using and updating the descriptor's offset.

This function returns a list of bytes containing the data that was read, along with a bool which, when true, indicates that the end of the file was reached. The returned list will contain up to length bytes; it may return fewer than requested, if the end of the file is reached or if the I/O operation is interrupted.

In the future, this may change to return a stream<u8, error-code>.

Note: This is similar to pread in POSIX.

Params
Return values

[method]descriptor.write: func

Write to a descriptor, without using and updating the descriptor's offset.

It is valid to write past the end of a file; the file is extended to the extent of the write, with bytes between the previous end and the start of the write set to zero.

In the future, this may change to take a stream<u8, error-code>.

Note: This is similar to pwrite in POSIX.

Params
Return values

[method]descriptor.read-directory: func

Read directory entries from a directory.

On filesystems where directories contain entries referring to themselves and their parents, often named . and .. respectively, these entries are omitted.

This always returns a new stream which starts at the beginning of the directory. Multiple streams may be active on the same directory, and they do not interfere with each other.

Params
Return values

[method]descriptor.sync: func

Synchronize the data and metadata of a file to disk.

This function succeeds with no effect if the file descriptor is not opened for writing.

Note: This is similar to fsync in POSIX.

Params
Return values

[method]descriptor.create-directory-at: func

Create a directory.

Note: This is similar to mkdirat in POSIX.

Params
Return values

[method]descriptor.stat: func

Return the attributes of an open file or directory.

Note: This is similar to fstat in POSIX, except that it does not return device and inode information. For testing whether two descriptors refer to the same underlying filesystem object, use is-same-object. To obtain additional data that can be used do determine whether a file has been modified, use metadata-hash.

Note: This was called fd_filestat_get in earlier versions of WASI.

Params
Return values

[method]descriptor.stat-at: func

Return the attributes of a file or directory.

Note: This is similar to fstatat in POSIX, except that it does not return device and inode information. See the stat description for a discussion of alternatives.

Note: This was called path_filestat_get in earlier versions of WASI.

Params
Return values

[method]descriptor.set-times-at: func

Adjust the timestamps of a file or directory.

Note: This is similar to utimensat in POSIX.

Note: This was called path_filestat_set_times in earlier versions of WASI.

Params
Return values

[method]descriptor.link-at: func

Create a hard link.

Note: This is similar to linkat in POSIX.

Params
Return values

[method]descriptor.open-at: func

Open a file or directory.

If flags contains descriptor-flags::mutate-directory, and the base descriptor doesn't have descriptor-flags::mutate-directory set, open-at fails with error-code::read-only.

If flags contains write or mutate-directory, or open-flags contains truncate or create, and the base descriptor doesn't have descriptor-flags::mutate-directory set, open-at fails with error-code::read-only.

Note: This is similar to openat in POSIX.

Params
Return values

[method]descriptor.readlink-at: func

Read the contents of a symbolic link.

If the contents contain an absolute or rooted path in the underlying filesystem, this function fails with error-code::not-permitted.

Note: This is similar to readlinkat in POSIX.

Params
Return values

[method]descriptor.remove-directory-at: func

Remove a directory.

Return error-code::not-empty if the directory is not empty.

Note: This is similar to unlinkat(fd, path, AT_REMOVEDIR) in POSIX.

Params
Return values

[method]descriptor.rename-at: func

Rename a filesystem object.

Note: This is similar to renameat in POSIX.

Params
Return values

[method]descriptor.symlink-at: func

Create a symbolic link (also known as a "symlink").

If old-path starts with /, the function fails with error-code::not-permitted.

Note: This is similar to symlinkat in POSIX.

Params
  • self: borrow<descriptor>
  • old-path: string
  • new-path: string
Return values

[method]descriptor.unlink-file-at: func

Unlink a filesystem object that is not a directory.

Return error-code::is-directory if the path refers to a directory. Note: This is similar to unlinkat(fd, path, 0) in POSIX.

Params
Return values

[method]descriptor.is-same-object: func

Test whether two descriptors refer to the same filesystem object.

In POSIX, this corresponds to testing whether the two descriptors have the same device (st_dev) and inode (st_ino or d_ino) numbers. wasi-filesystem does not expose device and inode numbers, so this function may be used instead.

Params
Return values
  • bool

[method]descriptor.metadata-hash: func

Return a hash of the metadata associated with a filesystem object referred to by a descriptor.

This returns a hash of the last-modification timestamp and file size, and may also include the inode number, device number, birth timestamp, and other metadata fields that may change when the file is modified or replaced. It may also include a secret value chosen by the implementation and not otherwise exposed.

Implementations are encouraged to provide the following properties:

  • If the file is not modified or replaced, the computed hash value should usually not change.
  • If the object is modified or replaced, the computed hash value should usually change.
  • The inputs to the hash should not be easily computable from the computed hash.

However, none of these is required.

Params
Return values

[method]descriptor.metadata-hash-at: func

Return a hash of the metadata associated with a filesystem object referred to by a directory descriptor and a relative path.

This performs the same hash computation as metadata-hash.

Params
Return values

[method]directory-entry-stream.read-directory-entry: func

Read a single directory entry from a directory-entry-stream.

Params
Return values

filesystem-error-code: func

Attempts to extract a filesystem-related error-code from the stream error provided.

Stream operations which return stream-error::last-operation-failed have a payload with more information about the operation that failed. This payload can be passed through to this function to see if there's filesystem-related information about the error to return.

Note that this function is fallible because not all stream-related errors are filesystem-related errors.

Params
Return values

Import interface wasi:filesystem/[email protected]

Types

type descriptor

descriptor

----

Functions

get-directories: func

Return the set of preopened directories, and their paths.

Return values

Import interface wasi:sockets/[email protected]

Types

resource network

An opaque resource that represents access to (a subset of) the network. This enables context-based security for networking. There is no need for this to map 1:1 to a physical network interface.

enum error-code

Error codes.

In theory, every API can return any error code. In practice, API's typically only return the errors documented per API combined with a couple of errors that are always possible:

  • unknown
  • access-denied
  • not-supported
  • out-of-memory
  • concurrency-conflict

See each individual API for what the POSIX equivalents are. They sometimes differ per API.

Enum Cases

  • unknown

    Unknown error

  • access-denied

    Access denied.

    POSIX equivalent: EACCES, EPERM

  • not-supported

    The operation is not supported.

    POSIX equivalent: EOPNOTSUPP

  • invalid-argument

    One of the arguments is invalid.

    POSIX equivalent: EINVAL

  • out-of-memory

    Not enough memory to complete the operation.

    POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY

  • timeout

    The operation timed out before it could finish completely.

  • concurrency-conflict

    This operation is incompatible with another asynchronous operation that is already in progress.

    POSIX equivalent: EALREADY

  • not-in-progress

    Trying to finish an asynchronous operation that: - has not been started yet, or: - was already finished by a previous `finish-*` call.

    Note: this is scheduled to be removed when futures are natively supported.

  • would-block

    The operation has been aborted because it could not be completed immediately.

    Note: this is scheduled to be removed when futures are natively supported.

  • invalid-state

    The operation is not valid in the socket's current state.

  • new-socket-limit

    A new socket resource could not be created because of a system limit.

  • address-not-bindable

    A bind operation failed because the provided address is not an address that the `network` can bind to.

  • address-in-use

    A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.

  • remote-unreachable

    The remote address is not reachable

  • connection-refused

    The TCP connection was forcefully rejected

  • connection-reset

    The TCP connection was reset.

  • connection-aborted

    A TCP connection was aborted.

  • datagram-too-large

    The size of a datagram sent to a UDP socket exceeded the maximum supported size.

  • name-unresolvable

    Name does not exist or has no suitable associated IP addresses.

  • temporary-resolver-failure

    A temporary failure in name resolution occurred.

  • permanent-resolver-failure

    A permanent failure in name resolution occurred.

enum ip-address-family

Enum Cases

  • ipv4

    Similar to `AF_INET` in POSIX.

  • ipv6

    Similar to `AF_INET6` in POSIX.

tuple ipv4-address

Tuple Fields
  • 0: u8
  • 1: u8
  • 2: u8
  • 3: u8

tuple ipv6-address

Tuple Fields
  • 0: u16
  • 1: u16
  • 2: u16
  • 3: u16
  • 4: u16
  • 5: u16
  • 6: u16
  • 7: u16

variant ip-address

Variant Cases

record ipv4-socket-address

Record Fields

record ipv6-socket-address

Record Fields

  • port: u16

    sin6_port

  • flow-info: u32

    sin6_flowinfo

  • address: ipv6-address

    sin6_addr

  • scope-id: u32

    sin6_scope_id

variant ip-socket-address

Variant Cases

Import interface wasi:sockets/[email protected]

This interface provides a value-export of the default network handle..

Types

type network

network

----

Functions

instance-network: func

Get a handle to the default network.

Return values

Import interface wasi:sockets/[email protected]

Types

type pollable

pollable

#### `type network` [`network`](#network)

#### `type error-code` [`error-code`](#error_code)

#### `type ip-socket-address` [`ip-socket-address`](#ip_socket_address)

#### `type ip-address-family` [`ip-address-family`](#ip_address_family)

#### `record incoming-datagram`

A received datagram.

Record Fields

  • data: list<u8>

    The payload.

    Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.

  • remote-address: ip-socket-address

    The source address.

    This field is guaranteed to match the remote address the stream was initialized with, if any.

    Equivalent to the src_addr out parameter of recvfrom.

record outgoing-datagram

A datagram to be sent out.

Record Fields

  • data: list<u8>

    The payload.

  • remote-address: option<ip-socket-address>

    The destination address.

    The requirements on this field depend on how the stream was initialized:

    • with a remote address: this field must be None or match the stream's remote address exactly.
    • without a remote address: this field is required.

    If this value is None, the send operation is equivalent to send in POSIX. Otherwise it is equivalent to sendto.

resource udp-socket

A UDP socket handle.

resource incoming-datagram-stream

resource outgoing-datagram-stream

Functions

[method]udp-socket.start-bind: func

Bind the socket to a specific network on the provided IP address and port.

If the IP address is zero (0.0.0.0 in IPv4, :: in IPv6), it is left to the implementation to decide which network interface(s) to bind to. If the port is zero, the socket will be bound to a random free port.

Typical errors

  • invalid-argument: The local-address has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
  • invalid-state: The socket is already bound. (EINVAL)
  • address-in-use: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
  • address-in-use: Address is already in use. (EADDRINUSE)
  • address-not-bindable: local-address is not an address that the network can bind to. (EADDRNOTAVAIL)
  • not-in-progress: A bind operation is not in progress.
  • would-block: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)

Implementors note

Unlike in POSIX, in WASI the bind operation is async. This enables interactive WASI hosts to inject permission prompts. Runtimes that don't want to make use of this ability can simply call the native bind as part of either start-bind or finish-bind.

References

Params
Return values

[method]udp-socket.finish-bind: func

Params
Return values

[method]udp-socket.stream: func

Set up inbound & outbound communication channels, optionally to a specific peer.

This function only changes the local socket configuration and does not generate any network traffic. On success, the remote-address of the socket is updated. The local-address may be updated as well, based on the best network path to remote-address.

When a remote-address is provided, the returned streams are limited to communicating with that specific peer:

  • send can only be used to send to this destination.
  • receive will only return datagrams sent from the provided remote-address.

This method may be called multiple times on the same socket to change its association, but only the most recently returned pair of streams will be operational. Implementations may trap if the streams returned by a previous invocation haven't been dropped yet before calling stream again.

The POSIX equivalent in pseudo-code is:

if (was previously connected) {
  connect(s, AF_UNSPEC)
}
if (remote_address is Some) {
  connect(s, remote_address)
}

Unlike in POSIX, the socket must already be explicitly bound.

Typical errors

  • invalid-argument: The remote-address has the wrong address family. (EAFNOSUPPORT)
  • invalid-argument: The IP address in remote-address is set to INADDR_ANY (0.0.0.0 / ::). (EDESTADDRREQ, EADDRNOTAVAIL)
  • invalid-argument: The port in remote-address is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
  • invalid-state: The socket is not bound.
  • address-in-use: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
  • remote-unreachable: The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
  • connection-refused: The connection was refused. (ECONNREFUSED)

References

Params
Return values

[method]udp-socket.local-address: func

Get the current bound address.

POSIX mentions:

If the socket has not been bound to a local name, the value stored in the object pointed to by address is unspecified.

WASI is stricter and requires local-address to return invalid-state when the socket hasn't been bound yet.

Typical errors

  • invalid-state: The socket is not bound to any local address.

References

Params
Return values

[method]udp-socket.remote-address: func

Get the address the socket is currently streaming to.

Typical errors

  • invalid-state: The socket is not streaming to a specific remote address. (ENOTCONN)

References

Params
Return values

[method]udp-socket.address-family: func

Whether this is a IPv4 or IPv6 socket.

Equivalent to the SO_DOMAIN socket option.

Params
Return values

[method]udp-socket.unicast-hop-limit: func

Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.

If the provided value is 0, an invalid-argument error is returned.

Typical errors

  • invalid-argument: (set) The TTL value must be 1 or higher.
Params
Return values

[method]udp-socket.set-unicast-hop-limit: func

Params
Return values

[method]udp-socket.receive-buffer-size: func

The kernel buffer space reserved for sends/receives on this socket.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded. I.e. after setting a value, reading the same setting back may return a different value.

Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.

Typical errors

  • invalid-argument: (set) The provided value was 0.
Params
Return values

[method]udp-socket.set-receive-buffer-size: func

Params
Return values

[method]udp-socket.send-buffer-size: func

Params
Return values

[method]udp-socket.set-send-buffer-size: func

Params
Return values

[method]udp-socket.subscribe: func

Create a pollable which will resolve once the socket is ready for I/O.

Note: this function is here for WASI 0.2 only. It's planned to be removed when future is natively supported in Preview3.

Params
Return values

[method]incoming-datagram-stream.receive: func

Receive messages on the socket.

This function attempts to receive up to max-results datagrams on the socket without blocking. The returned list may contain fewer elements than requested, but never more.

This function returns successfully with an empty list when either:

  • max-results is 0, or:
  • max-results is greater than 0, but no results are immediately available. This function never returns error(would-block).

Typical errors

  • remote-unreachable: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
  • connection-refused: The connection was refused. (ECONNREFUSED)

References

Params
Return values

[method]incoming-datagram-stream.subscribe: func

Create a pollable which will resolve once the stream is ready to receive again.

Note: this function is here for WASI 0.2 only. It's planned to be removed when future is natively supported in Preview3.

Params
Return values

[method]outgoing-datagram-stream.check-send: func

Check readiness for sending. This function never blocks.

Returns the number of datagrams permitted for the next call to send, or an error. Calling send with more datagrams than this function has permitted will trap.

When this function returns ok(0), the subscribe pollable will become ready when this function will report at least ok(1), or an error.

Never returns would-block.

Params
Return values

[method]outgoing-datagram-stream.send: func

Send messages on the socket.

This function attempts to send all provided datagrams on the socket without blocking and returns how many messages were actually sent (or queued for sending). This function never returns error(would-block). If none of the datagrams were able to be sent, ok(0) is returned.

This function semantically behaves the same as iterating the datagrams list and sequentially sending each individual datagram until either the end of the list has been reached or the first error occurred. If at least one datagram has been sent successfully, this function never returns an error.

If the input list is empty, the function returns ok(0).

Each call to send must be permitted by a preceding check-send. Implementations must trap if either check-send was not called or datagrams contains more items than check-send permitted.

Typical errors

  • invalid-argument: The remote-address has the wrong address family. (EAFNOSUPPORT)
  • invalid-argument: The IP address in remote-address is set to INADDR_ANY (0.0.0.0 / ::). (EDESTADDRREQ, EADDRNOTAVAIL)
  • invalid-argument: The port in remote-address is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
  • invalid-argument: The socket is in "connected" mode and remote-address is some value that does not match the address passed to stream. (EISCONN)
  • invalid-argument: The socket is not "connected" and no value for remote-address was provided. (EDESTADDRREQ)
  • remote-unreachable: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
  • connection-refused: The connection was refused. (ECONNREFUSED)
  • datagram-too-large: The datagram is too large. (EMSGSIZE)

References

Params
Return values

[method]outgoing-datagram-stream.subscribe: func

Create a pollable which will resolve once the stream is ready to send again.

Note: this function is here for WASI 0.2 only. It's planned to be removed when future is natively supported in Preview3.

Params
Return values

Import interface wasi:sockets/[email protected]

Types

type network

network

#### `type error-code` [`error-code`](#error_code)

#### `type ip-address-family` [`ip-address-family`](#ip_address_family)

#### `type udp-socket` [`udp-socket`](#udp_socket)

----

Functions

create-udp-socket: func

Create a new UDP socket.

Similar to socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP) in POSIX. On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.

This function does not require a network capability handle. This is considered to be safe because at time of creation, the socket is not bound to any network yet. Up to the moment bind is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.

All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.

Typical errors

  • not-supported: The specified address-family is not supported. (EAFNOSUPPORT)
  • new-socket-limit: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)

References:

Params
Return values

Import interface wasi:sockets/[email protected]

Types

type input-stream

input-stream

#### `type output-stream` [`output-stream`](#output_stream)

#### `type pollable` [`pollable`](#pollable)

#### `type duration` [`duration`](#duration)

#### `type network` [`network`](#network)

#### `type error-code` [`error-code`](#error_code)

#### `type ip-socket-address` [`ip-socket-address`](#ip_socket_address)

#### `type ip-address-family` [`ip-address-family`](#ip_address_family)

#### `enum shutdown-type`

Enum Cases

  • receive

    Similar to `SHUT_RD` in POSIX.

  • send

    Similar to `SHUT_WR` in POSIX.

  • both

    Similar to `SHUT_RDWR` in POSIX.

resource tcp-socket

A TCP socket resource.

The socket can be in one of the following states:

Note: Except where explicitly mentioned, whenever this documentation uses the term "bound" without backticks it actually means: in the bound state or higher. (i.e. bound, listen-in-progress, listening, connect-in-progress or connected)

In addition to the general error codes documented on the network::error-code type, TCP socket methods may always return error(invalid-state) when in the closed state.

Functions

[method]tcp-socket.start-bind: func

Bind the socket to a specific network on the provided IP address and port.

If the IP address is zero (0.0.0.0 in IPv4, :: in IPv6), it is left to the implementation to decide which network interface(s) to bind to. If the TCP/UDP port is zero, the socket will be bound to a random free port.

Bind can be attempted multiple times on the same socket, even with different arguments on each iteration. But never concurrently and only as long as the previous bind failed. Once a bind succeeds, the binding can't be changed anymore.

Typical errors

  • invalid-argument: The local-address has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
  • invalid-argument: local-address is not a unicast address. (EINVAL)
  • invalid-argument: local-address is an IPv4-mapped IPv6 address. (EINVAL)
  • invalid-state: The socket is already bound. (EINVAL)
  • address-in-use: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
  • address-in-use: Address is already in use. (EADDRINUSE)
  • address-not-bindable: local-address is not an address that the network can bind to. (EADDRNOTAVAIL)
  • not-in-progress: A bind operation is not in progress.
  • would-block: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)

Implementors note

When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR socket option should be set implicitly on all platforms, except on Windows where this is the default behavior and SO_REUSEADDR performs something different entirely.

Unlike in POSIX, in WASI the bind operation is async. This enables interactive WASI hosts to inject permission prompts. Runtimes that don't want to make use of this ability can simply call the native bind as part of either start-bind or finish-bind.

References

Params
Return values

[method]tcp-socket.finish-bind: func

Params
Return values

[method]tcp-socket.start-connect: func

Connect to a remote endpoint.

On success:

  • the socket is transitioned into the connected state.
  • a pair of streams is returned that can be used to read & write to the connection

After a failed connection attempt, the socket will be in the closed state and the only valid action left is to drop the socket. A single socket can not be used to connect more than once.

Typical errors

  • invalid-argument: The remote-address has the wrong address family. (EAFNOSUPPORT)
  • invalid-argument: remote-address is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
  • invalid-argument: remote-address is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
  • invalid-argument: The IP address in remote-address is set to INADDR_ANY (0.0.0.0 / ::). (EADDRNOTAVAIL on Windows)
  • invalid-argument: The port in remote-address is set to 0. (EADDRNOTAVAIL on Windows)
  • invalid-argument: The socket is already attached to a different network. The network passed to connect must be identical to the one passed to bind.
  • invalid-state: The socket is already in the connected state. (EISCONN)
  • invalid-state: The socket is already in the listening state. (EOPNOTSUPP, EINVAL on Windows)
  • timeout: Connection timed out. (ETIMEDOUT)
  • connection-refused: The connection was forcefully rejected. (ECONNREFUSED)
  • connection-reset: The connection was reset. (ECONNRESET)
  • connection-aborted: The connection was aborted. (ECONNABORTED)
  • remote-unreachable: The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
  • address-in-use: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
  • not-in-progress: A connect operation is not in progress.
  • would-block: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)

Implementors note

The POSIX equivalent of start-connect is the regular connect syscall. Because all WASI sockets are non-blocking this is expected to return EINPROGRESS, which should be translated to ok() in WASI.

The POSIX equivalent of finish-connect is a poll for event POLLOUT with a timeout of 0 on the socket descriptor. Followed by a check for the SO_ERROR socket option, in case the poll signaled readiness.

References

Params
Return values

[method]tcp-socket.finish-connect: func

Params
Return values

[method]tcp-socket.start-listen: func

Start listening for new connections.

Transitions the socket into the listening state.

Unlike POSIX, the socket must already be explicitly bound.

Typical errors

  • invalid-state: The socket is not bound to any local address. (EDESTADDRREQ)
  • invalid-state: The socket is already in the connected state. (EISCONN, EINVAL on BSD)
  • invalid-state: The socket is already in the listening state.
  • address-in-use: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
  • not-in-progress: A listen operation is not in progress.
  • would-block: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)

Implementors note

Unlike in POSIX, in WASI the listen operation is async. This enables interactive WASI hosts to inject permission prompts. Runtimes that don't want to make use of this ability can simply call the native listen as part of either start-listen or finish-listen.

References

Params
Return values

[method]tcp-socket.finish-listen: func

Params
Return values

[method]tcp-socket.accept: func

Accept a new client socket.

The returned socket is bound and in the connected state. The following properties are inherited from the listener socket:

  • address-family
  • keep-alive-enabled
  • keep-alive-idle-time
  • keep-alive-interval
  • keep-alive-count
  • hop-limit
  • receive-buffer-size
  • send-buffer-size

On success, this function returns the newly accepted client socket along with a pair of streams that can be used to read & write to the connection.

Typical errors

  • invalid-state: Socket is not in the listening state. (EINVAL)
  • would-block: No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
  • connection-aborted: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED)
  • new-socket-limit: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)

References

Params
Return values

[method]tcp-socket.local-address: func

Get the bound local address.

POSIX mentions:

If the socket has not been bound to a local name, the value stored in the object pointed to by address is unspecified.

WASI is stricter and requires local-address to return invalid-state when the socket hasn't been bound yet.

Typical errors

  • invalid-state: The socket is not bound to any local address.

References

Params
Return values

[method]tcp-socket.remote-address: func

Get the remote address.

Typical errors

  • invalid-state: The socket is not connected to a remote address. (ENOTCONN)

References

Params
Return values

[method]tcp-socket.is-listening: func

Whether the socket is in the listening state.

Equivalent to the SO_ACCEPTCONN socket option.

Params
Return values
  • bool

[method]tcp-socket.address-family: func

Whether this is a IPv4 or IPv6 socket.

Equivalent to the SO_DOMAIN socket option.

Params
Return values

[method]tcp-socket.set-listen-backlog-size: func

Hints the desired listen queue size. Implementations are free to ignore this.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded.

Typical errors

  • not-supported: (set) The platform does not support changing the backlog size after the initial listen.
  • invalid-argument: (set) The provided value was 0.
  • invalid-state: (set) The socket is in the connect-in-progress or connected state.
Params
Return values

[method]tcp-socket.keep-alive-enabled: func

Enables or disables keepalive.

The keepalive behavior can be adjusted using:

  • keep-alive-idle-time
  • keep-alive-interval
  • keep-alive-count These properties can be configured while keep-alive-enabled is false, but only come into effect when keep-alive-enabled is true.

Equivalent to the SO_KEEPALIVE socket option.

Params
Return values

[method]tcp-socket.set-keep-alive-enabled: func

Params
Return values

[method]tcp-socket.keep-alive-idle-time: func

Amount of time the connection has to be idle before TCP starts sending keepalive packets.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded. I.e. after setting a value, reading the same setting back may return a different value.

Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)

Typical errors

  • invalid-argument: (set) The provided value was 0.
Params
Return values

[method]tcp-socket.set-keep-alive-idle-time: func

Params
Return values

[method]tcp-socket.keep-alive-interval: func

The time between keepalive packets.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded. I.e. after setting a value, reading the same setting back may return a different value.

Equivalent to the TCP_KEEPINTVL socket option.

Typical errors

  • invalid-argument: (set) The provided value was 0.
Params
Return values

[method]tcp-socket.set-keep-alive-interval: func

Params
Return values

[method]tcp-socket.keep-alive-count: func

The maximum amount of keepalive packets TCP should send before aborting the connection.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded. I.e. after setting a value, reading the same setting back may return a different value.

Equivalent to the TCP_KEEPCNT socket option.

Typical errors

  • invalid-argument: (set) The provided value was 0.
Params
Return values

[method]tcp-socket.set-keep-alive-count: func

Params
Return values

[method]tcp-socket.hop-limit: func

Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.

If the provided value is 0, an invalid-argument error is returned.

Typical errors

  • invalid-argument: (set) The TTL value must be 1 or higher.
Params
Return values

[method]tcp-socket.set-hop-limit: func

Params
Return values

[method]tcp-socket.receive-buffer-size: func

The kernel buffer space reserved for sends/receives on this socket.

If the provided value is 0, an invalid-argument error is returned. Any other value will never cause an error, but it might be silently clamped and/or rounded. I.e. after setting a value, reading the same setting back may return a different value.

Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.

Typical errors

  • invalid-argument: (set) The provided value was 0.
Params
Return values

[method]tcp-socket.set-receive-buffer-size: func

Params
Return values

[method]tcp-socket.send-buffer-size: func

Params
Return values

[method]tcp-socket.set-send-buffer-size: func

Params
Return values

[method]tcp-socket.subscribe: func

Create a pollable which can be used to poll for, or block on, completion of any of the asynchronous operations of this socket.

When finish-bind, finish-listen, finish-connect or accept return error(would-block), this pollable can be used to wait for their success or failure, after which the method can be retried.

The pollable is not limited to the async operation that happens to be in progress at the time of calling subscribe (if any). Theoretically, subscribe only has to be called once per socket and can then be (re)used for the remainder of the socket's lifetime.

See https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md#pollable-readiness for more information.

Note: this function is here for WASI 0.2 only. It's planned to be removed when future is natively supported in Preview3.

Params
Return values

[method]tcp-socket.shutdown: func

Initiate a graceful shutdown.

  • receive: The socket is not expecting to receive any data from the peer. The input-stream associated with this socket will be closed. Any data still in the receive queue at time of calling this method will be discarded.
  • send: The socket has no more data to send to the peer. The output-stream associated with this socket will be closed and a FIN packet will be sent.
  • both: Same effect as receive & send combined.

This function is idempotent; shutting down a direction more than once has no effect and returns ok.

The shutdown function does not close (drop) the socket.

Typical errors

  • invalid-state: The socket is not in the connected state. (ENOTCONN)

References

Params
Return values

Import interface wasi:sockets/[email protected]

Types

type network

network

#### `type error-code` [`error-code`](#error_code)

#### `type ip-address-family` [`ip-address-family`](#ip_address_family)

#### `type tcp-socket` [`tcp-socket`](#tcp_socket)

----

Functions

create-tcp-socket: func

Create a new TCP socket.

Similar to socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP) in POSIX. On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.

This function does not require a network capability handle. This is considered to be safe because at time of creation, the socket is not bound to any network yet. Up to the moment bind/connect is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.

All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.

Typical errors

  • not-supported: The specified address-family is not supported. (EAFNOSUPPORT)
  • new-socket-limit: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)

References

Params
Return values

Import interface wasi:sockets/[email protected]

Types

type pollable

pollable

#### `type network` [`network`](#network)

#### `type error-code` [`error-code`](#error_code)

#### `type ip-address` [`ip-address`](#ip_address)

#### `resource resolve-address-stream`

Functions

resolve-addresses: func

Resolve an internet host name to a list of IP addresses.

Unicode domain names are automatically converted to ASCII using IDNA encoding. If the input is an IP address string, the address is parsed and returned as-is without making any external requests.

See the wasi-socket proposal README.md for a comparison with getaddrinfo.

This function never blocks. It either immediately fails or immediately returns successfully with a resolve-address-stream that can be used to (asynchronously) fetch the results.

Typical errors

  • invalid-argument: name is a syntactically invalid domain name or IP address.

References:

Params
Return values

[method]resolve-address-stream.resolve-next-address: func

Returns the next address from the resolver.

This function should be called multiple times. On each call, it will return the next address in connection order preference. If all addresses have been exhausted, this function returns none.

This function never returns IPv4-mapped IPv6 addresses.

Typical errors

  • name-unresolvable: Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
  • temporary-resolver-failure: A temporary failure in name resolution occurred. (EAI_AGAIN)
  • permanent-resolver-failure: A permanent failure in name resolution occurred. (EAI_FAIL)
  • would-block: A result is not available yet. (EWOULDBLOCK, EAGAIN)
Params
Return values

[method]resolve-address-stream.subscribe: func

Create a pollable which will resolve once the stream is ready for I/O.

Note: this function is here for WASI 0.2 only. It's planned to be removed when future is natively supported in Preview3.

Params
Return values

Import interface wasi:random/[email protected]

WASI Random is a random data API.

It is intended to be portable at least between Unix-family platforms and Windows.

Functions

get-random-bytes: func

Return len cryptographically-secure random or pseudo-random bytes.

This function must produce data at least as cryptographically secure and fast as an adequately seeded cryptographically-secure pseudo-random number generator (CSPRNG). It must not block, from the perspective of the calling program, under any circumstances, including on the first request and on requests for numbers of bytes. The returned data must always be unpredictable.

This function must always return fresh data. Deterministic environments must omit this function, rather than implementing it with deterministic data.

Params
  • len: u64
Return values
  • list<u8>

get-random-u64: func

Return a cryptographically-secure random or pseudo-random u64 value.

This function returns the same type of data as get-random-bytes, represented as a u64.

Return values
  • u64

Import interface wasi:random/[email protected]

The insecure interface for insecure pseudo-random numbers.

It is intended to be portable at least between Unix-family platforms and Windows.

Functions

get-insecure-random-bytes: func

Return len insecure pseudo-random bytes.

This function is not cryptographically secure. Do not use it for anything related to security.

There are no requirements on the values of the returned bytes, however implementations are encouraged to return evenly distributed values with a long period.

Params
  • len: u64
Return values
  • list<u8>

get-insecure-random-u64: func

Return an insecure pseudo-random u64 value.

This function returns the same type of pseudo-random data as get-insecure-random-bytes, represented as a u64.

Return values
  • u64

Import interface wasi:random/[email protected]

The insecure-seed interface for seeding hash-map DoS resistance.

It is intended to be portable at least between Unix-family platforms and Windows.

Functions

insecure-seed: func

Return a 128-bit value that may contain a pseudo-random value.

The returned value is not required to be computed from a CSPRNG, and may even be entirely deterministic. Host implementations are encouraged to provide pseudo-random values to any program exposed to attacker-controlled content, to enable DoS protection built into many languages' hash-map implementations.

This function is intended to only be called once, by a source language to initialize Denial Of Service (DoS) protection in its hash-map implementation.

Expected future evolution

This will likely be changed to a value import, to prevent it from being called multiple times and potentially used for purposes other than DoS protection.

Return values
  • (u64, u64)