diff --git a/proxy/config.go b/proxy/config.go
index bbd37ac..692f5c6 100644
--- a/proxy/config.go
+++ b/proxy/config.go
@@ -10,6 +10,8 @@ type Config struct {
 
 func init() {
 	config.RegisterConfigCreator(Name, func() interface{} {
-		return new(Config)
+		return &Config{
+			LogLevel: 1,
+		}
 	})
 }
diff --git a/proxy/nat/nat.go b/proxy/nat/nat.go
index 4c3e067..a7e99e9 100644
--- a/proxy/nat/nat.go
+++ b/proxy/nat/nat.go
@@ -1,4 +1,4 @@
-// +build linux darwin
+// +build linux
 
 package nat
 
diff --git a/proxy/nat/nat_stub.go b/proxy/nat/nat_stub.go
new file mode 100644
index 0000000..06304a1
--- /dev/null
+++ b/proxy/nat/nat_stub.go
@@ -0,0 +1,5 @@
+// +build !linux
+
+package nat
+
+const Name = "NAT"
diff --git a/proxy/proxy.go b/proxy/proxy.go
index ed99f9c..e862e65 100644
--- a/proxy/proxy.go
+++ b/proxy/proxy.go
@@ -64,7 +64,6 @@ func (p *Proxy) relayConnLoop() {
 						return
 					}
 					defer outbound.Close()
-					log.Debug("relaying connection")
 					errChan := make(chan error, 2)
 					copyConn := func(a, b net.Conn) {
 						_, err := io.Copy(a, b)
@@ -77,7 +76,7 @@ func (p *Proxy) relayConnLoop() {
 					if err != nil {
 						log.Error(err)
 					}
-					log.Debug("connection relay ends")
+					log.Debug("conn relay ends")
 				}(inbound)
 			}
 		}(source)
@@ -107,7 +106,6 @@ func (p *Proxy) relayPacketLoop() {
 						return
 					}
 					defer outbound.Close()
