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 }