type sockflags[link]

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

};

Optional flags to accept to be set on the returned io::file. See the O_CLOEXEC and O_NONBLOCK sections of open(2) for details.

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: io::file, flags: sockflags...) (io::file | error);

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

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 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: io::file, 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: io::file, 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 shutdown[link]

fn shutdown(sock: io::file) void;

Shuts down a listening socket.

fn strerror[link]

fn strerror(err: error) const str;

Converts an error into a human-readable string.