module net

import io
import time
import strings

pub const tcp_default_read_timeout = 30 * time.second
pub const tcp_default_write_timeout = 30 * time.second

// TCPDialer is a concrete instance of the Dialer interface,
// for creating tcp connections.
pub struct TCPDialer {}

// dial will try to create a new abstract connection to the given address.
// It will return an error, if that is not possible.
pub fn (t TCPDialer) dial(address string) !Connection {
    return dial_tcp(address)!
}

// default_tcp_dialer will give you an instance of Dialer, that is suitable for making new tcp connections.
pub fn default_tcp_dialer() Dialer {
    return &TCPDialer{}
}

@[heap]
pub struct TcpConn {
pub mut:
    sock           TcpSocket
    handle         int
    write_deadline time.Time
    read_deadline  time.Time
    read_timeout   time.Duration
    write_timeout  time.Duration
    is_blocking    bool = true
    // last_write_sent is the exact number of bytes the most recent write_ptr
    // call sent, valid even when it then returned an error (send() is
    // byte-accurate), so a caller can tell a zero-byte failure — 0, safe to
    // replay — from a partial write. (The TLS backends expose the same field but
    // use -1 for the indeterminate case they cannot prove; plain TCP never does.)
    last_write_sent int
}

// dial_tcp will try to create a new TcpConn to the given address.
pub fn dial_tcp(oaddress string) !&TcpConn {
    mut address := oaddress
    $if windows {
        // resolving 0.0.0.0 to localhost, works on linux and macos, but not on windows, so try to emulate it:
        if address.starts_with(':::') {
            address = address.replace_once(':::', 'localhost:')
        }
        if address.starts_with('0.0.0.0:') {
            address = address.replace_once('0.0.0.0:', 'localhost:')
        }
    }
    addrs := resolve_addrs_fuzzy(address, .tcp) or {
        return error('${err.msg()}; could not resolve address ${address} in dial_tcp')
    }

    // Keep track of dialing errors that take place
    mut errs := []IError{}

    // Very simple dialer
    for addr in addrs {
        mut s := new_tcp_socket(addr.family()) or {
            return error('${err.msg()}; could not create new tcp socket in dial_tcp')
        }
        s.connect(addr) or {
            errs << err
            // Connection failed
            s.close() or { continue }
            continue
        }

        mut conn := &TcpConn{
            sock:          s
            read_timeout:  tcp_default_read_timeout
            write_timeout: tcp_default_write_timeout
        }
        // The blocking / non-blocking mode is determined before the connection is established.
        $if net_nonblocking_sockets ? {
            conn.is_blocking = false
        }
        return conn
    }

    // Once we've failed now try and explain why we failed to connect
    // to any of these addresses
    mut err_builder := strings.new_builder(1024)
    err_builder.write_string('dial_tcp failed for address ${address}\n')
    err_builder.write_string('tried addrs:\n')
    for i := 0; i < errs.len; i++ {
        addr := addrs[i]
        why := errs[i]
        err_builder.write_string('\t${addr}: ${why}\n')
    }

    // failed
    return error(err_builder.str())
}

// dial_tcp_with_bind will bind the given local address `laddr` and dial.
pub fn dial_tcp_with_bind(saddr string, laddr string) !&TcpConn {
    addrs := resolve_addrs_fuzzy(saddr, .tcp) or {
        return error('${err.msg()}; could not resolve address ${saddr} in dial_tcp_with_bind')
    }

    // Very simple dialer
    for addr in addrs {
        mut s := new_tcp_socket(addr.family()) or {
            return error('${err.msg()}; could not create new tcp socket in dial_tcp_with_bind')
        }
        s.bind(laddr) or {
            s.close() or { continue }
            continue
        }
        s.connect(addr) or {
            // Connection failed
            s.close() or { continue }
            continue
        }

        mut conn := &TcpConn{
            sock:          s
            read_timeout:  tcp_default_read_timeout
            write_timeout: tcp_default_write_timeout
        }
        // The blocking / non-blocking mode is determined before the connection is established.
        $if net_nonblocking_sockets ? {
            conn.is_blocking = false
        }
        return conn
    }
    // failed
    return error('dial_tcp_with_bind failed for address ${saddr}')
}

