reversehttp

package main


import (
	"flag"
	"fmt"
	"log"
	"net"
	"net/http"
	"io")

func ReverseListen(network, addr string) (*DialListen, error) {
	var d *DialListen
	var err error
	var client net.Conn
	d = new(DialListen)
	client, err = net.Dial(network, addr)
		if err != nil {
			return nil, err
		}

	d.fauxclose = make(chan net.Conn)
	d.realclose = make(chan struct{})
	d.client = client
	go func() {
		d.fauxclose <- client
	}()
	return d, nil
}	

type DialListen struct {
	client net.Conn
	fauxclose chan net.Conn
	realclose chan struct{}
}

type stayOpen struct {
	*DialListen
	net.Conn
}

func (s stayOpen) Close() error {
	log.Println("I will not close really, but I will signal on a chan")
	log.Printf("%+v", s.client)
	one := make([]byte, 1)
	_, err := s.client.Read(one)
	if err != nil {
		s.realclose <- struct{}{}
		return nil
	}
	s.fauxclose <- s.client
	return nil
}

func (d *DialListen) Accept() (net.Conn, error) {
	select {
	case client := <-d.fauxclose :
		return stayOpen{DialListen: d, Conn: client}, nil
	case <-d.realclose:
		
	}
	return nil, fmt.Errorf("no more clients in the channel")
}

func (d *DialListen) Addr() net.Addr {
	return d.client.LocalAddr()
}

func (d *DialListen) Close() error {
	var err error
	close(d.fauxclose)
	err = d.client.Close()
	return err
}

var (
	ntype = flag.String("ntype", "tcp4", "Default network type")
	naddr = flag.String("addr", ":8090", "Network address")
)

func main() {
	flag.Parse()
	ln, err := ReverseListen(*ntype, *naddr)
	if err != nil {
		log.Fatal(err)
	}
	http.HandleFunc("/foo", func (w http.ResponseWriter, req *http.Request) {
		io.WriteString(w, "hello wooooooo\n")
	})
	http.Serve(ln, nil)

	
}