2020-08-20 23:01:37 +02:00
|
|
|
|
module net
|
|
|
|
|
|
|
|
|
|
import time
|
|
|
|
|
|
2020-12-15 16:39:11 +01:00
|
|
|
|
const (
|
|
|
|
|
tcp_default_read_timeout = 30 * time.second
|
|
|
|
|
tcp_default_write_timeout = 30 * time.second
|
|
|
|
|
)
|
|
|
|
|
|
2021-05-16 03:28:11 +02:00
|
|
|
|
[heap]
|
2020-08-20 23:01:37 +02:00
|
|
|
|
pub struct TcpConn {
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub mut:
|
2021-06-13 22:53:38 +02:00
|
|
|
|
sock TcpSocket
|
2020-08-20 23:01:37 +02:00
|
|
|
|
mut:
|
|
|
|
|
write_deadline time.Time
|
2020-12-15 16:39:11 +01:00
|
|
|
|
read_deadline time.Time
|
|
|
|
|
read_timeout time.Duration
|
|
|
|
|
write_timeout time.Duration
|
2021-08-07 22:20:58 +02:00
|
|
|
|
is_blocking bool
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn dial_tcp(address string) ?&TcpConn {
|
2022-01-08 16:02:03 +01:00
|
|
|
|
addrs := resolve_addrs_fuzzy(address, .tcp) or {
|
2022-02-11 14:52:33 +01:00
|
|
|
|
return error('$err.msg(); could not resolve address $address in dial_tcp')
|
2022-01-08 16:02:03 +01:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
|
|
|
|
|
// Very simple dialer
|
|
|
|
|
for addr in addrs {
|
2022-01-08 16:02:03 +01:00
|
|
|
|
mut s := new_tcp_socket(addr.family()) or {
|
2022-02-11 14:52:33 +01:00
|
|
|
|
return error('$err.msg(); could not create new tcp socket in dial_tcp')
|
2022-01-08 16:02:03 +01:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
s.connect(addr) or {
|
|
|
|
|
// Connection failed
|
|
|
|
|
s.close() or { continue }
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return &TcpConn{
|
|
|
|
|
sock: s
|
|
|
|
|
read_timeout: net.tcp_default_read_timeout
|
|
|
|
|
write_timeout: net.tcp_default_write_timeout
|
|
|
|
|
}
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
// failed
|
2022-01-08 16:02:03 +01:00
|
|
|
|
return error('dial_tcp failed for address $address')
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut c TcpConn) close() ? {
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln(' TcpConn.close | c.sock.handle: ${c.sock.handle:6}')
|
|
|
|
|
}
|
2020-12-15 16:39:11 +01:00
|
|
|
|
c.sock.close() ?
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-10-11 14:41:31 +02:00
|
|
|
|
pub fn (c TcpConn) read_ptr(buf_ptr &byte, len int) ?int {
|
2021-09-28 08:20:49 +02:00
|
|
|
|
mut res := wrap_read_result(C.recv(c.sock.handle, voidptr(buf_ptr), len, 0)) ?
|
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln('<<< TcpConn.read_ptr | c.sock.handle: $c.sock.handle | buf_ptr: ${ptr_str(buf_ptr)} len: $len | res: $res')
|
|
|
|
|
}
|
|
|
|
|
if res > 0 {
|
|
|
|
|
$if trace_tcp_data_read ? {
|
|
|
|
|
eprintln('<<< TcpConn.read_ptr | 1 data.len: ${res:6} | data: ' +
|
|
|
|
|
unsafe { buf_ptr.vstring_with_len(res) })
|
|
|
|
|
}
|
|
|
|
|
return res
|
|
|
|
|
}
|
|
|
|
|
code := error_code()
|
|
|
|
|
if code == int(error_ewouldblock) {
|
|
|
|
|
c.wait_for_read() ?
|
|
|
|
|
res = wrap_read_result(C.recv(c.sock.handle, voidptr(buf_ptr), len, 0)) ?
|
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln('<<< TcpConn.read_ptr | c.sock.handle: $c.sock.handle | buf_ptr: ${ptr_str(buf_ptr)} len: $len | res: $res')
|
|
|
|
|
}
|
|
|
|
|
$if trace_tcp_data_read ? {
|
|
|
|
|
if res > 0 {
|
|
|
|
|
eprintln('<<< TcpConn.read_ptr | 2 data.len: ${res:6} | data: ' +
|
|
|
|
|
unsafe { buf_ptr.vstring_with_len(res) })
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return socket_error(res)
|
|
|
|
|
} else {
|
|
|
|
|
wrap_error(code) ?
|
|
|
|
|
}
|
|
|
|
|
return none
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-11 14:41:31 +02:00
|
|
|
|
pub fn (c TcpConn) read(mut buf []byte) ?int {
|
2021-09-28 08:20:49 +02:00
|
|
|
|
return c.read_ptr(buf.data, buf.len)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (mut c TcpConn) read_deadline() ?time.Time {
|
|
|
|
|
if c.read_deadline.unix == 0 {
|
|
|
|
|
return c.read_deadline
|
|
|
|
|
}
|
|
|
|
|
return none
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-20 23:01:37 +02:00
|
|
|
|
// write_ptr blocks and attempts to write all data
|
2021-04-04 16:43:32 +02:00
|
|
|
|
pub fn (mut c TcpConn) write_ptr(b &byte, len int) ?int {
|
2020-12-29 14:41:46 +01:00
|
|
|
|
$if trace_tcp ? {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
eprintln(
|
|
|
|
|
'>>> TcpConn.write_ptr | c.sock.handle: $c.sock.handle | b: ${ptr_str(b)} len: $len |\n' +
|
2021-04-23 14:18:09 +02:00
|
|
|
|
unsafe { b.vstring_with_len(len) })
|
2021-04-23 14:12:37 +02:00
|
|
|
|
}
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp_data_write ? {
|
|
|
|
|
eprintln('>>> TcpConn.write_ptr | data.len: ${len:6} | data: ' +
|
|
|
|
|
unsafe { b.vstring_with_len(len) })
|
|
|
|
|
}
|
2020-08-20 23:01:37 +02:00
|
|
|
|
unsafe {
|
2021-04-04 16:43:32 +02:00
|
|
|
|
mut ptr_base := &byte(b)
|
2020-08-20 23:01:37 +02:00
|
|
|
|
mut total_sent := 0
|
|
|
|
|
for total_sent < len {
|
|
|
|
|
ptr := ptr_base + total_sent
|
2021-06-13 22:53:38 +02:00
|
|
|
|
remaining := len - total_sent
|
|
|
|
|
mut sent := C.send(c.sock.handle, ptr, remaining, msg_nosignal)
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp_data_write ? {
|
|
|
|
|
eprintln('>>> TcpConn.write_ptr | data chunk, total_sent: ${total_sent:6}, chunk_size: ${chunk_size:6}, sent: ${sent:6}, ptr: ${ptr_str(ptr)}')
|
|
|
|
|
}
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if sent < 0 {
|
|
|
|
|
code := error_code()
|
2021-01-08 17:41:52 +01:00
|
|
|
|
if code == int(error_ewouldblock) {
|
2021-01-26 15:43:10 +01:00
|
|
|
|
c.wait_for_write() ?
|
2021-01-08 17:41:52 +01:00
|
|
|
|
continue
|
|
|
|
|
} else {
|
|
|
|
|
wrap_error(code) ?
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
total_sent += sent
|
|
|
|
|
}
|
2021-02-27 09:29:18 +01:00
|
|
|
|
return total_sent
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// write blocks and attempts to write all data
|
2021-02-27 09:29:18 +01:00
|
|
|
|
pub fn (mut c TcpConn) write(bytes []byte) ?int {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return c.write_ptr(bytes.data, bytes.len)
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-19 02:51:31 +01:00
|
|
|
|
// write_string blocks and attempts to write all data
|
|
|
|
|
pub fn (mut c TcpConn) write_string(s string) ?int {
|
|
|
|
|
return c.write_ptr(s.str, s.len)
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-20 23:01:37 +02:00
|
|
|
|
pub fn (mut c TcpConn) set_read_deadline(deadline time.Time) {
|
|
|
|
|
c.read_deadline = deadline
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut c TcpConn) write_deadline() ?time.Time {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if c.write_deadline.unix == 0 {
|
|
|
|
|
return c.write_deadline
|
|
|
|
|
}
|
|
|
|
|
return none
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (mut c TcpConn) set_write_deadline(deadline time.Time) {
|
|
|
|
|
c.write_deadline = deadline
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpConn) read_timeout() time.Duration {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return c.read_timeout
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-15 16:39:11 +01:00
|
|
|
|
pub fn (mut c TcpConn) set_read_timeout(t time.Duration) {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
c.read_timeout = t
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpConn) write_timeout() time.Duration {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return c.write_timeout
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (mut c TcpConn) set_write_timeout(t time.Duration) {
|
|
|
|
|
c.write_timeout = t
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
[inline]
|
2021-10-11 14:41:31 +02:00
|
|
|
|
pub fn (c TcpConn) wait_for_read() ? {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return wait_for_read(c.sock.handle, c.read_deadline, c.read_timeout)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
[inline]
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut c TcpConn) wait_for_write() ? {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return wait_for_write(c.sock.handle, c.write_deadline, c.write_timeout)
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpConn) peer_addr() ?Addr {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
mut addr := Addr{
|
2021-07-20 10:17:08 +02:00
|
|
|
|
addr: AddrData{
|
|
|
|
|
Ip6: Ip6{}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
mut size := sizeof(Addr)
|
2022-01-08 16:02:03 +01:00
|
|
|
|
socket_error_message(C.getpeername(c.sock.handle, voidptr(&addr), &size), 'peer_addr failed') ?
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return addr
|
2020-11-15 21:54:47 +01:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpConn) peer_ip() ?string {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return c.peer_addr() ?.str()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (c &TcpConn) addr() ?Addr {
|
|
|
|
|
return c.sock.address()
|
2020-11-15 21:54:47 +01:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-26 15:43:10 +01:00
|
|
|
|
pub fn (c TcpConn) str() string {
|
|
|
|
|
s := c.sock.str().replace('\n', ' ').replace(' ', ' ')
|
|
|
|
|
return 'TcpConn{ write_deadline: $c.write_deadline, read_deadline: $c.read_deadline, read_timeout: $c.read_timeout, write_timeout: $c.write_timeout, sock: $s }'
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub struct TcpListener {
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub mut:
|
|
|
|
|
sock TcpSocket
|
2020-08-20 23:01:37 +02:00
|
|
|
|
mut:
|
2020-12-15 16:39:11 +01:00
|
|
|
|
accept_timeout time.Duration
|
2020-08-20 23:01:37 +02:00
|
|
|
|
accept_deadline time.Time
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-13 22:53:38 +02:00
|
|
|
|
pub fn listen_tcp(family AddrFamily, saddr string) ?&TcpListener {
|
2022-02-11 14:52:33 +01:00
|
|
|
|
s := new_tcp_socket(family) or { return error('$err.msg(); could not create new socket') }
|
2021-06-13 22:53:38 +02:00
|
|
|
|
|
2022-01-08 16:02:03 +01:00
|
|
|
|
addrs := resolve_addrs(saddr, family, .tcp) or {
|
2022-02-11 14:52:33 +01:00
|
|
|
|
return error('$err.msg(); could not resolve address $saddr')
|
2022-01-08 16:02:03 +01:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
|
|
|
|
|
// TODO(logic to pick here)
|
|
|
|
|
addr := addrs[0]
|
|
|
|
|
|
2020-08-20 23:01:37 +02:00
|
|
|
|
// cast to the correct type
|
2021-06-13 22:53:38 +02:00
|
|
|
|
alen := addr.len()
|
2022-01-08 16:02:03 +01:00
|
|
|
|
socket_error_message(C.bind(s.handle, voidptr(&addr), alen), 'binding to $saddr failed') ?
|
|
|
|
|
socket_error_message(C.listen(s.handle, 128), 'listening on $saddr failed') ?
|
2021-01-20 11:11:01 +01:00
|
|
|
|
return &TcpListener{
|
2020-08-20 23:01:37 +02:00
|
|
|
|
sock: s
|
|
|
|
|
accept_deadline: no_deadline
|
2020-11-15 21:54:47 +01:00
|
|
|
|
accept_timeout: infinite_timeout
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut l TcpListener) accept() ?&TcpConn {
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln(' TcpListener.accept | l.sock.handle: ${l.sock.handle:6}')
|
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
addr := Addr{
|
2021-07-20 10:17:08 +02:00
|
|
|
|
addr: AddrData{
|
|
|
|
|
Ip6: Ip6{}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
}
|
2021-04-23 13:37:05 +02:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
size := sizeof(Addr)
|
|
|
|
|
mut new_handle := C.accept(l.sock.handle, voidptr(&addr), &size)
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if new_handle <= 0 {
|
2020-12-15 16:39:11 +01:00
|
|
|
|
l.wait_for_accept() ?
|
2021-06-13 22:53:38 +02:00
|
|
|
|
new_handle = C.accept(l.sock.handle, voidptr(&addr), &size)
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if new_handle == -1 || new_handle == 0 {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return error('accept failed')
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2020-12-15 16:39:11 +01:00
|
|
|
|
new_sock := tcp_socket_from_handle(new_handle) ?
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln(' TcpListener.accept | << new_sock.handle: ${new_sock.handle:6}')
|
|
|
|
|
}
|
2021-01-20 11:11:01 +01:00
|
|
|
|
return &TcpConn{
|
2020-08-20 23:01:37 +02:00
|
|
|
|
sock: new_sock
|
2021-01-26 15:43:10 +01:00
|
|
|
|
read_timeout: net.tcp_default_read_timeout
|
|
|
|
|
write_timeout: net.tcp_default_write_timeout
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpListener) accept_deadline() ?time.Time {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if c.accept_deadline.unix != 0 {
|
|
|
|
|
return c.accept_deadline
|
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return error('invalid deadline')
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (mut c TcpListener) set_accept_deadline(deadline time.Time) {
|
|
|
|
|
c.accept_deadline = deadline
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (c &TcpListener) accept_timeout() time.Duration {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return c.accept_timeout
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-15 16:39:11 +01:00
|
|
|
|
pub fn (mut c TcpListener) set_accept_timeout(t time.Duration) {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
c.accept_timeout = t
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut c TcpListener) wait_for_accept() ? {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return wait_for_read(c.sock.handle, c.accept_deadline, c.accept_timeout)
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut c TcpListener) close() ? {
|
2020-12-15 16:39:11 +01:00
|
|
|
|
c.sock.close() ?
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-13 22:53:38 +02:00
|
|
|
|
pub fn (c &TcpListener) addr() ?Addr {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return c.sock.address()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct TcpSocket {
|
|
|
|
|
pub:
|
|
|
|
|
handle int
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-13 22:53:38 +02:00
|
|
|
|
fn new_tcp_socket(family AddrFamily) ?TcpSocket {
|
|
|
|
|
handle := socket_error(C.socket(family, SocketType.tcp, 0)) ?
|
2021-01-20 11:11:01 +01:00
|
|
|
|
mut s := TcpSocket{
|
2021-06-13 22:53:38 +02:00
|
|
|
|
handle: handle
|
2021-04-23 13:37:05 +02:00
|
|
|
|
}
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln(' new_tcp_socket | s.handle: ${s.handle:6}')
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-13 22:53:38 +02:00
|
|
|
|
// TODO(emily):
|
|
|
|
|
// we shouldnt be using ioctlsocket in the 21st century
|
|
|
|
|
// use the non-blocking socket option instead please :)
|
|
|
|
|
|
|
|
|
|
// TODO(emily):
|
|
|
|
|
// Move this to its own function on the socket
|
2021-04-23 16:12:13 +02:00
|
|
|
|
s.set_option_int(.reuse_addr, 1) ?
|
2021-08-27 12:10:34 +02:00
|
|
|
|
|
|
|
|
|
$if !net_blocking_sockets ? {
|
|
|
|
|
$if windows {
|
|
|
|
|
t := u32(1) // true
|
|
|
|
|
socket_error(C.ioctlsocket(handle, fionbio, &t)) ?
|
|
|
|
|
} $else {
|
|
|
|
|
socket_error(C.fcntl(handle, C.F_SETFL, C.fcntl(handle, C.F_GETFL) | C.O_NONBLOCK)) ?
|
|
|
|
|
}
|
2021-04-23 16:12:13 +02:00
|
|
|
|
}
|
2020-11-15 21:54:47 +01:00
|
|
|
|
return s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn tcp_socket_from_handle(sockfd int) ?TcpSocket {
|
2021-01-20 11:11:01 +01:00
|
|
|
|
mut s := TcpSocket{
|
2020-11-15 21:54:47 +01:00
|
|
|
|
handle: sockfd
|
|
|
|
|
}
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if trace_tcp ? {
|
|
|
|
|
eprintln(' tcp_socket_from_handle | s.handle: ${s.handle:6}')
|
|
|
|
|
}
|
2021-04-23 16:12:13 +02:00
|
|
|
|
// s.set_option_bool(.reuse_addr, true)?
|
|
|
|
|
s.set_option_int(.reuse_addr, 1) ?
|
2021-06-13 22:53:38 +02:00
|
|
|
|
s.set_dualstack(true) or {
|
|
|
|
|
// Not ipv6, we dont care
|
|
|
|
|
}
|
2021-08-27 12:10:34 +02:00
|
|
|
|
$if !net_blocking_sockets ? {
|
|
|
|
|
$if windows {
|
|
|
|
|
t := u32(1) // true
|
|
|
|
|
socket_error(C.ioctlsocket(sockfd, fionbio, &t)) ?
|
|
|
|
|
} $else {
|
|
|
|
|
socket_error(C.fcntl(sockfd, C.F_SETFL, C.fcntl(sockfd, C.F_GETFL) | C.O_NONBLOCK)) ?
|
|
|
|
|
}
|
2021-04-23 16:12:13 +02:00
|
|
|
|
}
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return s
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut s TcpSocket) set_option_bool(opt SocketOption, value bool) ? {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
// 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
|
|
|
|
|
// }
|
2021-03-18 15:23:29 +01:00
|
|
|
|
x := int(value)
|
|
|
|
|
socket_error(C.setsockopt(s.handle, C.SOL_SOCKET, int(opt), &x, sizeof(int))) ?
|
2021-06-13 22:53:38 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn (mut s TcpSocket) set_dualstack(on bool) ? {
|
|
|
|
|
x := int(!on)
|
|
|
|
|
socket_error(C.setsockopt(s.handle, C.IPPROTO_IPV6, int(SocketOption.ipv6_only), &x,
|
|
|
|
|
sizeof(int))) ?
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (mut s TcpSocket) set_option_int(opt SocketOption, value int) ? {
|
2020-12-15 16:39:11 +01:00
|
|
|
|
socket_error(C.setsockopt(s.handle, C.SOL_SOCKET, int(opt), &value, sizeof(int))) ?
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
fn (mut s TcpSocket) close() ? {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return shutdown(s.handle)
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-20 11:11:01 +01:00
|
|
|
|
fn (mut s TcpSocket) @select(test Select, timeout time.Duration) ?bool {
|
2020-08-20 23:01:37 +02:00
|
|
|
|
return @select(s.handle, test, timeout)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const (
|
|
|
|
|
connect_timeout = 5 * time.second
|
|
|
|
|
)
|
|
|
|
|
|
2021-06-13 22:53:38 +02:00
|
|
|
|
fn (mut s TcpSocket) connect(a Addr) ? {
|
|
|
|
|
res := C.connect(s.handle, voidptr(&a), a.len())
|
2020-08-20 23:01:37 +02:00
|
|
|
|
if res == 0 {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
|
|
|
|
|
// The socket is nonblocking and the connection cannot be completed
|
|
|
|
|
// immediately. (UNIX domain sockets failed with EAGAIN instead.)
|
|
|
|
|
// It is possible to select(2) or poll(2) for completion by selecting
|
|
|
|
|
// the socket for writing. After select(2) indicates writability,
|
|
|
|
|
// use getsockopt(2) to read the SO_ERROR option at level SOL_SOCKET to
|
|
|
|
|
// determine whether connect() completed successfully (SO_ERROR is zero) or
|
|
|
|
|
// unsuccessfully (SO_ERROR is one of the usual error codes listed here,
|
|
|
|
|
// ex‐ plaining the reason for the failure).
|
2021-01-26 15:43:10 +01:00
|
|
|
|
write_result := s.@select(.write, net.connect_timeout) ?
|
2020-11-15 21:54:47 +01:00
|
|
|
|
if write_result {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
err := 0
|
|
|
|
|
len := sizeof(err)
|
|
|
|
|
socket_error(C.getsockopt(s.handle, C.SOL_SOCKET, C.SO_ERROR, &err, &len)) ?
|
|
|
|
|
|
|
|
|
|
if err != 0 {
|
|
|
|
|
return wrap_error(err)
|
|
|
|
|
}
|
|
|
|
|
// Succeeded
|
|
|
|
|
return
|
2020-11-15 21:54:47 +01:00
|
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
|
|
|
|
|
|
// Get the error
|
|
|
|
|
socket_error(C.connect(s.handle, voidptr(&a), a.len())) ?
|
|
|
|
|
|
2020-11-15 21:54:47 +01:00
|
|
|
|
// otherwise we timed out
|
|
|
|
|
return err_connect_timed_out
|
2020-08-20 23:01:37 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// address gets the address of a socket
|
2021-01-20 11:11:01 +01:00
|
|
|
|
pub fn (s &TcpSocket) address() ?Addr {
|
2021-06-13 22:53:38 +02:00
|
|
|
|
return addr_from_socket_handle(s.handle)
|
2020-08-22 17:09:22 +02:00
|
|
|
|
}
|