init_go.sh

export PATH=$PATH:/home/zdb/go/bin
export GOROOT=/home/zdb/go
export GOOS=linux
export GOARCH=amd64

test_go.go

package main

import (
    //"crypto/rand"
    "crypto/tls"
    "fmt"
    "net"
    "os"
    "time"
)

func main() {
    cert, err := tls.LoadX509KeyPair("cacert.pem", "privkey.pem")
    checkError(err)
    config := tls.Config{Certificates: []tls.Certificate{cert}}
    //now := time.Now()
    //config.Time = func() time.Time { return now }
    //config.Rand = rand.Reader
    service := "0.0.0.0:51888"
    listener, err := tls.Listen("tcp4", service, &config)
    checkError(err)
    fmt.Println("Listening")
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println(err.Error())
            continue
        }
        fmt.Println("Accepted")
        go handleClient(conn)
    }
}

func handleClient(conn net.Conn) {
    defer conn.Close()
    var tmp_buf [4096]byte
    //conn.Write([]byte("Hello,bitch"))
    conn.SetReadDeadline(time.Now().Add(30 * time.Second))
    n, err := conn.Read(tmp_buf[0:])
    if err != nil {
        fmt.Println("any error ", err.Error())
        return
    }
    fmt.Println("receive from client len ", n)
    if n == 0 {
        fmt.Println("no data ")
        conn.SetReadDeadline(time.Now().Add(30 * time.Second))
        n, err = conn.Read(tmp_buf[0:])
        fmt.Println("n is ", n)
        if n == 0 {
            return
        }
    }
    tcpAddr, err := net.ResolveTCPAddr("tcp4", string(tmp_buf[0:n-2]))
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        return
    }
    remote,err := net.DialTCP("tcp4", nil, tcpAddr)
    defer remote.Close()
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        return
    }
    go processBack(conn,remote)
    for{
        conn.SetReadDeadline(time.Now().Add(1800 * time.Second))
        n,err := conn.Read(tmp_buf[0:])
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println("read from client length ",n)
        if( 0 == n) {
            conn.SetReadDeadline(time.Now().Add(1800 * time.Second))
            n,err = conn.Read(tmp_buf[0:])
        }
        n,err = remote.Write(tmp_buf[0:n])
        if  0 ==n {
            break
        }
    }
}

func processBack(local net.Conn,remote net.Conn) {
    defer remote.Close()
    defer local.Close()
    var tmp_buf [64*1024]byte
    for{
        remote.SetReadDeadline(time.Now().Add(1200 * time.Second))
        n,err := remote.Read(tmp_buf[0:])
        fmt.Println("read from remote len",n)
        if err != nil {
            fmt.Println(err)
        }
        n,err = local.Write(tmp_buf[0:n])
        if 0 == n {
            return
        }
    }
}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        os.Exit(1)
    }
}