Skip to content

net #

Description:

net provides networking functions. It is mostly a wrapper to BSD sockets, so you can listen on a port, connect to remote TCP/UDP services, and communicate with them.

Constants #

const no_timeout = time.Duration(0)

no_timeout should be given to functions when no timeout is wanted (i.e. all functions return instantly)

const infinite_timeout = time.infinite

infinite_timeout should be given to functions when an infinite_timeout is wanted (i.e. functions only ever return with data)

const (
	errors_base             = 0
	err_new_socket_failed   = error_with_code('net: new_socket failed to create socket',
		errors_base + 1)
	err_option_not_settable = error_with_code('net: set_option_xxx option not settable',
		errors_base + 2)
	err_option_wrong_type   = error_with_code('net: set_option_xxx option wrong type',
		errors_base + 3)
	err_port_out_of_range   = error_with_code('net: port out of range', errors_base + 5)
	err_no_udp_remote       = error_with_code('net: no udp remote', errors_base + 6)
	err_connect_failed      = error_with_code('net: connect failed', errors_base + 7)
	err_connect_timed_out   = error_with_code('net: connect timed out', errors_base + 8)
	err_timed_out           = error_with_code('net: op timed out', errors_base + 9)
	err_timed_out_code      = errors_base + 9
	err_connection_refused  = error_with_code('net: connection refused', errors_base + 10)
)

Well defined errors that are returned from socket functions

const (
	msg_nosignal = 0x4000
)

fn addr_from_socket_handle #

fn addr_from_socket_handle(handle int) Addr

addr_from_socket_handle returns an address, based on the given integer socket handle

fn close #

fn close(handle int) !

close a socket, given its file descriptor handle.

fn dial_tcp #

fn dial_tcp(address string) !&TcpConn

fn dial_tcp_with_bind #

fn dial_tcp_with_bind(saddr string, laddr string) !&TcpConn

bind local address and dial.

fn dial_udp #

fn dial_udp(raddr string) !&UdpConn

fn listen_tcp #

fn listen_tcp(family AddrFamily, saddr string) !&TcpListener

fn listen_udp #

fn listen_udp(laddr string) !&UdpConn

fn new_ip #

fn new_ip(port u16, addr [4]u8) Addr

new_ip creates a new Addr from the IPv4 address family, based on the given port and addr

fn new_ip6 #

fn new_ip6(port u16, addr [16]u8) Addr

new_ip6 creates a new Addr from the IP6 address family, based on the given port and addr

fn resolve_addrs #

fn resolve_addrs(addr string, family AddrFamily, @type SocketType) ![]Addr

resolve_addrs converts the given addr, family and @type to a list of addresses

fn resolve_addrs_fuzzy #

fn resolve_addrs_fuzzy(addr string, @type SocketType) ![]Addr

resolve_addrs converts the given addr and @type to a list of addresses

fn resolve_ipaddrs #

fn resolve_ipaddrs(addr string, family AddrFamily, typ SocketType) ![]Addr

resolve_ipaddrs converts the given addr, family and typ to a list of addresses

fn shutdown #

fn shutdown(handle int, config ShutdownConfig) int

shutdown shutsdown a socket, given its file descriptor handle.
By default it shuts it down in both directions, both for reading and for writing. You can change that using net.shutdown(handle, how: .read) or net.shutdown(handle, how: .write)

fn socket_error #

fn socket_error(potential_code int) !int

fn socket_error_message #

fn socket_error_message(potential_code int, s string) !int

fn split_address #

fn split_address(addr string) !(string, u16)

split address splits an address into its host name and its port

fn tcp_socket_from_handle_raw #

fn tcp_socket_from_handle_raw(sockfd int) TcpSocket

tcp_socket_from_handle_raw is similar to tcp_socket_from_handle, but it does not modify any socket options

fn validate_port #

fn validate_port(port int) !u16

validate_port checks whether a port is valid and returns the port or an error

fn wrap_error #

fn wrap_error(error_code int) !

fn (TcpSocket) set_option_bool #

fn (mut s TcpSocket) set_option_bool(opt SocketOption, value bool) !

fn (TcpSocket) set_dualstack #

fn (mut s TcpSocket) set_dualstack(on bool) !

fn (TcpSocket) set_option_int #

fn (mut s TcpSocket) set_option_int(opt SocketOption, value int) !

fn (TcpSocket) bind #

fn (mut s TcpSocket) bind(addr string) !

bind a local rddress for TcpSocket

fn (UdpSocket) set_option_bool #

fn (mut s UdpSocket) set_option_bool(opt SocketOption, value bool) !

fn (UdpSocket) set_dualstack #

fn (mut s UdpSocket) set_dualstack(on bool) !

enum AddrFamily #

enum AddrFamily {
	unix = C.AF_UNIX
	ip = C.AF_INET
	ip6 = C.AF_INET6
	unspec = C.AF_UNSPEC
}

AddrFamily are the available address families

enum ShutdownDirection #

enum ShutdownDirection {
	read
	write
	read_and_write
}

ShutdownDirection is used by net.shutdown, for specifying the direction for which the communication will be cut.