// close closes the tcp connection
pub fn (mut c TcpConn) close() ! {
    $if trace_tcp ? {
        eprintln('    TcpConn.close | c.sock.handle: ${c.sock.handle:6}')
    }
    c.sock.close()!
}

// read_ptr reads data from the tcp connection to the given buffer. It reads at most `len` bytes.
// It returns the number of actually read bytes, which can vary between 0 to `len`.
pub fn (c TcpConn) read_ptr(buf_ptr &u8, len int) !int {
    mut res := 0
    mut ecode := 0
    $if is_coroutine ? {
        res = C.photon_recv(c.sock.handle, voidptr(buf_ptr), len, 0, c.read_timeout)
        ecode = error_code()
    } $else {
        if c.is_blocking {
            // Honor read deadlines/timeouts first, then use a normal blocking recv.
            // This avoids transient EAGAIN-style reads on newly accepted sockets.
            c.wait_for_read()!
            res = C.recv(c.sock.handle, voidptr(buf_ptr), len, 0)
        } else {
            res = C.recv(c.sock.handle, voidptr(buf_ptr), len, msg_dontwait)
        }
        ecode = error_code()
    }
    if res == 0 {
        return io.Eof{}
    }
    if res > 0 {
        $if trace_tcp ? {
            eprintln(
                '<<< TcpConn.read_ptr  | c.sock.handle: ${c.sock.handle} | buf_ptr: ${ptr_str(buf_ptr)} | len: ${len} | res: ${res} |\n' +
                unsafe { buf_ptr.vstring_with_len(len) })
        }
        $if trace_tcp_data_read ? {
            eprintln(
                '<<< TcpConn.read_ptr  | 1 data.len: ${res:6} | hex: ${unsafe { buf_ptr.vbytes(res) }.hex()} | data: ' +
                unsafe { buf_ptr.vstring_with_len(res) })
        }
        return res
    }
    if ecode in [int(error_ewouldblock), int(error_eagain), C.EINTR] {
        c.wait_for_read()!
        res = $if is_coroutine ? {
            C.photon_recv(c.sock.handle, voidptr(buf_ptr), len, 0, c.read_timeout)
        } $else {
            if c.is_blocking {
                C.recv(c.sock.handle, voidptr(buf_ptr), len, 0)
            } else {
                C.recv(c.sock.handle, voidptr(buf_ptr), len, msg_dontwait)
            }
        }
        if res == 0 {
            return io.Eof{}
        }
        $if trace_tcp ? {
            eprintln(
                '<<< TcpConn.read_ptr  | c.sock.handle: ${c.sock.handle} | buf_ptr: ${ptr_str(buf_ptr)} | len: ${len} | res: ${res} | code: ${ecode} |\n' +
                unsafe { buf_ptr.vstring_with_len(len) })
        }
        $if trace_tcp_data_read ? {
            if res > 0 {
                eprintln(
                    '<<< TcpConn.read_ptr  | 2 data.len: ${res:6} | hex: ${unsafe { buf_ptr.vbytes(res) }.hex()} | data: ' +
                    unsafe { buf_ptr.vstring_with_len(res) })
            }
        }
        return socket_error(res)
    } else {
        wrap_error(ecode)!
    }
    return error('none')
}

// read reads data from the tcp connection into the mutable buffer `buf`.
// The number of bytes read is limited to the length of the buffer `buf.len`.
// The returned value is the number of read bytes (between 0 and `buf.len`).
pub fn (c TcpConn) read(mut buf []u8) !int {
    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 error('none')
}

