goproxy public server

package main

import (
    "log"
    "io"
    "net"
    "fmt"
    "flag"
    "sync"
)

type Server struct {
    QuitChan chan bool
    CltChan chan net.Conn
    UsrChan chan net.Conn
    CltServer net.Listener
    UsrServer net.Listener
    ProxyClient net.Conn
    ProxyClientStatus bool
    ProxyUser net.Conn
    LsClt string
    LsUsr string
}

func (s *Server) Init(lsClt string, lsUsr string) {

    s.QuitChan = make(chan bool, 2)
    s.CltChan = make(chan net.Conn)
    s.UsrChan = make(chan net.Conn)

    s.LsClt = lsClt
    s.LsUsr = lsUsr

    var errClt, errUsr error

    s.CltServer, errClt = net.Listen("tcp", s.LsClt) // listener for proxy client behind NAT
    s.UsrServer, errUsr = net.Listen("tcp", s.LsUsr) // listener for proxy users

    if errClt != nil {
        log.Fatalln(errClt)
    }
    if errUsr != nil {
        log.Fatalln(errUsr)
    }
    s.Serve()
}

func (s *Server) AcceptUserConn(wg sync.WaitGroup) {
    for {

        conn, err := s.UsrServer.Accept()
        if err != nil {
            log.Fatalln(err)
            fmt.Println("*** New user connection error *** ", err)
        }
        fmt.Println("*** New user connection ***")
        s.UsrChan <- conn
    }
    s.QuitChan <- true

}

func (s *Server) AcceptClientConn(wg sync.WaitGroup) {

    for {
        if s.ProxyClientStatus == false {
            cltConn, err := s.CltServer.Accept()
            if err != nil {
                log.Fatalln(err)
                fmt.Println("*** New client connection error *** ", err)
                continue
            }
            fmt.Println("*** New client connection ***")
            s.ProxyClient = cltConn
            s.ProxyClientStatus = true
        }
        s.Tunnel(wg)
    }
    s.QuitChan <- true
}

func (s *Server) Tunnel(wg sync.WaitGroup) {

    fmt.Println("*** TUNNEL User <--> Client ***")

    usrConn := <- s.UsrChan

    wg.Add(1)
    go func(wg sync.WaitGroup) {
    fmt.Println("*** Waiting  to copy to client ***")
        _, err := io.Copy(s.ProxyClient, usrConn)// !!!!This io.Copy seems not to block!!!!
        fmt.Println("*** Copied to client ***")
        if err != nil {
            fmt.Println("*** Handle request - error ***", err)
            usrConn.Close()
        }
        wg.Done()
    }(wg)
    // wg.Wait() // If this is uncommented I dont get any response to the user
    fmt.Println("*** Waiting  to copy to user ***")
    _, err := io.Copy(usrConn, s.ProxyClient) // !!!!This io.Copy blocks!!!!
    fmt.Println("*** Copied to user ***")
    if err != nil {
        mt.Println("*** Handle ProxyClient - error ***", err)
       usrConn.Close() // Is this required?
    }
    fmt.Println("*** Handle request - close user conn ***")
    usrConn.Close()

}

func (s *Server) Serve() {

    var wg sync.WaitGroup
    go s.AcceptClientConn(wg)
    go s.AcceptUserConn(wg)

    <- s.QuitChan
}

func main() {

    fmt.Println("*********** Startet ncsocks reverse proxy v3 ***********")

    flgListenClients := flag.String("lc", "", "Client listener")
    flgListenUsers := flag.String("lu", "", "User listenere")
    flag.Parse()

    if *flgListenClients == "" {
        fmt.Println("Invalid client listener")
        return
    }

    if *flgListenUsers == "" {
        fmt.Println("Invalid user listener")
        return
    }

    s := Server{}
    s.Init(*flgListenClients, *flgListenUsers)
    s.Serve()

}