-					log.Debug("relaying packets")
 					errChan := make(chan error, 2)
 					copyPacket := func(a, b tunnel.PacketConn) {
 						buf := make([]byte, MaxPacketSize)
@@ -172,6 +170,10 @@ func NewProxyFromConfigData(data []byte, isJSON bool) (*Proxy, error) {
 	create, ok := creators[strings.ToUpper(cfg.RunType)]
 	if !ok {
 		return nil, common.NewError("unknown proxy type: " + cfg.RunType)
+	}
+	log.SetLogLevel(log.LogLevel(cfg.LogLevel))
+	if cfg.LogFile != "" {
+
 	}
 	return create(ctx)
 }
diff --git a/proxy/stack.go b/proxy/stack.go
index f777880..3e8db0c 100644
--- a/proxy/stack.go
+++ b/proxy/stack.go
@@ -23,6 +23,9 @@ func (n *Node) BuildNext(name string) *Node {
 		log.Fatal(err)
 	}
 	s, err := t.NewServer(n.Context, n.Server)
+	if err != nil {
+		log.Fatal(err)
+	}
 	newNode := &Node{
 		Name:    name,
 		Next:    make(map[string]*Node),
diff --git a/tunnel/shadowsocks/client.go b/tunnel/shadowsocks/client.go
index 8f4aa66..a789545 100644
--- a/tunnel/shadowsocks/client.go
+++ b/tunnel/shadowsocks/client.go
@@ -39,7 +39,7 @@ func NewClient(ctx context.Context, underlay tunnel.Client) (*Client, error) {
 	if err != nil {
 		return nil, common.NewError("invalid shadowsocks cipher").Base(err)
 	}
-	log.Info("shadowsocks client created")
+	log.Debug("shadowsocks client created")
 	return &Client{
 		underlay: underlay,
 		Cipher:   cipher,
diff --git a/tunnel/shadowsocks/server.go b/tunnel/shadowsocks/server.go
index 56df932..6cfea25 100644
--- a/tunnel/shadowsocks/server.go
+++ b/tunnel/shadowsocks/server.go
@@ -39,7 +39,7 @@ func NewServer(ctx context.Context, underlay tunnel.Server) (*Server, error) {
 	if err != nil {
 		return nil, common.NewError("invalid shadowsocks cipher").Base(err)
 	}
-	log.Info("shadowsocks client created")
+	log.Debug("shadowsocks client created")
 	return &Server{
 		underlay: underlay,
 		Cipher:   cipher,
diff --git a/tunnel/socks/server.go b/tunnel/socks/server.go
index 088c608..c9dad07 100644
--- a/tunnel/socks/server.go
+++ b/tunnel/socks/server.go
@@ -27,18 +27,15 @@ const (
 type Server struct {
 	connChan    chan tunnel.Conn
 	packetChan  chan tunnel.PacketConn
-	errChan     chan error
-	listenAddr  net.Addr
 	tcpListener net.Listener
 	ctx         context.Context
+	localHost   string
 }
 
 func (s *Server) AcceptConn(tunnel.Tunnel) (tunnel.Conn, error) {
 	select {
 	case conn := <-s.connChan:
 		return conn, nil
-	case err := <-s.errChan:
-		return nil, err
 	case <-s.ctx.Done():
 		return nil, common.NewError("socks server closed")
 	}
@@ -48,8 +45,6 @@ func (s *Server) AcceptPacket(tunnel.Tunnel) (tunnel.PacketConn, error) {
 	select {
 	case conn := <-s.packetChan:
 		return conn, nil
-	case err := <-s.errChan:
-		return nil, err
 	case <-s.ctx.Done():
 		return nil, common.NewError("socks server closed")
 	}
@@ -110,30 +105,23 @@ func (s *Server) associate(conn net.Conn, addr *tunnel.Address) error {
 }
 
 func (s *Server) acceptLoop() {
-	l, err := net.Listen("tcp", s.listenAddr.String())
-	if err != nil {
-		s.errChan <- common.NewError("socks5 failed to listen").Base(err)
-		return
-	}
-	s.tcpListener = l
-
 	for {
-		conn, err := l.Accept()
+		conn, err := s.tcpListener.Accept()
 		if err != nil {
-			s.errChan <- common.NewError("socks5 accept err").Base(err)
+			log.Error(common.NewError("socks5 accept err").Base(err))
 			return
 		}
 		go func(conn net.Conn) {
 			newConn, err := s.handshake(conn)
 			if err != nil {
-				s.errChan <- common.NewError("socks5 failed to handshake with client").Base(err)
+				log.Error(common.NewError("socks5 failed to handshake with client").Base(err))
 				return
 			}
 			log.Info("socks5 connection from", conn.RemoteAddr(), "metadata", newConn.metadata.String())
 			switch newConn.metadata.Command {
 			case Connect:
 				if err := s.connect(newConn); err != nil {
-					s.errChan <- common.NewError("socks5 failed to respond CONNECT").Base(err)
+					log.Error(common.NewError("socks5 failed to respond CONNECT").Base(err))
 					newConn.Close()
 					return
 				}
@@ -141,26 +129,24 @@ func (s *Server) acceptLoop() {
 				return
 			case Associate:
 				defer newConn.Close()
-				host, _, err := net.SplitHostPort(s.listenAddr.String())
-				common.Must(err)
-				port := common.PickPort("udp", host)
-				associateAddr := tunnel.NewAddressFromHostPort("udp", host, port)
+				port := common.PickPort("udp", s.localHost)
+				associateAddr := tunnel.NewAddressFromHostPort("udp", s.localHost, port)
 				l, err := net.ListenPacket("udp", associateAddr.String())
 				if err != nil {
-					s.errChan <- common.NewError("socks5 failed to bind udp").Base(err)
+					log.Error(common.NewError("socks5 failed to bind udp").Base(err))
 					return
 				}
 				s.packetChan <- NewPacketConn(l)
 				log.Info("socks5 udp session")
 				if err := s.associate(newConn, associateAddr); err != nil {
-					s.errChan <- common.NewError("socks5 failed to respond to ASSOCIATE").Base(err)
+					log.Error(common.NewError("socks5 failed to respond to associate request").Base(err))
 					return
 				}
 				buf := [1]byte{}
 				newConn.Read(buf[:])
 				log.Debug("socks5 udp session ends")
 			default:
-				s.errChan <- common.NewError(fmt.Sprintf("unknown socks5 command %d", newConn.metadata.Command))
+				log.Error(common.NewError(fmt.Sprintf("unknown socks5 command %d", newConn.metadata.Command)))
 				newConn.Close()
 			}
 		}(conn)
@@ -171,12 +157,16 @@ func (s *Server) acceptLoop() {
 func NewServer(ctx context.Context, underlay tunnel.Server) (tunnel.Server, error) {
 	cfg := config.FromContext(ctx, Name).(*Config)
 	listenAddr := tunnel.NewAddressFromHostPort("tcp", cfg.LocalHost, cfg.LocalPort)
+	l, err := net.Listen("tcp", listenAddr.String())
+	if err != nil {
+		return nil, common.NewError("socks5 failed to listen").Base(err)
+	}
+	log.Info("socks5 server is listening on tcp:", l.Addr().String())
 	server := &Server{
-		listenAddr: listenAddr,
-		ctx:        ctx,
-		connChan:   make(chan tunnel.Conn, 32),
-		packetChan: make(chan tunnel.PacketConn, 32),
-		errChan:    make(chan error, 32),
+		tcpListener: l,
+		ctx:         ctx,
+		connChan:    make(chan tunnel.Conn, 32),
+		packetChan:  make(chan tunnel.PacketConn, 32),
 	}
 	go server.acceptLoop()
 	log.Debug("socks server created")
diff --git a/tunnel/tproxy/server.go b/tunnel/tproxy/server.go
index 6f676d3..7eaac01 100644
--- a/tunnel/tproxy/server.go
+++ b/tunnel/tproxy/server.go
@@ -143,7 +143,7 @@ func NewServer(ctx context.Context, _ tunnel.Server) (*Server, error) {
 		Port: cfg.LocalPort,
 	})
 	if err != nil {
-		return nil, common.NewError("tproxy failed to listen tcp").Base(err)
+		return nil, common.NewError("tproxy failed to listen udp").Base(err)
 	}
 
 	server := &Server{
diff --git a/tunnel/tproxy/tproxy.go b/tunnel/tproxy/tproxy.go
index 3488a6e..6d60717 100644
--- a/tunnel/tproxy/tproxy.go
+++ b/tunnel/tproxy/tproxy.go
@@ -1,4 +1,4 @@
-// +build linux darwin
+// +build linux
 
 package tproxy
 
diff --git a/tunnel/transport/server.go b/tunnel/transport/server.go
index c640dec..f9e5e70 100644
--- a/tunnel/transport/server.go
+++ b/tunnel/transport/server.go
@@ -322,6 +322,8 @@ func NewServer(ctx context.Context, _ tunnel.Server) (*Server, error) {
 		}
 	}
 	go server.acceptLoop()
+
+	log.Info("transport server is listening on tcp:", tcpListener.Addr().String())
 	log.Debug("transport server created")
 	return server, nil
 }
diff --git a/tunnel/transport/transport_test.go b/tunnel/transport/transport_test.go
index ec173d9..e02ec4b 100644
--- a/tunnel/transport/transport_test.go
+++ b/tunnel/transport/transport_test.go
@@ -82,7 +82,8 @@ func TestTLS(t *testing.T) {
 		RemoteHost: "127.0.0.1",
 		RemotePort: serverCfg.LocalPort,
 		TLS: TLSConfig{
-			Verify: false,
+			Verify:      false,
+			Fingerprint: "firefox",
 		},
 	}
 	sctx := config.WithConfig(context.Background(), Name, serverCfg)
diff --git a/tunnel/trojan/server.go b/tunnel/trojan/server.go
index 27a92aa..23faf46 100644
--- a/tunnel/trojan/server.go
+++ b/tunnel/trojan/server.go
@@ -208,11 +208,13 @@ func NewServer(ctx context.Context, underlay tunnel.Server) (tunnel.Server, erro
 		packetChan: make(chan tunnel.PacketConn, 32),
 	}
 
-	redirConn, err := net.Dial("tcp", redirAddr.String())
-	if err != nil {
-		return nil, common.NewError("invalid redirect address").Base(err)
+	if !cfg.DisableHTTPCheck {
+		redirConn, err := net.Dial("tcp", redirAddr.String())
+		if err != nil {
+			return nil, common.NewError("invalid redirect address. check your http server: " + redirAddr.String()).Base(err)
+		}
+		redirConn.Close()
 	}
-	redirConn.Close()
 
 	go s.acceptLoop()
 	log.Debug("trojan server created")