// write_ptr blocks and attempts to write all data
pub fn (mut c TcpConn) write_ptr(b &u8, len int) !int {
    $if trace_tcp_sock_handle ? {
        eprintln('>>> TcpConn.write_ptr | c: ${ptr_str(c)} | c.sock.handle: ${c.sock.handle} | b: ${ptr_str(b)} | len: ${len}')
    }
    $if trace_tcp ? {
        eprintln(
            '>>> TcpConn.write_ptr | c.sock.handle: ${c.sock.handle} | b: ${ptr_str(b)} len: ${len} |\n' +
            unsafe { b.vstring_with_len(len) })
    }
    $if trace_tcp_data_write ? {
        eprintln(
            '>>> TcpConn.write_ptr | data.len: ${len:6} | hex: ${unsafe { b.vbytes(len) }.hex()} | data: ' +
            unsafe { b.vstring_with_len(len) })
    }
    c.last_write_sent = 0
    unsafe {
        mut ptr_base := &u8(b)
        mut total_sent := 0
        for total_sent < len {
            ptr := ptr_base + total_sent
            remaining := len - total_sent
            mut sent := $if is_coroutine ? {
                C.photon_send(c.sock.handle, ptr, remaining, msg_nosignal, c.write_timeout)
            } $else {
                C.send(c.sock.handle, ptr, remaining, msg_nosignal)
            }
            code := error_code()
            $if trace_tcp_data_write ? {
                eprintln('>>> TcpConn.write_ptr | data chunk, total_sent: ${total_sent:6}, remaining: ${remaining:6}, ptr: ${voidptr(ptr):x} => sent: ${sent:6}')
            }
            if sent < 0 {
                $if trace_tcp_send_failures ? {
                    eprintln('>>> TcpConn.write_ptr | send_failure, data.len: ${len:6}, total_sent: ${total_sent:6}, remaining: ${remaining:6}, ptr: ${voidptr(ptr):x}, c.write_timeout: ${c.write_timeout:3} => sent: ${sent:6}, error code: ${code:3}')
                }
                if code in [int(error_ewouldblock), int(error_eagain), C.EINTR] {
                    c.wait_for_write()!
                    continue
                } else {
                    wrap_error(code)!
                }
            }
            total_sent += sent
            c.last_write_sent = total_sent
        }
        return total_sent
    }
}

// write blocks and attempts to write all data
pub fn (mut c TcpConn) write(bytes []u8) !int {
    return c.write_ptr(bytes.data, bytes.len)
}

// 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)
}

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

pub fn (mut c TcpConn) write_deadline() !time.Time {
    if c.write_deadline.unix() == 0 {
        return c.write_deadline
    }
    return error('none')
}

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

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

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

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

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

@[inline]
pub fn (c TcpConn) wait_for_read() ! {
    return wait_for_read(c.sock.handle, c.read_deadline, c.read_timeout)
}

@[inline]
pub fn (mut c TcpConn) wait_for_write() ! {
    return wait_for_write(c.sock.handle, c.write_deadline, c.write_timeout)
}

// set_sock initialises the c.sock field. It should be called after `.accept_only()!`.
// Note: just use `.accept()!`. In most cases it is simpler, and calls `.set_sock()!` for you.
pub fn (mut c TcpConn) set_sock() ! {
    c.sock = tcp_socket_from_handle(c.handle)!
    $if trace_tcp ? {
        eprintln('    TcpListener.accept | << new_sock.handle: ${c.handle:6}')
    }
}

// peer_addr retrieves the ip address and port number used by the peer
pub fn (c &TcpConn) peer_addr() !Addr {
    return peer_addr_from_socket_handle(c.sock.handle)
}

// peer_ip retrieves the ip address used by the peer, and returns it as a string
pub fn (c &TcpConn) peer_ip() !string {
    address := c.peer_addr()!.str()
    if address.contains(']:') {
        // ipv6 addresses similar to this: '[::1]:46098'
        ip := address.all_before(']:').all_after('[')
        return ip
    }
    // ipv4 addresses similar to '127.0.0.1:7346'
    ip := address.all_before(':')
    return ip
}

pub fn (c &TcpConn) addr() !Addr {
    return c.sock.address()
}

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} }'
}

pub struct TcpListener {
pub mut:
    sock            TcpSocket
    accept_timeout  time.Duration
    accept_deadline time.Time
    is_blocking     bool = true
}

@[params]
pub struct ListenOptions {
pub:
    dualstack bool = true
    backlog   int  = 128
}