enum SocketOption #

enum SocketOption {
// TODO: SO_ACCEPT_CONN is not here because windows doesnt support it
// and there is no easy way to define it
	broadcast = C.SO_BROADCAST
	debug = C.SO_DEBUG
	dont_route = C.SO_DONTROUTE
	error = C.SO_ERROR
	keep_alive = C.SO_KEEPALIVE
	linger = C.SO_LINGER
	oob_inline = C.SO_OOBINLINE
	reuse_addr = C.SO_REUSEADDR
	recieve_buf_size = C.SO_RCVBUF
	recieve_low_size = C.SO_RCVLOWAT
	recieve_timeout = C.SO_RCVTIMEO
	send_buf_size = C.SO_SNDBUF
	send_low_size = C.SO_SNDLOWAT
	send_timeout = C.SO_SNDTIMEO
	socket_type = C.SO_TYPE
	ipv6_only = C.IPV6_V6ONLY
}

enum SocketType #

enum SocketType {
	udp = C.SOCK_DGRAM
	tcp = C.SOCK_STREAM
	seqpacket = C.SOCK_SEQPACKET
}

SocketType are the available sockets

struct Addr #

struct Addr {
pub:
	f    u16
	addr AddrData
}

fn (Addr) family #

fn (a Addr) family() AddrFamily

family returns the family/kind of the given address a

fn (Addr) len #

fn (a Addr) len() u32

len returns the length in bytes of the address a, depending on its family

fn (Addr) str #

fn (a Addr) str() string

str returns a string representation of the address a

struct C.addrinfo #

struct C.addrinfo {
mut:
	ai_family    int
	ai_socktype  int
	ai_flags     int
	ai_protocol  int
	ai_addrlen   int
	ai_addr      voidptr
	ai_canonname voidptr
	ai_next      voidptr
}

struct C.fd_set #

struct C.fd_set {}

struct C.sockaddr_in #

struct C.sockaddr_in {
mut:
	sin_family u16
	sin_port   u16
	sin_addr   u32
}

struct C.sockaddr_in6 #

struct C.sockaddr_in6 {
mut:
	sin6_family u16
	sin6_port   u16
	sin6_addr   [4]u32
}

struct C.sockaddr_un #

struct C.sockaddr_un {
mut:
	sun_family u16
	sun_path   [max_unix_path]char
}

struct Ip #

struct Ip {
	port u16
	addr [4]u8
// Pad to size so that socket functions
// dont complain to us (see  in.h and bind())
// TODO(emily): I would really like to use
// some constant calculations here
// so that this doesnt have to be hardcoded
	sin_pad [8]u8
}

fn (Ip) str #

fn (a Ip) str() string

str returns a string representation of a

struct Ip6 #

struct Ip6 {
	port      u16
	flow_info u32
	addr      [16]u8
	scope_id  u32
}

fn (Ip6) str #

fn (a Ip6) str() string

str returns a string representation of a

struct ShutdownConfig #

struct ShutdownConfig {
	how ShutdownDirection = .read_and_write
}

struct Socket #

struct Socket {
pub:
	handle int
}

fn (Socket) address #

fn (s &Socket) address() !Addr

address gets the address of a socket

struct TcpConn #

struct TcpConn {
pub mut:
	sock TcpSocket
mut:
	write_deadline time.Time
	read_deadline  time.Time
	read_timeout   time.Duration
	write_timeout  time.Duration
	is_blocking    bool
}

fn (TcpConn) addr #

fn (c &TcpConn) addr() !Addr

fn (TcpConn) close #

fn (mut c TcpConn) close() !

fn (TcpConn) get_blocking #

fn (mut con TcpConn) get_blocking() bool

get_blocking returns whether the connection is in a blocking state, that is calls to .read_line, C.recv etc will block till there is new data arrived, instead of returning immediately.

fn (TcpConn) peer_addr #

fn (c &TcpConn) peer_addr() !Addr

fn (TcpConn) peer_ip #

fn (c &TcpConn) peer_ip() !string

fn (TcpConn) read #

fn (c TcpConn) read(mut buf []u8) !int

fn (TcpConn) read_deadline #

fn (mut c TcpConn) read_deadline() !time.Time

fn (TcpConn) read_line #

fn (mut con TcpConn) read_line() string

read_line is a simple, non customizable, blocking line reader.
It will return a line, ending with LF, or just '', on EOF.
Note: if you want more control over the buffer, please use a buffered IO reader instead: io.new_buffered_reader({reader: io.make_reader(con)})

fn (TcpConn) read_line_max #

fn (mut con TcpConn) read_line_max(max_line_len int) string

read_line_max is a simple, non customizable, blocking line reader.
It will return a line, ending with LF, '' on EOF.
It stops reading, when the result line length exceeds max_line_len.

fn (TcpConn) read_ptr #

fn (c TcpConn) read_ptr(buf_ptr &u8, len int) !int

fn (TcpConn) read_timeout #

fn (c &TcpConn) read_timeout() time.Duration

fn (TcpConn) set_blocking #

