reverse proxy sample, net.TcpConn.read() is blocking, where am i wrong?

[vcker]

HI, i am write a reverse proxy, but i found the read is blocking after original socket finished write, where am i wrong?

1. if i close socket delayed 1 second, it will get http response, but this is not regular operation.
2. net.TcpConn.read() is blocking until timeout, why do return -1 when read finished?
3. even if i used net.TcpConn.read_all(), it has same proplem

so, where am i whrong？

this is a golang reverse proxy
https://github.com/jpillora/go-tcp-proxy/blob/master/proxy.go

// file main.v
module main

import net
import io
import net.http
import time

fn main() {
	mut server := net.listen_tcp(.ip, ':9988') or { panic(err) }
	println(server.addr()!)
	// println('listen: ${server.addr()!.port()!}') // add port func

	go request()

	for {
		mut socket := server.accept()!
		spawn async_handle_socket(mut socket)
		// go fn (mut sock net.TcpConn) {
		// 	time.sleep(1000 * time.millisecond)
		// 	println('====================== close socket')
		// 	sock.close() or {
		// 		println('sock close error : ${err}')
		// 		panic(err)
		// 	}
		// }(mut socket)
	}
}

fn request() {
	println('http.get begin')
	response := http.get('http://127.0.0.1:9988') or {
		// response := http.get('http://45.56.81.220:80') or {
		println('error: ${err}')
		panic(err)
	}
	println('http.get end')
	// println(response.bytestr())
}

fn async_handle_socket(mut socket net.TcpConn) {
	println('async_handle_socket begin')
	mut ip := '45.56.81.220'
	mut port := 80
	mut con := net.dial_tcp('${ip}:${port}') or { panic(err) }
	ch1 := chan int{cap: 2}
	spawn exchange_socket2(mut socket, mut con, ch1)
	spawn exchange_socket2(mut con, mut socket, ch1)
	_ = <-ch1
	println('async_handle_socket end 1')
	_ = <-ch1
	println('async_handle_socket end  all')
}

fn exchange_socket(mut en net.TcpConn, mut out net.TcpConn, end chan int) {
	println('exchange_socket begin')
	mut buf := []u8{len: 512}
	mut num_read := 0
	mut num_write := 0
	for {
		// en.wait_for_read() or {
		// 	println('wait_for_read error: ${err}')
		//  }
		num_read = en.read(mut buf) or {
			println('error on en.read: ${err}')
			-1
		}
		// println('read num_read=${num_read}: ${buf.bytestr()}')
		println('read num_read=${num_read}')
		if num_read <= 0 {
			break
		}
		num_write = out.write_ptr(buf[0], num_read) or {
			println('write_ptr error: ${err}')

			-1
		}
		out.wait_for_write() or { println('wait_for_write error: ${err}') }
		assert num_read == num_write
	}
	println('exchange_socket end')
	// en.close() or { println('en.close error ${err}') }
	end <- 1
}

fn exchange_socket2(mut en net.TcpConn, mut out net.TcpConn, end chan int) {
	println('exchange_socket begin')
	for {
		println('read_all begin')

		mut buf := io.read_all(io.ReadAllConfig{ reader: en }) or {
			println('read_all error: ${err}')
			[]u8{}
		}
		println('read_all end')
		// println('read all: ${buf.bytestr()}')
		if buf.len == 0 {
			break
		}
		out.write(buf) or {
			println('out.write error: ${err}')
			0
		}
	}
	println('exchange_socket end')
	end <- 1
}