func handleConnection(conn net.Conn) {
if debug {
debug.Printf("socks connect from %s\n", conn.RemoteAddr().String())
}
closed := false
defer func() {
if !closed {
conn.Close()
}
}()
var err error = nil
if err = handShake(conn); err != nil {
log.Println("socks handshake:", err)
return
}
rawaddr, addr, err := getRequest(conn)
if err != nil {
log.Println("error getting request:", err)
return
}
// Sending connection established message immediately to client.
// This some round trip time for creating socks connection with the client.
// But if connection failed, the client will get connection reset error.
_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08, 0x43})
if err != nil {
debug.Println("send connection confirmation:", err)
return
}
remote, err := createServerConn(rawaddr, addr)
if err != nil {
if len(servers.srvCipher) > 1 {
log.Println("Failed connect to all avaiable shadowsocks server")
}
return
}
defer func() {
if !closed {
remote.Close()
}
}()
debug.Println("go ss.PipeThenClose(conn, remote)")
go ss.PipeThenClose(conn, remote)
debug.Println("ss.PipeThenClose(remote, conn)")
ss.PipeThenClose(remote, conn)
closed = true
debug.Println("closed connection to", addr)
}
func handleConnection(conn net.Conn) {
if debug {
debug.Printf("socks connect from %s\n", conn.RemoteAddr().String())
}
closed := false
defer func() {
if !closed {
conn.Close()
}
}()
var err error = nil
// _ := conn.RemoteAddr().(*net.TCPAddr)
destAddr, err := getSockOriginalDst(conn)
if err != nil {
log.Printf("get original addr error. err:%v", err)
return
}
rawaddr := make([]byte, 1+4+4)
w := bytes.NewBuffer(rawaddr)
var adType int8 = 0x01
binary.Write(w, binary.BigEndian, adType)
w.Write(destAddr.IP.To4())
var port int32 = int32(destAddr.Port)
addr := destAddr.String()
binary.Write(w, binary.BigEndian, port)
remote, err := createServerConn(rawaddr, addr)
if err != nil {
if len(servers.srvCipher) > 1 {
log.Println("Failed connect to all avaiable shadowsocks server")
}
return
}
defer func() {
if !closed {
remote.Close()
}
}()
go ss.PipeThenClose(conn, remote)
ss.PipeThenClose(remote, conn)
closed = true
debug.Println("closed connection to", addr)
}
func handleConnection(conn *ss.Conn) {
var host string
connCnt++ // this maybe not accurate, but should be enough
if connCnt-nextLogConnCnt >= 0 {
// XXX There's no xadd in the atomic package, so it's difficult to log
// the message only once with low cost. Also note nextLogConnCnt maybe
// added twice for current peak connection number level.
log.Printf("Number of client connections reaches %d\n", nextLogConnCnt)
nextLogConnCnt += logCntDelta
}
// function arguments are always evaluated, so surround debug statement
// with if statement
if debug {
debug.Printf("new client %s->%s\n", conn.RemoteAddr().String(), conn.LocalAddr())
}
closed := false
defer func() {
if debug {
debug.Printf("closed pipe %s<->%s\n", conn.RemoteAddr(), host)
}
connCnt--
if !closed {
conn.Close()
}
}()
host, extra, err := getRequest(conn)
if err != nil {
log.Println("error getting request", conn.RemoteAddr(), conn.LocalAddr(), err)
return
}
debug.Println("connecting", host)
remote, err := net.Dial("tcp", host)
if err != nil {
if ne, ok := err.(*net.OpError); ok && (ne.Err == syscall.EMFILE || ne.Err == syscall.ENFILE) {
// log too many open file error
// EMFILE is process reaches open file limits, ENFILE is system limit
log.Println("dial error:", err)
} else {
log.Println("error connecting to:", host, err)
}
return
}
defer func() {
if !closed {
remote.Close()
}
}()
// write extra bytes read from
if extra != nil {
// debug.Println("getRequest read extra data, writing to remote, len", len(extra))
if _, err = remote.Write(extra); err != nil {
debug.Println("write request extra error:", err)
return
}
}
if debug {
debug.Printf("piping %s<->%s", conn.RemoteAddr(), host)
}
go ss.PipeThenClose(conn, remote, ss.SET_TIMEOUT)
ss.PipeThenClose(remote, conn, ss.NO_TIMEOUT)
closed = true
return
}
func (s ShadowsocksTransport) Start() error {
handler := server.NewHandler(s.Name)
listener, err := net.Listen("tcp", s.BindAddr)
if err != nil {
listener, err = net.Listen("tcp", "127.0.0.1:0")
}
if err != nil {
handler.PrintError("CANNOT BIND TO ANY PORT")
return errors.New("Cannot bind to any port")
}
listener = handler.MonitorListener(listener)
handler.PrintExpose("socks5", listener.Addr().String())
config := &ss.Config{
Server: s.RemoteHost,
ServerPort: s.RemotePort,
Password: s.Secret,
LocalPort: s.BindPort,
Method: "aes-256-cfb",
}
parseServerConfig(config)
handler.PrintDone()
verbose := server.NewOption("verbose")
if verbose.Has() {
s.Verbose = true
ss.SetDebug(true)
debug = true
}
go func() {
for {
defer listener.Close()
conn, err := listener.Accept()
if err != nil {
debug.Println("accept:", err)
continue
}
go func(conn net.Conn) {
conn = handler.MonitorConn(conn)
if debug {
debug.Printf("socks connect from %s\n", conn.RemoteAddr().String())
}
closed := false
defer func() {
if !closed {
conn.Close()
}
}()
var err error = nil
if err = handShake(conn); err != nil {
debug.Printf("socks handshake: %s", err)
return
}
rawaddr, addr, err := getRequest(conn)
if err != nil {
debug.Println("error getting request:", err)
return
}
// Sending connection established message immediately to client.
// This some round trip time for creating socks connection with the client.
// But if connection failed, the client will get connection reset error.
_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08, 0x43})
if err != nil {
debug.Println("send connection confirmation:", err)
return
}
remote, err := createServerConn(rawaddr, addr)
if err != nil {
if len(servers.srvCipher) > 1 {
debug.Println("Failed connect to all avaiable shadowsocks server")
}
return
}
handler.TrackOpenConn(addr)
defer func() {
if !closed {
remote.Close()
}
}()
go ss.PipeThenClose(conn, remote)
ss.PipeThenClose(remote, conn)
closed = true
handler.TrackCloseConn(addr)
}(conn)
}
}()
handler.Wait()
return nil
}
func handleConnection(conn *ss.Conn, port string, pflag *uint32, openvpn string) {
var host string
newConnCnt := atomic.AddUint64(&connCnt, 1) // connCnt++
if newConnCnt%logCntDelta == 0 {
log.Printf("Number of client connections reaches %d\n", newConnCnt)
}
// function arguments are always evaluated, so surround debug statement
// with if statement
ss.Debug.Printf("new client %s->%s\n", conn.RemoteAddr().String(), conn.LocalAddr())
closed := false
defer func() {
ss.Debug.Printf("closed pipe %s<->%s\n", conn.RemoteAddr(), host)
atomic.AddUint64(&connCnt, ^uint64(0)) // connCnt--
if !closed {
conn.Close()
}
}()
h, p, extra, err := getRequest(conn)
if err != nil {
log.Println("error getting request", conn.RemoteAddr(), conn.LocalAddr(), err)
return
}
host = h + ":" + p
ss.Debug.Println("connecting", host)
addr, err := net.ResolveIPAddr("ip", h)
if err != nil {
log.Println(err)
return
}
ip := addr.String()
if (strings.HasPrefix(ip, "127.") && (p != "1194" || openvpn != "ok")) ||
strings.HasPrefix(ip, "10.8.") || ip == "::1" {
log.Printf("illegal connect to local network(%s)\n", ip)
return
}
remote, err := net.Dial("tcp", net.JoinHostPort(ip, p))
if err != nil {
if ne, ok := err.(*net.OpError); ok && (ne.Err == syscall.EMFILE || ne.Err == syscall.ENFILE) {
// log too many open file error
// EMFILE is process reaches open file limits, ENFILE is system limit
log.Println("dial error:", err)
} else {
log.Println("error connecting to:", host, err)
}
return
}
defer func() {
if !closed {
remote.Close()
}
}()
// write extra bytes read from
if extra != nil {
// Debug.Println("getRequest read extra data, writing to remote, len", len(extra))
if _, err = remote.Write(extra); err != nil {
ss.Debug.Println("write request extra error:", err)
return
}
}
ss.Debug.Printf("ping %s<->%s", conn.RemoteAddr(), host)
go ss.PipeThenClose(conn, remote, ss.SET_TIMEOUT, pflag, port, "out")
ss.PipeThenClose(remote, conn, ss.NO_TIMEOUT, pflag, port, "in")
closed = true
return
}