gistfile1.txt

func copy(dest io.Writer, src io.Reader) int64 {
    // If dest has a ReadFrom method, we use that. This gives us zero copy
    // when copying between sockets, for example.
    if reader_from_dest, ok := dest.(io.ReaderFrom); ok {
        written, _ := reader_from_dest.ReadFrom(src)
        return written
    }

    buf := make([]byte, 1024 * 16)

    var written int64
    var err error
    
    for err == nil {
        var bytes int
        bytes, err = src.Read(buf)
        if err == nil {
            bytes, err = dest.Write(buf[:bytes])
        }
        written += int64(bytes)
    }
    return written
}


func handleConnection(client net.Conn) {
    defer client.Close()
    
    forwarded, err := net.Dial("tcp", CONNECT)
    if err != nil {
        nlog.WRN("Dial %s", err)
        return
    }
    defer forwarded.Close()
    
    start := time.Now()

    var done = make(chan int64, 1)
    go func() { done <- copy(client, forwarded) }()
    go func() { done <- copy(forwarded, client) }()
    written := <-done
    client.Close()
    forwarded.Close()
    written += <-done

    seconds := time.Since(start).Seconds()
    p := float64(written) / seconds / 1024 / 1024
    nlog.WRN("transferred %d byte: %v: %.2f MByte/sec", written, time.Since(start), p)
}