v/vlib/net/udp.v

module net

import time

const (
	udp_default_read_timeout  = 30 * time.second
	udp_default_write_timeout = 30 * time.second
)

pub struct UdpConn {
	sock UdpSocket

mut:
	write_deadline time.Time
	read_deadline time.Time

	read_timeout time.Duration
	write_timeout time.Duration
}

pub fn dial_udp(laddr string, raddr string) ?UdpConn {
	// Dont have to do this when its fixed
	// this just allows us to store this `none` optional in a struct
	resolve_wrapper := fn(raddr string) ?Addr {
		x :=  resolve_addr(raddr, .inet, .udp) or { return none }
		return x
	}

	local := resolve_addr(laddr, .inet, .udp)?
	sbase := new_udp_socket(local.port)?

	sock := UdpSocket {
		handle: sbase.handle

		l: local
		r: resolve_wrapper(raddr)
	}

	return UdpConn {
		sock: sock
		read_timeout: udp_default_read_timeout
		write_timeout: udp_default_write_timeout
	}
}

pub fn (c UdpConn) write_ptr(b byteptr, len int) ? {
	remote := c.sock.remote() or {
		return err_no_udp_remote
	}

	return c.write_to_ptr(remote, b, len)
}

pub fn (c UdpConn) write(buf []byte) ? {
	return c.write_ptr(buf.data, buf.len)
}

pub fn (c UdpConn) write_str(s string) ? {
	return c.write_ptr(s.str, s.len)
}

pub fn (c UdpConn) write_to_ptr(addr Addr, b byteptr, len int) ? {
	res := C.sendto(c.sock.handle, b, len, 0, &addr.addr, addr.len)

	if res >= 0 {
		return none
	}

	code := error_code()
	match code {
		error_ewouldblock {
			c.wait_for_write()?
			socket_error(C.sendto(c.sock.handle, b, len, 0, &addr.addr, addr.len))?
		}
		else {
			wrap_error(code)?
		}
	}

	return none
}

// write_to blocks and writes the buf to the remote addr specified
pub fn (c UdpConn) write_to(addr Addr, buf []byte) ? {
	return c.write_to_ptr(addr, buf.data, buf.len)
}

// write_to_string blocks and writes the buf to the remote addr specified
pub fn (c UdpConn) write_to_string(addr Addr, s string) ? {
	return c.write_to_ptr(addr, s.str, s.len)
}

// read reads from the socket into buf up to buf.len returning the number of bytes read
pub fn (c UdpConn) read(mut buf []byte) ?(int, Addr) {
	mut addr_from := C.sockaddr{}
	len := sizeof(C.sockaddr)

	mut res := wrap_read_result(C.recvfrom(c.sock.handle, buf.data, buf.len, 0, &addr_from, &len))?

	if res > 0 {
		addr := new_addr(addr_from)?
		return res, addr
	}

	code := error_code()
	match code {
		error_ewouldblock {
			c.wait_for_read()?
			// same setup as in tcp
			res = wrap_read_result(C.recvfrom(c.sock.handle, buf.data, buf.len, 0, &addr_from, &len))?
			res2 := socket_error(res)?

			addr := new_addr(addr_from)?
			return res2, addr
		}
		else {
			wrap_error(code)?
		}
	}

	return none
}

pub fn (c UdpConn) read_deadline() ?time.Time {
	if c.read_deadline.unix == 0 {
		return c.read_deadline
	}
	return none
}

pub fn (mut c UdpConn) set_read_deadline(deadline time.Time) {
	c.read_deadline = deadline
}

pub fn (c UdpConn) write_deadline() ?time.Time {
	if c.write_deadline.unix == 0 {
		return c.write_deadline
	}
	return none
}

pub fn (mut c UdpConn) set_write_deadline(deadline time.Time) {
	c.write_deadline = deadline
}

pub fn (c UdpConn) read_timeout() time.Duration {
	return c.read_timeout
}

pub fn(mut c UdpConn) set_read_timeout(t time.Duration) {
	c.read_timeout = t
}

pub fn (c UdpConn) write_timeout() time.Duration {
	return c.write_timeout
}

pub fn (mut c UdpConn) set_write_timeout(t time.Duration) {
	c.write_timeout = t
}

[inline]
pub fn (c UdpConn) wait_for_read() ? {
	return wait_for_read(c.sock.handle, c.read_deadline, c.read_timeout)
}

[inline]
pub fn (c UdpConn) wait_for_write() ? {
	return wait_for_write(c.sock.handle, c.write_deadline, c.write_timeout)
}

pub fn (c UdpConn) str() string {
	// TODO
	return 'UdpConn'
}

pub fn (c UdpConn) close() ? {
	return c.sock.close()
}

pub fn listen_udp(port int) ?UdpConn {
	s := new_udp_socket(port)?

	return UdpConn {
		sock: s
		read_timeout: udp_default_read_timeout
		write_timeout: udp_default_write_timeout
	}
}

struct UdpSocket {
	handle int

	l Addr
	r ?Addr
}

fn new_udp_socket(local_port int) ?UdpSocket {
	sockfd := socket_error(C.socket(SocketFamily.inet, SocketType.udp, 0))?
	s := UdpSocket {
		handle: sockfd
	}
	s.set_option_bool(.reuse_addr, true)?
	$if windows {
		t := true
		socket_error(C.ioctlsocket(sockfd, fionbio, &t))?
	} $else {
		socket_error(C.fcntl(sockfd, C.F_SETFD, C.O_NONBLOCK))
	}

	// In UDP we always have to bind to a port
	validate_port(local_port)?

	mut addr := C.sockaddr_in{}
	addr.sin_family = SocketFamily.inet
	addr.sin_port = C.htons(local_port)
	addr.sin_addr.s_addr = C.htonl(C.INADDR_ANY)
	size := sizeof(C.sockaddr_in)

	// cast to the correct type
	sockaddr := unsafe {&C.sockaddr(&addr)}

	socket_error(C.bind(s.handle, sockaddr, size))?

	return s
}

pub fn (s UdpSocket) remote() ?Addr {
	return s.r
}

pub fn (s UdpSocket) set_option_bool(opt SocketOption, value bool) ? {
	// TODO reenable when this `in` operation works again
	// if opt !in opts_can_set {
	// 	return err_option_not_settable
	// }
	// if opt !in opts_bool {
	// 	return err_option_wrong_type
	// }
	socket_error(C.setsockopt(s.handle, C.SOL_SOCKET, int(opt), &value, sizeof(bool)))?
	return none
}

fn (s UdpSocket) close() ? {
	return shutdown(s.handle)
}

fn (s UdpSocket) @select(test Select, timeout time.Duration) ?bool {
	return @select(s.handle, test, timeout)
}