socks_server.go

package main

import (
	"bufio"
	"fmt"
	"net"
	"net/http"
)

type Reader struct {
	bufio.Reader
}

func (this *Reader) Read(b []byte) (int, error) {
	return this.Reader.Read(b)
}

func (this *Reader) MustRead(b []byte) error {
	for {
		n, err := this.Read(b)
		if err != nil {
			return err
		}
		if n != len(b) {
			b = b[n:]
		} else {
			break
		}
	}
	return nil
}

func handle(conn net.Conn) {
	defer conn.Close()
	r := &Reader{*bufio.NewReader(conn)}
	buff := make([]byte, 0xffff)
	r.MustRead(buff[:2])
	if buff[0] != 5 {
		return
	}
	r.MustRead(buff[2:2 + buff[1]])
	for i := byte(0); i < buff[1]; i++ {
		if buff[2 + i] == 0 {
			goto good
		}
	}
	return
	good:
	conn.Write([]byte{5, 0})
	var cmd byte
	var ip uint32
	var domain string
	var port uint16
	r.MustRead(buff[:4])
	for {
		if buff[0] != 5 {
			return
		}
		cmd = buff[1]
		switch ty := buff[3]; ty {
		case 1:
			r.MustRead(buff[:4])
			ip = uint32(buff[4]) << 24
			ip += uint32(buff[5]) << 16
			ip += uint32(buff[6]) << 8
			ip += uint32(buff[7])
		case 3:
			r.MustRead(buff[:1])
			r.MustRead(buff[1:1 + buff[0]])
			domain = string(buff[1:1 + buff[0]])
		default:
			print("not supported type")
			return
		}
		r.MustRead(buff[:2])
		port = uint16(buff[0]) << 8
		port = uint16(buff[1])
		if cmd == 1 {
			agt, err := net.Dial("tcp", domain + ":" + fmt.Sprint(port))
			if err != nil {
				println(err.Error())
				return
			}
			conn.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
			go func() {
				buff := make([]byte, 0xffff)
				for {
					n, err := agt.Read(buff)
					if err != nil {
						return
					}
					conn.Write(buff[:n])
				}
			}()
			for {
				n, err := conn.Read(buff)
				if err != nil {
					break
				}
				agt.Write(buff[:n])
			}
		} else {
			println("unsupported cmd")
			return
		}
	}
}

func main() {
	lis, err := net.Listen("tcp", ":1080")
	if err != nil {
		println(err.Error())
		return
	}
	for {
		conn, err := lis.Accept()
		if err != nil {
			continue
		}
		go handle(conn)
	}
}