x.net: new net module (#6130)

Author: emily33901

examples/net_raw_http.v

@@ -0,0 +1,14 @@
+// Simple raw HTTP head request
+import x.net as net
+import time
+
+// Make a new connection
+mut conn := net.dial_tcp('google.com:80')?
+// Simple http HEAD request for a file
+conn.write_string('HEAD /index.html HTTP/1.0\r\n\r\n')?
+// Make sure to set a timeout so we can wait for a response!
+conn.set_read_timeout(10 * time.second)
+// Read all the data that is waiting
+result := conn.read()?
+// Cast to string and print result
+println(result.bytestr())

vlib/x/net/aasocket.c.v

@@ -0,0 +1,95 @@
+module net
+
+// Select represents a select operation
+enum Select {
+	read write except
+}
+
+// SocketType are the available sockets
+pub enum SocketType {
+	udp = C.SOCK_DGRAM
+	tcp = C.SOCK_STREAM
+}
+
+// SocketFamily are the available address families
+pub enum SocketFamily {
+	inet = C. AF_INET
+}
+
+struct C.in_addr {
+mut:
+	s_addr int
+}
+
+struct C.sockaddr {
+}
+
+struct C.sockaddr_in {
+mut:
+	sin_family int
+	sin_port   int
+	sin_addr   C.in_addr
+}
+
+
+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.sockaddr_storage {
+}
+
+fn C.socket() int
+
+fn C.setsockopt() int
+
+fn C.htonl() int
+
+fn C.htons() int
+
+fn C.bind() int
+
+fn C.listen() int
+
+fn C.accept() int
+
+fn C.getaddrinfo() int
+
+fn C.connect() int
+
+fn C.send() int
+fn C.sendto() int
+
+fn C.recv() int
+fn C.recvfrom() int
+
+fn C.shutdown() int
+
+fn C.ntohs() int
+
+fn C.inet_ntop() int
+
+fn C.getsockname() int
+
+// defined in builtin
+// fn C.read() int
+// fn C.close() int
+
+fn C.ioctlsocket() int
+fn C.fcntl() int
+
+fn C.@select() int
+fn C.FD_ZERO()
+fn C.FD_SET()
+fn C.FD_ISSET() bool
+
+[typedef]
+struct C.fd_set {}

vlib/x/net/address.v

@@ -0,0 +1,74 @@
+module net
+
+// Addr represents an ip address
+pub struct Addr {
+	addr C.sockaddr
+	len int
+pub:
+	saddr string
+	port int
+}
+
+pub fn (a Addr) str() string {
+	return '${a.saddr}:${a.port}'
+}
+
+const (
+	max_ipv4_addr_len = 16
+)
+
+fn new_addr(addr C.sockaddr, _saddr string, _port int) ?Addr {
+	mut saddr := _saddr
+	if saddr == '' {
+		// Convert to string representation
+		buf := []byte{ len: max_ipv4_addr_len, init: 0 }
+		$if windows {
+			res := C.inet_ntop(SocketFamily.inet, &addr, buf.data, buf.len)
+			if res == 0 {
+				socket_error(-1)?
+			}
+		} $else {
+			res := C.inet_ntop(SocketFamily.inet, &addr, buf.data, buf.len)
+			if res == 0 {
+				socket_error(-1)?
+			}
+		}
+		saddr = buf.bytestr()
+	}
+
+	mut port := _port
+	if port == 0 {
+		hport := (&C.sockaddr_in(&addr)).sin_port
+		port = C.ntohs(hport)
+	}
+
+	return Addr {
+		addr int(sizeof(C.sockaddr)) saddr port
+	}
+}
+
+pub fn resolve_addr(addr string, family SocketFamily, typ SocketType) ?Addr {
+	address, port := split_address(addr)?
+
+	mut hints := C.addrinfo{}
+	hints.ai_family = family
+	hints.ai_socktype = typ
+	hints.ai_flags = C.AI_PASSIVE
+	hints.ai_protocol = 0
+	hints.ai_addrlen = 0
+	hints.ai_canonname = C.NULL
+	hints.ai_addr = C.NULL
+	hints.ai_next = C.NULL
+	info := &C.addrinfo(0)
+
+	sport := '$port'
+
+	// This might look silly but is reccomended by MSDN
+	$if windows {
+		socket_error(0-C.getaddrinfo(address.str, sport.str, &hints, &info))?
+	} $else {
+		wrap_error(C.getaddrinfo(address.str, sport.str, &hints, &info))
+	}
+
+	return new_addr(*info.ai_addr, address, port)
+}

vlib/x/net/common.v

@@ -0,0 +1,122 @@
+module net
+
+import time
+
+// Shutdown shutsdown a socket and closes it
+fn shutdown(handle int) ? {
+	$if windows {
+		C.shutdown(handle, C.SD_BOTH)
+		socket_error(C.closesocket(handle))?
+	} $else {
+		C.shutdown(handle, C.SHUT_RDWR)
+		socket_error(C.close(handle))?
+	}
+
+	return none
+}
+
+// Select waits for an io operation (specified by parameter `test`) to be available
+fn @select(handle int, test Select, timeout time.Duration) ?bool {
+	set := C.fd_set{}
+
+	C.FD_ZERO(&set)
+	C.FD_SET(handle, &set)
+
+	seconds := timeout.milliseconds() / 1000
+	microseconds := timeout - (seconds * time.second)
+
+	mut tt := C.timeval{
+		tv_sec: u64(seconds)
+		tv_usec: u64(microseconds)
+	}
+
+	mut timeval_timeout := &tt
+
+	// infinite timeout is signaled by passing null as the timeout to
+	// select
+	if timeout == infinite_timeout {
+		timeval_timeout = &C.timeval(0)
+	}
+
+	match test {
+		.read {
+			socket_error(C.@select(handle+1, &set, C.NULL, C.NULL, timeval_timeout))?
+		}
+		.write {
+			socket_error(C.@select(handle+1, C.NULL, &set, C.NULL, timeval_timeout))?
+		}
+		.except {
+			socket_error(C.@select(handle+1, C.NULL, C.NULL, &set, timeval_timeout))?
+		}
+	}
+
+	return C.FD_ISSET(handle, &set)
+}
+
+// wait_for_common wraps the common wait code
+fn wait_for_common(
+	handle int,
+	deadline time.Time,
+	timeout time.Duration,
+	test Select) ? {
+	if deadline.unix == 0 {
+		// only accept infinite_timeout as a valid
+		// negative timeout - it is handled in @select however
+		if timeout < 0 && timeout != infinite_timeout {
+			return err_timed_out
+		}
+		ready := @select(handle, test, timeout)?
+		if ready {
+			return none
+		}
+		return err_timed_out
+	}
+	// Convert the deadline into a timeout
+	// and use that
+	d_timeout := deadline.unix - time.now().unix
+	if d_timeout < 0 {
+		// deadline is in the past so this has already
+		// timed out
+		return err_timed_out
+	}
+
+	ready := @select(handle, test, d_timeout)?
+	if ready {
+		return none
+	}
+	return err_timed_out
+}
+
+// wait_for_write waits for a write io operation to be available
+fn wait_for_write(
+	handle int,
+	deadline time.Time,
+	timeout time.Duration) ? {
+	return wait_for_common(handle, deadline, timeout, .write)
+}
+
+// wait_for_read waits for a read io operation to be available
+fn wait_for_read(
+	handle int,
+	deadline time.Time,
+	timeout time.Duration) ? {
+	return wait_for_common(handle, deadline, timeout, .read)
+}
+
+// no_deadline should be given to functions when no deadline is wanted (i.e. all functions
+// return instantly)
+const (
+	no_deadline = time.Time{unix: 0}
+)
+
+// no_timeout should be given to functions when no timeout is wanted (i.e. all functions
+// return instantly)
+const (
+	no_timeout = time.Duration(0)
+)
+
+// infinite_timeout should be given to functions when an infinite_timeout is wanted (i.e. functions
+// only ever return with data)
+const (
+	infinite_timeout = time.Duration(-1)
+)

vlib/x/net/errors.v

@@ -0,0 +1,44 @@
+module net
+
+// Well defined errors that are returned from socket functions
+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('', errors_base+5)
+	err_no_udp_remote = error_with_code('', 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
+)
+
+pub fn socket_error(potential_code int) ?int {
+	$if windows {
+		if potential_code < 0 {
+			last_error_int := C.WSAGetLastError()
+			last_error := wsa_error(last_error_int)
+			return error_with_code('net: socket error: ($last_error_int) $last_error', last_error)
+		}
+	}
+	$else {
+		if potential_code < 0 {
+			last_error := error_code()
+			return error_with_code('net: socket error: $last_error', last_error)
+		}
+	}
+
+	return potential_code
+}
+
+pub fn wrap_error(error_code int) ? {
+	$if windows {
+		enum_error := wsa_error(error_code)
+		return error_with_code('socket error: $enum_error', error_code)
+	}
+	$else {
+		return error_with_code('net: socket error: $error_code', error_code)
+	}
+}

vlib/x/net/net_nix.c.v

@@ -0,0 +1,28 @@
+module net
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/select.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <errno.h>
+#include <fcntl.h>
+
+fn error_code() int {
+	return C.errno
+}
+
+fn init() {
+}
+
+pub const (
+	msg_nosignal = 0x4000
+)
+
+const (
+	error_ewouldblock = C.EWOULDBLOCK
+)
+
+#flag solaris -lsocket