pub fn listen_tcp(family AddrFamily, saddr string, options ListenOptions) !&TcpListener {
    if family !in [.ip, .ip6] {
        return error('listen_tcp only supports ip and ip6')
    }
    return listen_tcp_with_family(family, saddr, options) or {
        if should_fallback_to_ipv4_listener(family, saddr, options, err.code()) {
            fallback_saddr := ipv4_fallback_listen_addr(saddr) or { return err }
            return listen_tcp_with_family(.ip, fallback_saddr, options)
        }
        return err
    }
}

fn should_fallback_to_ipv4_listener(family AddrFamily, saddr string, options ListenOptions, err_code int) bool {
    // Treat an unspecified IPv6 listener as "dual stack if available, otherwise IPv4 only".
    if family != .ip6 || !options.dualstack {
        return false
    }
    if !is_unspecified_ip6_listen_addr(saddr) {
        return false
    }
    return is_ipv6_unavailable_error(err_code)
}

fn is_unspecified_ip6_listen_addr(saddr string) bool {
    address, _ := split_address(saddr) or { return false }
    return address in ['', '::']
}

fn is_ipv6_unavailable_error(err_code int) bool {
    $if windows {
        return err_code in [int(WsaError.wsaeafnosupport), int(WsaError.wsaeprotonosupport),
            int(WsaError.wsaeaddrnotavail)]
    } $else {
        return err_code in [C.EAFNOSUPPORT, C.EPROTONOSUPPORT, C.EADDRNOTAVAIL]
    }
}

fn ipv4_fallback_listen_addr(saddr string) !string {
    _, port := split_address(saddr)!
    return ':${port}'
}

fn listen_tcp_with_family(family AddrFamily, saddr string, options ListenOptions) !&TcpListener {
    mut s := new_tcp_socket(family) or { return error('${err.msg()}; could not create new socket') }
    s.set_dualstack(options.dualstack) or {}

    addrs := resolve_addrs(saddr, family, .tcp) or {
        return error('${err.msg()}; could not resolve address ${saddr}')
    }
    // TODO(logic to pick here)
    addr := addrs[0]

    // cast to the correct type
    alen := addr.len()
    socket_error_message(C.bind(s.handle, voidptr(&addr), alen), 'binding to ${saddr} failed')!
    mut res := C.listen(s.handle, options.backlog)
    if res == 0 {
        mut listener := &TcpListener{
            sock:            s
            accept_deadline: no_deadline
            accept_timeout:  infinite_timeout
        }
        // The blocking / non-blocking mode is determined before the connection is established.
        $if net_nonblocking_sockets ? {
            listener.is_blocking = false
        }
        return listener
    }

    $if !net_nonblocking_sockets ? {
        socket_error_message(res,
            'listening on ${saddr} with maximum backlog pending queue of ${options.backlog}, failed')!
        return &TcpListener(unsafe { nil }) // for compiler passed
    } $else {
        // non-blocking sockets may also not succeed immediately when they listen() and need to check the status and take action accordingly.
        for {
            code := error_code()
            if code in [int(error_einprogress), int(error_ewouldblock), int(error_eagain), C.EINTR] {
                select(s.handle, .read, connect_timeout)!
                res = C.listen(s.handle, options.backlog)
                if res == 0 {
                    break
                }
            } else {
                socket_error_message(res,
                    'listening on ${saddr} with maximum backlog pending queue of ${options.backlog}, failed')!
                break // for compiler passed
            }
        }
        mut listener := &TcpListener{
            sock:            s
            accept_deadline: no_deadline
            accept_timeout:  infinite_timeout
        }
        // The blocking / non-blocking mode is determined before the connection is established.
        $if net_nonblocking_sockets ? {
            listener.is_blocking = false
        }
        return listener
    }
}

// accept a tcp connection from an external source to the listener `l`.
pub fn (mut l TcpListener) accept() !&TcpConn {
    mut res := l.accept_only()!
    res.set_sock()!
    return res
}

