Simple TCP proxy in Golang

proxy.go

package main

import (
	"bytes"
	"encoding/hex"
	"flag"
	"fmt"
	"io"
	"log"
	"net"
)

var localAddr *string = flag.String("l", "localhost:9999", "local address")
var remoteAddr *string = flag.String("r", "localhost:80", "remote address")

func proxyConn(conn *net.TCPConn) {
	rAddr, err := net.ResolveTCPAddr("tcp", *remoteAddr)
	if err != nil {
		panic(err)
	}

	rConn, err := net.DialTCP("tcp", nil, rAddr)
	if err != nil {
		panic(err)
	}
	defer rConn.Close()

	buf := &bytes.Buffer{}
	for {
		data := make([]byte, 256)
		n, err := conn.Read(data)
		if err != nil {
			panic(err)
		}
		buf.Write(data[:n])
		if data[0] == 13 && data[1] == 10 {
			break
		}
	}

	if _, err := rConn.Write(buf.Bytes()); err != nil {
		panic(err)
	}
	log.Printf("sent:\n%v", hex.Dump(buf.Bytes()))

	data := make([]byte, 1024)
	n, err := rConn.Read(data)
	if err != nil {
		if err != io.EOF {
			panic(err)
		} else {
			log.Printf("received err: %v", err)
		}
	}
	log.Printf("received:\n%v", hex.Dump(data[:n]))
}

func handleConn(in <-chan *net.TCPConn, out chan<- *net.TCPConn) {
	for conn := range in {
		proxyConn(conn)
		out <- conn
	}
}

func closeConn(in <-chan *net.TCPConn) {
	for conn := range in {
		conn.Close()
	}
}

func main() {
	flag.Parse()

	fmt.Printf("Listening: %v\nProxying: %v\n\n", *localAddr, *remoteAddr)

	addr, err := net.ResolveTCPAddr("tcp", *localAddr)
	if err != nil {
		panic(err)
	}

	listener, err := net.ListenTCP("tcp", addr)
	if err != nil {
		panic(err)
	}

	pending, complete := make(chan *net.TCPConn), make(chan *net.TCPConn)

	for i := 0; i < 5; i++ {
		go handleConn(pending, complete)
	}
	go closeConn(complete)

	for {
		conn, err := listener.AcceptTCP()
		if err != nil {
			panic(err)
		}
		pending <- conn
	}
}

You may want to replace

if data[0] == 13 && data[1] == 10

with

if data[0] == '\r' && data[1] == '\n'

to make it less magical :-)

Forked this to https://github.com/lumanetworks/go-tcp-proxy

Thanks for the code.
come of my comments

• serializing read then write does not seem to be necessary. You can do something like

go io.Copy(src, dst)
go io.Copy(dst, src)

• write only contents before "\r\n" seems strange to me. io.EOF seems a better ending signal.

I'm trying to create a simple proxy that redirects based on the request hostname.
Using this approach, is there a way to figure out which hostname, instead of ip, the local connection arrived at?

answer to tscolari's question: you can do something like that

req, err := http.ReadRequest(bufio.NewReader(conn))
            if err != nil {
                log.Error("Failed to get request from conn: ", err)
            } 
                host, _, err := net.SplitHostPort(req.Host)
                if err != nil {
                    log.Error("Failed to SplitHostPort: ", err)
                }
                ...

Hi, I'm trying to run this gist, and it seems to me that Line 31 is blocking. It keeps waiting for data to be available on the connection, instead of immediately returning an EOF. I'm pretty sure conn.Read(data) has never blocked previously, so I'm trying to figure out if this is a bug on my computer. The only part of the code that I've modified is on Line 14, where I've replaced localhost:80 with google.com:80. If it helps, I'm on OS X 10.11.4, and on Golang 1.6.2.

I've also tried running it on an ubuntu image, inside a docker container on my Mac, but the problem seems to persist. Can anyone help me out here?

Bagai mana cara gratis internet open vpn xl