fn (mut con TcpConn) set_blocking(state bool) !

set_blocking will change the state of the connection to either blocking, when state is true, or non blocking (false).
The default for net tcp connections is the non blocking mode.
Calling .read_line will set the connection to blocking mode.

fn (TcpConn) set_read_deadline #

fn (mut c TcpConn) set_read_deadline(deadline time.Time)

fn (TcpConn) set_read_timeout #

fn (mut c TcpConn) set_read_timeout(t time.Duration)

fn (TcpConn) set_write_deadline #

fn (mut c TcpConn) set_write_deadline(deadline time.Time)

fn (TcpConn) set_write_timeout #

fn (mut c TcpConn) set_write_timeout(t time.Duration)

fn (TcpConn) str #

fn (c TcpConn) str() string

fn (TcpConn) wait_for_read #

fn (c TcpConn) wait_for_read() !

fn (TcpConn) wait_for_write #

fn (mut c TcpConn) wait_for_write() !

fn (TcpConn) write #

fn (mut c TcpConn) write(bytes []u8) !int

write blocks and attempts to write all data

fn (TcpConn) write_deadline #

fn (mut c TcpConn) write_deadline() !time.Time

fn (TcpConn) write_ptr #

fn (mut c TcpConn) write_ptr(b &u8, len int) !int

write_ptr blocks and attempts to write all data

fn (TcpConn) write_string #

fn (mut c TcpConn) write_string(s string) !int

write_string blocks and attempts to write all data

fn (TcpConn) write_timeout #

fn (c &TcpConn) write_timeout() time.Duration

struct TcpListener #

struct TcpListener {
pub mut:
	sock TcpSocket
mut:
	accept_timeout  time.Duration
	accept_deadline time.Time
}

fn (TcpListener) accept #

fn (mut l TcpListener) accept() !&TcpConn

fn (TcpListener) accept_deadline #

fn (c &TcpListener) accept_deadline() !time.Time

fn (TcpListener) set_accept_deadline #

fn (mut c TcpListener) set_accept_deadline(deadline time.Time)

fn (TcpListener) accept_timeout #

fn (c &TcpListener) accept_timeout() time.Duration

fn (TcpListener) set_accept_timeout #

fn (mut c TcpListener) set_accept_timeout(t time.Duration)

fn (TcpListener) wait_for_accept #

fn (mut c TcpListener) wait_for_accept() !

fn (TcpListener) close #

fn (mut c TcpListener) close() !

fn (TcpListener) addr #

fn (c &TcpListener) addr() !Addr

struct UdpConn #

struct UdpConn {
pub mut:
	sock UdpSocket
mut:
	write_deadline time.Time
	read_deadline  time.Time
	read_timeout   time.Duration
	write_timeout  time.Duration
}

fn (UdpConn) write_ptr #

fn (mut c UdpConn) write_ptr(b &u8, len int) !int
sock := UdpSocket{ 		handle: sbase.handle 		l: local 		r: resolve_wrapper(raddr) 	} }

fn (UdpConn) write #

fn (mut c UdpConn) write(buf []u8) !int

fn (UdpConn) write_string #

fn (mut c UdpConn) write_string(s string) !int

fn (UdpConn) write_to_ptr #

fn (mut c UdpConn) write_to_ptr(addr Addr, b &u8, len int) !int

fn (UdpConn) write_to #

fn (mut c UdpConn) write_to(addr Addr, buf []u8) !int

write_to blocks and writes the buf to the remote addr specified

fn (UdpConn) write_to_string #

fn (mut c UdpConn) write_to_string(addr Addr, s string) !int

write_to_string blocks and writes the buf to the remote addr specified

fn (UdpConn) read #

fn (mut c UdpConn) read(mut buf []u8) !(int, Addr)

read reads from the socket into buf up to buf.len returning the number of bytes read

fn (UdpConn) read_deadline #

fn (c &UdpConn) read_deadline() !time.Time

fn (UdpConn) set_read_deadline #

fn (mut c UdpConn) set_read_deadline(deadline time.Time)

fn (UdpConn) write_deadline #

fn (c &UdpConn) write_deadline() !time.Time

fn (UdpConn) set_write_deadline #

fn (mut c UdpConn) set_write_deadline(deadline time.Time)

fn (UdpConn) read_timeout #

fn (c &UdpConn) read_timeout() time.Duration

fn (UdpConn) set_read_timeout #

fn (mut c UdpConn) set_read_timeout(t time.Duration)

fn (UdpConn) write_timeout #

fn (c &UdpConn) write_timeout() time.Duration

fn (UdpConn) set_write_timeout #

fn (mut c UdpConn) set_write_timeout(t time.Duration)

fn (UdpConn) wait_for_read #

fn (mut c UdpConn) wait_for_read() !

fn (UdpConn) wait_for_write #

fn (mut c UdpConn) wait_for_write() !

fn (UdpConn) str #

fn (c &UdpConn) str() string

fn (UdpConn) close #

fn (mut c UdpConn) close() !

struct Unix #

struct Unix {
	path [max_unix_path]u8
}