diff --git a/proxy/kcp/kcp.go b/proxy/kcp/kcp.go
index 0ce6ed2..3cd1215 100644
--- a/proxy/kcp/kcp.go
+++ b/proxy/kcp/kcp.go
@@ -139,20 +139,16 @@ func NewKCPDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
 func NewKCPServer(s string, p proxy.Proxy) (proxy.Server, error) {
 	transport := strings.Split(s, ",")
 
-	// prepare transport listener
-	// TODO: check here
-	if len(transport) < 2 {
-		return nil, errors.New("[kcp] malformd listener:" + s)
-	}
-
 	k, err := NewKCP(transport[0], nil, p)
 	if err != nil {
 		return nil, err
 	}
 
-	k.server, err = proxy.ServerFromURL(transport[1], p)
-	if err != nil {
-		return nil, err
+	if len(transport) > 1 {
+		k.server, err = proxy.ServerFromURL(transport[1], p)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return k, nil
@@ -190,11 +186,30 @@ func (s *KCP) ListenAndServe() {
 
 // Serve serves connections.
 func (s *KCP) Serve(c net.Conn) {
-	// we know the internal server will close the connection after serve
-	// defer c.Close()
-
 	if s.server != nil {
 		s.server.Serve(c)
+		return
+	}
+
+	defer c.Close()
+
+	rc, dialer, err := s.proxy.Dial("tcp", "")
+	if err != nil {
+		log.F("[kcp] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, dialer.Addr(), err)
+		s.proxy.Record(dialer, false)
+		return
+	}
+
+	defer rc.Close()
+
+	log.F("[kcp] %s <-> %s", c.RemoteAddr(), dialer.Addr())
+
+	if err = proxy.Relay(c, rc); err != nil {
+		log.F("[kcp] %s <-> %s, relay error: %v", c.RemoteAddr(), dialer.Addr(), err)
+		// record remote conn failure only
+		if !strings.Contains(err.Error(), s.addr) {
+			s.proxy.Record(dialer, false)
+		}
 	}
 }
 
diff --git a/proxy/tls/tls.go b/proxy/tls/tls.go
index bd4d43d..5e7f9d9 100644
--- a/proxy/tls/tls.go
+++ b/proxy/tls/tls.go
@@ -85,12 +85,6 @@ func NewTLSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
 func NewTLSServer(s string, p proxy.Proxy) (proxy.Server, error) {
 	transport := strings.Split(s, ",")
 
-	// prepare transport listener
-	// TODO: check here
-	if len(transport) < 2 {
-		return nil, errors.New("[tls] malformd listener:" + s)
-	}
-
 	t, err := NewTLS(transport[0], nil, p)
 	if err != nil {
 		return nil, err
@@ -111,9 +105,11 @@ func NewTLSServer(s string, p proxy.Proxy) (proxy.Server, error) {
 		MinVersion:   stdtls.VersionTLS12,
 	}
 
-	t.server, err = proxy.ServerFromURL(transport[1], p)
-	if err != nil {
-		return nil, err
+	if len(transport) > 1 {
+		t.server, err = proxy.ServerFromURL(transport[1], p)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return t, nil
@@ -142,13 +138,32 @@ func (s *TLS) ListenAndServe() {
 }
 
 // Serve serves a connection.
-func (s *TLS) Serve(c net.Conn) {
-	// we know the internal server will close the connection after serve
-	// defer c.Close()
+func (s *TLS) Serve(cc net.Conn) {
+	c := stdtls.Server(cc, s.config)
 
 	if s.server != nil {
-		cc := stdtls.Server(c, s.config)
-		s.server.Serve(cc)
+		s.server.Serve(c)
+		return
+	}
+
+	defer c.Close()
+
+	rc, dialer, err := s.proxy.Dial("tcp", "")
+	if err != nil {
+		log.F("[tls] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, dialer.Addr(), err)
+		s.proxy.Record(dialer, false)
+		return
+	}
+	defer rc.Close()
+
+	log.F("[tls] %s <-> %s", c.RemoteAddr(), dialer.Addr())
+
+	if err = proxy.Relay(c, rc); err != nil {
+		log.F("[tls] %s <-> %s, relay error: %v", c.RemoteAddr(), dialer.Addr(), err)
+		// record remote conn failure only
+		if !strings.Contains(err.Error(), s.addr) {
+			s.proxy.Record(dialer, false)
+		}
 	}
 }
 
diff --git a/proxy/ws/server.go b/proxy/ws/server.go
index 9fcb52f..3715f88 100644
--- a/proxy/ws/server.go
+++ b/proxy/ws/server.go
@@ -20,20 +20,16 @@ func init() {
 func NewWSServer(s string, p proxy.Proxy) (proxy.Server, error) {
 	transport := strings.Split(s, ",")
 
-	// prepare transport listener
-	// TODO: check here
-	if len(transport) < 2 {
-		return nil, errors.New("[ws] malformd listener:" + s)
-	}
-
 	w, err := NewWS(transport[0], nil, p)
 	if err != nil {
 		return nil, err
 	}
 
-	w.server, err = proxy.ServerFromURL(transport[1], p)
-	if err != nil {
-		return nil, err
+	if len(transport) > 1 {
+		w.server, err = proxy.ServerFromURL(transport[1], p)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	return w, nil
@@ -62,18 +58,39 @@ func (s *WS) ListenAndServe() {
 }
 
 // Serve serves a connection.
-func (s *WS) Serve(c net.Conn) {
-	// we know the internal server will close the connection after serve
-	// defer c.Close()
+func (s *WS) Serve(cc net.Conn) {
+	c, err := s.NewServerConn(cc)
+	if err != nil {
+		log.F("[ws] handshake error: %s", err)
+		return
+	}
 
 	if s.server != nil {
-		sc, err := s.NewServerConn(c)
-		if err != nil {
-			log.F("[ws] handshake error: %s", err)
-			return
-		}
-		s.server.Serve(sc)
+		s.server.Serve(c)
+		return
 	}
+
+	defer c.Close()
+
+	rc, dialer, err := s.proxy.Dial("tcp", "")
+	if err != nil {
+		log.F("[ws] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, dialer.Addr(), err)
+		s.proxy.Record(dialer, false)
+		return
+	}
+
+	defer rc.Close()
+
+	log.F("[ws] %s <-> %s", c.RemoteAddr(), dialer.Addr())
+
+	if err = proxy.Relay(c, rc); err != nil {
+		log.F("[ws] %s <-> %s, relay error: %v", c.RemoteAddr(), dialer.Addr(), err)
+		// record remote conn failure only
+		if !strings.Contains(err.Error(), s.addr) {
+			s.proxy.Record(dialer, false)
+		}
+	}
+
 }
 
 // ServerConn is a connection to ws client.