package main

import (
	"fmt"
	"log"
	"net"
	"syscall"
	"time"
)

func main() {
	client, server, err := makeTCPConns()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()
	defer server.Close()

	err = client.SetDeadline(time.Now())
	if err != nil {
		log.Fatal(err)
	}

	scClient, err := client.(syscall.Conn).SyscallConn()
	if err != nil {
		log.Fatal(err)
	}

	var n int
	scClient.Read(func(fd uintptr) (done bool) {
		n, err = syscall.Read(int(fd), make([]byte, 64))
		return true
	})
	fmt.Println(n, err) // => 0 <nil>

	scClient.Write(func(fd uintptr) (done bool) {
		n, err = syscall.Write(int(fd), make([]byte, 64))
		return true
	})
	fmt.Println(n, err) // => 0 <nil>

}

func makeTCPConns() (client, server net.Conn, err error) {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		return nil, nil, err
	}
	defer ln.Close()

	type acceptResultT struct {
		conn net.Conn
		err  error
	}
	acceptChan := make(chan acceptResultT)

	go func() {
		conn, err := ln.Accept()
		acceptChan <- acceptResultT{conn: conn, err: err}
	}()

	client, err = net.Dial("tcp", ln.Addr().String())
	if err != nil {
		return nil, nil, err
	}

	acceptResult := <-acceptChan
	err = acceptResult.err
	if err != nil {
		return nil, nil, err
	}

	server = acceptResult.conn

	return client, server, nil
}