// accept_only accepts a tcp connection from an external source to the listener `l`.
// Unlike `accept`, `accept_only` *will not call* `.set_sock()!` on the result,
// and is thus faster.
//
// Note: you *need* to call `.set_sock()!` manually, before using the
// connection after calling `.accept_only()!`, but that does not have to happen
// in the same thread that called `.accept_only()!`.
// The intention of this API, is to have a more efficient way to accept
// connections, that are later processed by a thread pool, while the main
// thread remains active, so that it can accept other connections.
// See also vlib/veb/veb.v .
//
// If you do not need that, just call `.accept()!` instead, which will call
// `.set_sock()!` for you.
pub fn (mut l TcpListener) accept_only() !&TcpConn {
    $if trace_tcp ? {
        eprintln('    TcpListener.accept | l.sock.handle: ${l.sock.handle:6}')
    }

    // The blocking mode `accept()` does not support a timeout option, so `select` is used instead.
    $if !is_coroutine ? {
        if l.is_blocking {
            l.wait_for_accept()!
        }
    }

    mut new_handle := $if is_coroutine ? {
        C.photon_accept(l.sock.handle, 0, 0, tcp_default_read_timeout)
    } $else {
        C.accept(l.sock.handle, 0, 0)
    }
    code := error_code()
    if !l.is_blocking && new_handle <= 0 {
        if code in [int(error_einprogress), int(error_ewouldblock), int(error_eagain), C.EINTR] {
            l.wait_for_accept()!
            new_handle = $if is_coroutine ? {
                C.photon_accept(l.sock.handle, 0, 0, tcp_default_read_timeout)
            } $else {
                C.accept(l.sock.handle, 0, 0)
            }
        }
    }
    if new_handle <= 0 {
        return error('accept failed')
    }

    return &TcpConn{
        handle:        new_handle
        read_timeout:  tcp_default_read_timeout
        write_timeout: tcp_default_write_timeout
        is_blocking:   l.is_blocking
    }
}

pub fn (c &TcpListener) accept_deadline() !time.Time {
    if c.accept_deadline.unix() != 0 {
        return c.accept_deadline
    }
    return error('invalid deadline')
}

pub fn (mut c TcpListener) set_accept_deadline(deadline time.Time) {
    c.accept_deadline = deadline
}

pub fn (c &TcpListener) accept_timeout() time.Duration {
    return c.accept_timeout
}

pub fn (mut c TcpListener) set_accept_timeout(t time.Duration) {
    c.accept_timeout = t
}

pub fn (mut c TcpListener) wait_for_accept() ! {
    return wait_for_read(c.sock.handle, c.accept_deadline, c.accept_timeout)
}

pub fn (mut c TcpListener) close() ! {
    c.sock.close()!
}

pub fn (c &TcpListener) addr() !Addr {
    return c.sock.address()
}

pub struct TcpSocket {
    Socket
}

// This is a workaround for issue https://github.com/vlang/v/issues/20858
// `noline` ensure that in `-prod` mode(CFLAG = `-O3 -flto`), gcc does not generate wrong instruction sequence
@[noinline]
pub fn new_tcp_socket(family AddrFamily) !TcpSocket {
    handle := $if is_coroutine ? {
        socket_error(C.photon_socket(i32(family), i32(SocketType.tcp), 0))!
    } $else {
        socket_error(C.socket(i32(family), i32(SocketType.tcp), 0))!
    }
    mut s := TcpSocket{
        handle: handle
    }
    $if trace_tcp ? {
        eprintln('    new_tcp_socket | s.handle: ${s.handle:6}')
    }

    // TODO(emily):
    // we shouldn't be using ioctlsocket in the 21st century
    // use the non-blocking socket option instead please :)

    // Some options need to be set before the connection is established, otherwise they will not work.
    s.set_default_options(family)!

    // Set the desired "blocking/non-blocking" mode before the connection is established,
    // and do not change it once the connection is successful.
    $if net_nonblocking_sockets ? {
        set_blocking(handle, false)!
    }
    return s
}

