type socket[link]

type socket = io::file;

A network socket.

type sockflags[link]

type sockflags = enum {
	NOCLOEXEC = rt::SOCK_CLOEXEC,
	NONBLOCK = rt::SOCK_NONBLOCK,

};

Optional flags to accept to be set on the returned socket. See the O_CLOEXEC and O_NONBLOCK sections of open(2) for details. Note that CLOEXEC is on by default, and NOCLOEXEC flag disables it.

type msghdr[link]

type msghdr = struct {
	native: rt::msghdr,
	vectors: []rt::iovec,
	control: []u8,
};

type error[link]

type error = !(unknownproto | ...errors::error);

All error types which can be returned from networking functions.

type unknownproto[link]

type unknownproto = !void;

An attempt was made to use an unsupported protocol.

fn accept[link]

fn accept(sock: socket, flags: sockflags...) (socket | error);

Accepts the next connection from a socket. Blocks until a new connection is available. Optionally accepts NOCLOEXEC and NONBLOCK flags. If flags are supplied, the io::file returned will have the supplied flags set.

fn addcontrol[link]

fn addcontrol(msg: *msghdr, length: size, level: int, ctype: int) []u8;

Adds a control message of the desired length to a msghdr, returning a buffer in which the ancillary data may be written in a domain-specific format.

This is a low-level interface, and is not generally used by users. More often, users will call functions like net::unix::addfiles or net::unix::prepfiles, which provide a high-level interface to this function for domain-specific use-cases.

fn addvector[link]

fn addvector(msg: *msghdr, vec: []u8) void;

Adds an I/O vector to the message.

fn close[link]

fn close(sock: socket) (void | error);

Closes a socket. No further operations against this socket are permitted after calling this function. Closing a socket can fail only under certain conditions (for example, closing a socket twice, or an interrupted syscall). However, the user should not attempt to close the file again on failure - at best the user should print a diagnostic message and move on. See close(2) for details.

On Linux, this function is an alias for io::close.

fn finish[link]

fn finish(msg: *msghdr) void;

Frees resources associated with a msghdr.

fn getcontrol[link]

fn getcontrol(msg: *msghdr, length: size, level: int, ctype: int) ([]u8 | void);

Retrieves a control header from a message, returning a slice of domain-specific data.

This is a low-level interface, and is not generally used by users. More often, users will call functions like net::unix::addfiles or net::unix::prepfiles, which provide a high-level interface to this function for domain-specific use-cases.

fn newmsg[link]

fn newmsg() msghdr;

Creates a new message header for advanced socket usage, with configurable I/O vectors, control messages, and other details, for use with sendmsg and recvmsg.

The user must call finish when they are done using this message for sending or receiving. The same message may be used for multiple operations before calling finish. reset may be used to "reset" a msghdr to an empty list of I/O vectors and control messages without freeing the underlying memory, which may be useful if future messages are expected to have similar characteristics.

fn recvmsg[link]

fn recvmsg(sock: socket, msg: *msghdr) (size | error);

Receives a message from a socket. See newmsg for details.

fn reset[link]

fn reset(msg: *msghdr) void;

Resets a message header, clearing out any I/O vectors or control messages, without freeing the underlying memory. This allows the user to configure new vectors or control messages without a re-allocation, which improves performance if the new configuration fits into the same amount of memory.

fn sendmsg[link]

fn sendmsg(sock: socket, msg: *msghdr) (size | error);

Sends a message to a socket. See newmsg for details.

fn setflags[link]

fn setflags(msg: *msghdr, flags: int) void;

Sets flags for this message.

fn strerror[link]

fn strerror(err: error) const str;

Converts an error into a human-readable string.