client / reverse proxy

package main

import (
    "net"
    "fmt"
    "./socks5"
    "golang.org/x/net/context"
    "io"
    "time"
    "flag"
)

type DNSResolverSimple struct {

}

func (d DNSResolverSimple) Resolve(ctx context.Context, name string) (context.Context, net.IP, error) {
    addr, err := net.ResolveIPAddr("ip", name)
    if err != nil {
        return ctx, nil, err
    }
    return ctx, addr.IP, err
}


func Socks5Server(socksHost string){

    // Create a SOCKS5 server
    drslv := DNSResolverSimple{}
    conf := &socks5.Config{
        Resolver: drslv,
    }
    server, err := socks5.New(conf)
    if err != nil {
        fmt.Println(err)
        return
    }

    // Create SOCKS5 proxy on localhost port 8000
    if err := server.ListenAndServe("tcp", socksHost); err != nil {
        fmt.Println(err) // panic(err)
        return
    }

}

func Forward(dst net.Conn, src net.Conn) {
    for {
        fmt.Println("*** Start forwarding ***")

        go func() {
            written, err := io.Copy(src, dst)
            if err != nil || written <= 0{
                fmt.Println("*** Forwarding copy error ***")
                src.Close()
                return
            }
        }()
        written, err := io.Copy(dst, src)

        if err != nil || written <= 0{
            fmt.Println("*** Forwarding copy error ***")
            return
        }
        fmt.Println("*** Finished forwarding ***")
    }
}

func main() {

    flgRemoteHost := flag.String("r", "", "Address of remote host")
    flgLocalSocks5 := flag.String("s", "", "Port / Address of local SOCKS proxy")
    flag.Parse()

    if *flgRemoteHost == "" {
        fmt.Println("Invalid remote host")
        return
    }

    if *flgLocalSocks5 == "" {
        fmt.Println("Invalid local SOCKS5 server address")
        return
    }
    fmt.Println("*** Start SOCKS5 server ***")
    go Socks5Server(*flgLocalSocks5)

    // Wait for the socks5 server to start...
    time.Sleep(3 * time.Second)

    fmt.Println("*** Connect to remote server ***")
    connRemote, errConnRemote := net.Dial("tcp", *flgRemoteHost)
    connLocalSocks, errConnSocks := net.Dial("tcp", *flgLocalSocks5)

    if errConnSocks != nil {
        fmt.Println(errConnSocks)
        return
    }
    if errConnRemote != nil {
        fmt.Println(errConnRemote)
        return
    }

    for {
        Forward(connLocalSocks, connRemote)
        time.Sleep(5 * time.Second)
    }
}