fn tcp_socket_from_handle(sockfd int) !TcpSocket {
    mut s := TcpSocket{
        handle: sockfd
    }
    $if trace_tcp ? {
        eprintln('    tcp_socket_from_handle | s.handle: ${s.handle:6}')
    }

    s.set_dualstack(true) or {
        // Not ipv6, we dont care
    }
    addr := addr_from_socket_handle(sockfd)
    s.set_default_options(addr.family())!

    return s
}

// tcp_socket_from_handle_raw is similar to tcp_socket_from_handle, but it does not modify any socket options
pub fn tcp_socket_from_handle_raw(sockfd int) TcpSocket {
    mut s := TcpSocket{
        handle: sockfd
    }
    $if trace_tcp ? {
        eprintln('    tcp_socket_from_handle_raw | s.handle: ${s.handle:6}')
    }
    return s
}

fn (mut s TcpSocket) set_option(level int, opt int, value int) ! {
    socket_error(C.setsockopt(s.handle, level, opt, &value, sizeof(int)))!
}

pub fn (mut s TcpSocket) 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
    // }
    x := int(value)
    s.set_option(C.SOL_SOCKET, int(opt), x)!
}

pub fn (mut s TcpSocket) set_option_int(opt SocketOption, value int) ! {
    s.set_option(C.SOL_SOCKET, int(opt), value)!
}

pub fn (mut s TcpSocket) set_dualstack(on bool) ! {
    x := int(!on)
    s.set_option(C.IPPROTO_IPV6, int(SocketOption.ipv6_only), x)!
}

fn (mut s TcpSocket) set_default_options(af AddrFamily) ! {
    s.set_option_int(.reuse_addr, 1)!

    // At the socket level to ignore the exception signal (usually SIGNPIPE).
    // In Linux, instead of using set_option(), specify the C.MSG_NOSIGNAL flag in c.send().
    // In Windows, there is no need to process this signal.
    $if macos {
        s.set_option(C.SOL_SOCKET, C.SO_NOSIGPIPE, 1)!
    }

    // Enable the NODELAY option by default.
    if af != .unix {
        s.set_option(C.IPPROTO_TCP, C.TCP_NODELAY, 1)!
    }
}

// bind a local rddress for TcpSocket
pub fn (mut s TcpSocket) bind(addr string) ! {
    addrs := resolve_addrs(addr, AddrFamily.ip, .tcp) or {
        return error('${err.msg()}; could not resolve address ${addr}')
    }

    // TODO(logic to pick here)
    a := addrs[0]

    // cast to the correct type
    alen := a.len()
    socket_error_message(C.bind(s.handle, voidptr(&a), alen), 'binding to ${addr} failed') or {
        return err
    }
}

fn (mut s TcpSocket) close() ! {
    shutdown(s.handle)
    return close(s.handle)
}

const connect_timeout = 5 * time.second

fn (mut s TcpSocket) connect(a Addr) ! {
    $if net_nonblocking_sockets ? {
        res := $if is_coroutine ? {
            C.photon_connect(s.handle, voidptr(&a), a.len(), tcp_default_read_timeout)
        } $else {
            C.connect(s.handle, voidptr(&a), a.len())
        }
        ecode := error_code()
        if res == 0 {
            return
        }
        // On nix non-blocking sockets we expect einprogress
        // On windows we expect res == -1 && error_code() == ewouldblock
        if (is_windows && ecode == int(error_ewouldblock)) || (!is_windows && res == -1
            && ecode in [int(error_einprogress), int(error_eagain), C.EINTR]) {
            // 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).
            write_result := select(s.handle, .write, connect_timeout)!
            err := 0
            len := sizeof(err)
            xyz := C.getsockopt(s.handle, C.SOL_SOCKET, C.SO_ERROR, &err, &len)
            if xyz == 0 && err == 0 {
                return
            }
            if write_result {
                if xyz == 0 {
                    wrap_error(err)!
                    return
                }
                return
            }
            return err_timed_out
        }
        wrap_error(ecode)!
        return
    } $else {
        x := $if is_coroutine ? {
            C.photon_connect(s.handle, voidptr(&a), a.len(), tcp_default_read_timeout)
        } $else {
            C.connect(s.handle, voidptr(&a), a.len())
        }
        socket_error(x)!
    }
}