diff --git a/advLayer/grpcSimple/client.go b/advLayer/grpcSimple/client.go
index fdc534e..9bc1794 100644
--- a/advLayer/grpcSimple/client.go
+++ b/advLayer/grpcSimple/client.go
@@ -46,17 +46,17 @@ type ClientConn struct {
 	err           error
 }
 
-func (g *ClientConn) handshake() {
-	response, err := g.transport.RoundTrip(g.request)
+func (c *ClientConn) handshake() {
+	response, err := c.transport.RoundTrip(c.request)
 	if err != nil {
-		g.err = err
-		g.writer.Close()
+		c.err = err
+		c.writer.Close()
 		return
 	}
 
 	notOK := false
 
-	if g.shouldClose.Load() {
+	if c.shouldClose.Load() {
 		notOK = true
 	} else {
 		//log.Println("response headers", response.Header)
@@ -67,8 +67,8 @@ func (g *ClientConn) handshake() {
 			}
 
 			notOK = true
-		} else if g.client != nil && len(g.client.responseHeader) > 0 {
-			if ok, firstNotMatchKey := httpLayer.AllHeadersIn(g.client.responseHeader, response.Header); !ok {
+		} else if c.client != nil && len(c.client.responseHeader) > 0 {
+			if ok, firstNotMatchKey := httpLayer.AllHeadersIn(c.client.responseHeader, response.Header); !ok {
 
 				if ce := utils.CanLogWarn("GRPC Client configured custom header, but the server response doesn't have all of them"); ce != nil {
 					ce.Write(zap.String("firstNotMatchKey", firstNotMatchKey))
@@ -82,55 +82,55 @@ func (g *ClientConn) handshake() {
 
 	if notOK {
 
-		g.client.cachedTransport = nil
+		c.client.cachedTransport = nil
 
 		response.Body.Close()
 	} else {
-		g.response = response
-		g.br = bufio.NewReader(response.Body)
+		c.response = response
+		c.br = bufio.NewReader(response.Body)
 	}
 }
 
-func (g *ClientConn) Read(b []byte) (n int, err error) {
+func (c *ClientConn) Read(b []byte) (n int, err error) {
 
-	g.handshakeOnce.Do(g.handshake)
+	c.handshakeOnce.Do(c.handshake)
 
-	if g.err != nil {
-		return 0, g.err
+	if c.err != nil {
+		return 0, c.err
 	}
 
-	if g.response == nil {
+	if c.response == nil {
 		return 0, net.ErrClosed
 	}
 
-	return g.commonPart.Read(b)
+	return c.commonPart.Read(b)
 
 }
 
-func (g *ClientConn) Write(b []byte) (n int, err error) {
+func (c *ClientConn) Write(b []byte) (n int, err error) {
 
 	buf := commonWrite(b)
-	_, err = g.writer.Write(buf.Bytes())
+	_, err = c.writer.Write(buf.Bytes())
 	utils.PutBuf(buf)
 
-	if err == io.ErrClosedPipe && g.err != nil {
-		err = g.err
+	if err == io.ErrClosedPipe && c.err != nil {
+		err = c.err
 	}
 	if err != nil {
-		g.client.dealErr(err)
+		c.client.dealErr(err)
 
 	}
 
 	return len(b), err
 }
 
-func (g *ClientConn) Close() error {
-	g.shouldClose.Store(true)
-	if r := g.response; r != nil {
+func (c *ClientConn) Close() error {
+	c.shouldClose.Store(true)
+	if r := c.response; r != nil {
 		r.Body.Close()
 	}
 
-	return g.writer.Close()
+	return c.writer.Close()
 }
 
 //implements advLayer.MuxClient
@@ -150,13 +150,13 @@ type Client struct {
 	path string
 }
 
-func (g *Client) dealErr(err error) {
+func (c *Client) dealErr(err error) {
 	//use of closed connection
 
 	if errors.Is(err, net.ErrClosed) {
-		g.cachedTransport = nil
+		c.cachedTransport = nil
 	} else if strings.Contains(err.Error(), "use of closed") {
-		g.cachedTransport = nil
+		c.cachedTransport = nil
 	}
 }
 
diff --git a/advLayer/grpcSimple/common.go b/advLayer/grpcSimple/common.go
index a4d2375..f79c3b3 100644
--- a/advLayer/grpcSimple/common.go
+++ b/advLayer/grpcSimple/common.go
@@ -93,23 +93,23 @@ type timeouter struct {
 	closeFunc func()
 }
 
-func (g *timeouter) SetReadDeadline(t time.Time) error  { return g.SetDeadline(t) }
-func (g *timeouter) SetWriteDeadline(t time.Time) error { return g.SetDeadline(t) }
+func (c *timeouter) SetReadDeadline(t time.Time) error  { return c.SetDeadline(t) }
+func (c *timeouter) SetWriteDeadline(t time.Time) error { return c.SetDeadline(t) }
 
-func (g *timeouter) SetDeadline(t time.Time) error {
+func (c *timeouter) SetDeadline(t time.Time) error {
 
 	var d time.Duration
 
-	if g.deadline != nil {
+	if c.deadline != nil {
 
 		if t == (time.Time{}) {
-			g.deadline.Stop()
-			g.deadline = nil
+			c.deadline.Stop()
+			c.deadline = nil
 			return nil
 		}
 
 		d = time.Until(t)
-		g.deadline.Reset(d)
+		c.deadline.Reset(d)
 
 	} else {
 		if t == (time.Time{}) {
@@ -117,7 +117,7 @@ func (g *timeouter) SetDeadline(t time.Time) error {
 		}
 
 		d = time.Until(t)
-		g.deadline = time.AfterFunc(d, g.closeFunc)
+		c.deadline = time.AfterFunc(d, c.closeFunc)
 	}
 
 	return nil
diff --git a/advLayer/grpcSimple/grpcSimple.go b/advLayer/grpcSimple/grpcSimple.go
index d2ff5f0..bbc94a4 100644
--- a/advLayer/grpcSimple/grpcSimple.go
+++ b/advLayer/grpcSimple/grpcSimple.go
@@ -27,6 +27,7 @@ grpcSimple can fallback to h2c.
 about h2c
 
 https://pkg.go.dev/golang.org/x/net/http2/h2c#example-NewHandler
+
 https://github.com/thrawn01/h2c-golang-example
 
 test h2c:
diff --git a/advLayer/grpcSimple/server.go b/advLayer/grpcSimple/server.go
index 38362aa..2d9df90 100644
--- a/advLayer/grpcSimple/server.go
+++ b/advLayer/grpcSimple/server.go
@@ -223,37 +223,37 @@ type ServerConn struct {
 	closed    bool
 }
 
-func (g *ServerConn) Close() error {
-	g.closeOnce.Do(func() {
-		g.closed = true
-		close(g.closeChan)
-		if g.Closer != nil {
-			g.Closer.Close()
+func (sc *ServerConn) Close() error {
+	sc.closeOnce.Do(func() {
+		sc.closed = true
+		close(sc.closeChan)
+		if sc.Closer != nil {
+			sc.Closer.Close()
 
 		}
 	})
 	return nil
 }
 
-func (g *ServerConn) Write(b []byte) (n int, err error) {
+func (sc *ServerConn) Write(b []byte) (n int, err error) {
 
 	//the determination of g.closed is necessary, or it might panic when calling Write or Flush
 
-	if g.closed {
+	if sc.closed {
 		return 0, net.ErrClosed
 	} else {
 
 		buf := commonWrite(b)
 
-		if g.closed { //较为谨慎，也许commonWrite 刚调用完, 就 g.closed 了
+		if sc.closed { //较为谨慎，也许commonWrite 刚调用完, 就 g.closed 了
 			utils.PutBuf(buf)
 			return 0, net.ErrClosed
 		}
-		_, err = g.Writer.Write(buf.Bytes())
+		_, err = sc.Writer.Write(buf.Bytes())
 		utils.PutBuf(buf)
 
-		if err == nil && !g.closed {
-			g.Writer.(http.Flusher).Flush() //necessary
+		if err == nil && !sc.closed {
+			sc.Writer.(http.Flusher).Flush() //necessary
 
 		}
 
diff --git a/cmd/verysimple/Makefile b/cmd/verysimple/Makefile
index 460ec4f..343a13a 100644
--- a/cmd/verysimple/Makefile
+++ b/cmd/verysimple/Makefile
@@ -136,23 +136,23 @@ winFn          :=${prefix}_win10
 #注意调用参数时，逗号前后不能留空格
 
 linux_amd64:
-	$(call compile, $(linuxAmdFn),linux,amd64)
+	$(call compile,$(linuxAmdFn),linux,amd64)
 
 linux_arm64:
-	$(call compile, $(linuxArmFn),linux,arm64)
+	$(call compile,$(linuxArmFn),linux,arm64)
 
 android_arm64:
-	$(call compile, $(androidArm64Fn),android,arm64)
+	$(call compile,$(androidArm64Fn),android,arm64)
 
 macos:
-	$(call compile, $(macFn),darwin,amd64)
+	$(call compile,$(macFn),darwin,amd64)
 
 #macos apple silicon
 macm1:
-	$(call compile, $(macM1Fn),darwin,arm64)
+	$(call compile,$(macM1Fn),darwin,arm64)
 
 win10:
-	$(call compile, $(winFn),windows,amd64,$(winsuffix))
+	$(call compile,$(winFn),windows,amd64,$(winsuffix))
 
 
 clean:
diff --git a/httpLayer/fallback.go b/httpLayer/fallback.go
index 38cd28f..0ec6f55 100644
--- a/httpLayer/fallback.go
+++ b/httpLayer/fallback.go
@@ -54,8 +54,8 @@ type FallbackResult struct {
 	Xver int
 }
 
-func (ef *FallbackResult) GetFallback(ftype byte, _ ...string) *FallbackResult {
-	return ef
+func (r *FallbackResult) GetFallback(ftype byte, _ ...string) *FallbackResult {
+	return r
 }
 
 func (FallbackResult) SupportType() byte {
diff --git a/httpLayer/header.go b/httpLayer/header.go
index cb34850..6e7fc1f 100644
--- a/httpLayer/header.go
+++ b/httpLayer/header.go
@@ -72,49 +72,49 @@ type HeaderPreset struct {
 }
 
 // 将Header改为首字母大写
-func (hh *HeaderPreset) Prepare() {
-	if hh.Request != nil && len(hh.Request.Headers) > 0 {
+func (h *HeaderPreset) Prepare() {
+	if h.Request != nil && len(h.Request.Headers) > 0 {
 
 		var realHeaders http.Header = make(http.Header)
-		for k, vs := range hh.Request.Headers {
+		for k, vs := range h.Request.Headers {
 			for _, v := range vs {
 				realHeaders.Add(k, v)
 
 			}
 		}
 
-		hh.Request.Headers = realHeaders
+		h.Request.Headers = realHeaders
 	}
-	if hh.Response != nil && len(hh.Response.Headers) > 0 {
+	if h.Response != nil && len(h.Response.Headers) > 0 {
 
 		var realHeaders http.Header = make(http.Header)
-		for k, vs := range hh.Response.Headers {
+		for k, vs := range h.Response.Headers {
 			for _, v := range vs {
 				realHeaders.Add(k, v)
 
 			}
 		}
 
-		hh.Response.Headers = realHeaders
+		h.Response.Headers = realHeaders
 	}
 }
 
 //默认值保持与v2ray的配置相同
-func (hh *HeaderPreset) AssignDefaultValue() {
-	if hh.Request == nil {
-		hh.Request = &RequestHeader{}
+func (h *HeaderPreset) AssignDefaultValue() {
+	if h.Request == nil {
+		h.Request = &RequestHeader{}
 	}
-	if hh.Request.Version == "" {
-		hh.Request.Version = "1.1"
+	if h.Request.Version == "" {
+		h.Request.Version = "1.1"
 	}
-	if hh.Request.Method == "" {
-		hh.Request.Method = "GET"
+	if h.Request.Method == "" {
+		h.Request.Method = "GET"
 	}
-	if len(hh.Request.Path) == 0 {
-		hh.Request.Path = []string{"/"}
+	if len(h.Request.Path) == 0 {
+		h.Request.Path = []string{"/"}
 	}
-	if len(hh.Request.Headers) == 0 {
-		hh.Request.Headers = map[string][]string{
+	if len(h.Request.Headers) == 0 {
+		h.Request.Headers = map[string][]string{
 			"Host":            {"www.baidu.com", "www.bing.com"},
 			"User-Agent":      {"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36", "Mozilla/5.0 (iPhone; CPU iPhone OS 10_0_2 like Mac OS X) AppleWebKit/601.1 (KHTML, like Gecko) CriOS/53.0.2785.109 Mobile/14A456 Safari/601.1.46"},
 			"Accept-Encoding": {"gzip, deflate"},
@@ -124,23 +124,23 @@ func (hh *HeaderPreset) AssignDefaultValue() {
 
 	}
 
-	if hh.Response == nil {
-		hh.Response = &ResponseHeader{}
+	if h.Response == nil {
+		h.Response = &ResponseHeader{}
 	}
 
-	if hh.Response.Version == "" {
-		hh.Response.Version = "1.1"
+	if h.Response.Version == "" {
+		h.Response.Version = "1.1"
 	}
 
-	if hh.Response.StatusCode == "" {
-		hh.Response.StatusCode = "200"
+	if h.Response.StatusCode == "" {
+		h.Response.StatusCode = "200"
 	}
-	if hh.Response.Reason == "" {
-		hh.Response.Reason = "OK"
+	if h.Response.Reason == "" {
+		h.Response.Reason = "OK"
 	}
 
-	if len(hh.Response.Headers) == 0 {
-		hh.Response.Headers = map[string][]string{
+	if len(h.Response.Headers) == 0 {
+		h.Response.Headers = map[string][]string{
 			"Content-Type":      {"application/octet-stream", "video/mpeg"},
 			"Transfer-Encoding": {"chunked"},
 			"Connection":        {"keep-alive"},
@@ -148,7 +148,7 @@ func (hh *HeaderPreset) AssignDefaultValue() {
 		}
 	}
 
-	hh.Prepare()
+	h.Prepare()
 }
 
 func (h *HeaderPreset) ReadRequest(underlay net.Conn) (err error, leftBuf *bytes.Buffer) {
@@ -237,15 +237,15 @@ func (h *HeaderPreset) ReadRequest(underlay net.Conn) (err error, leftBuf *bytes
 	return nil, rp.WholeRequestBuf
 }
 
-func (p *HeaderPreset) WriteRequest(underlay net.Conn, payload []byte) error {
+func (h *HeaderPreset) WriteRequest(underlay net.Conn, payload []byte) error {
 
 	buf := bytes.NewBuffer(payload)
-	r, err := http.NewRequest(p.Request.Method, p.Request.Path[0], buf)
+	r, err := http.NewRequest(h.Request.Method, h.Request.Path[0], buf)
 	if err != nil {
 		return err
 	}
 
-	nh := TrimHeaders(p.Request.Headers)
+	nh := TrimHeaders(h.Request.Headers)
 
 	r.Header = nh
 
@@ -255,7 +255,7 @@ func (p *HeaderPreset) WriteRequest(underlay net.Conn, payload []byte) error {
 	return r.Write(underlay)
 }
 
-func (p *HeaderPreset) ReadResponse(underlay net.Conn) (err error, leftBuf *bytes.Buffer) {
+func (h *HeaderPreset) ReadResponse(underlay net.Conn) (err error, leftBuf *bytes.Buffer) {
 
 	bs := utils.GetPacket()
 	var n int
@@ -281,18 +281,18 @@ func (p *HeaderPreset) ReadResponse(underlay net.Conn) (err error, leftBuf *byte
 	return nil, buf
 }
 
-func (p *HeaderPreset) WriteResponse(underlay net.Conn, payload []byte) error {
+func (h *HeaderPreset) WriteResponse(underlay net.Conn, payload []byte) error {
 	buf := utils.GetBuf()
 
 	buf.WriteString("HTTP/")
-	buf.WriteString(p.Response.Version)
+	buf.WriteString(h.Response.Version)
 	buf.WriteString(" ")
-	buf.WriteString(p.Response.StatusCode)
+	buf.WriteString(h.Response.StatusCode)
 	buf.WriteString(" ")
-	buf.WriteString(p.Response.Reason)
+	buf.WriteString(h.Response.Reason)
 	buf.WriteString(CRLF)
 
-	for key, v := range p.Response.Headers {
+	for key, v := range h.Response.Headers {
 		thisStr := v[rand.Intn(len(v))]
 		buf.WriteString(key)
 		buf.WriteString(":")
@@ -325,51 +325,51 @@ type HeaderConn struct {
 	notFirstWrite bool
 }
 
-func (pc *HeaderConn) Read(p []byte) (n int, err error) {
+func (c *HeaderConn) Read(p []byte) (n int, err error) {
 	var buf *bytes.Buffer
 
-	if pc.IsServerEnd {
-		if pc.optionalReader == nil {
-			err, buf = pc.H.ReadRequest(pc.Conn)
+	if c.IsServerEnd {
+		if c.optionalReader == nil {
+			err, buf = c.H.ReadRequest(c.Conn)
 			if err != nil {
 				err = utils.ErrInErr{ErrDesc: "http HeaderConn Read failed, at serverEnd", ErrDetail: err}
 				return
 			}
 
-			pc.optionalReader = io.MultiReader(buf, pc.Conn)
+			c.optionalReader = io.MultiReader(buf, c.Conn)
 		}
 
 	} else {
-		if pc.optionalReader == nil {
-			err, buf = pc.H.ReadResponse(pc.Conn)
+		if c.optionalReader == nil {
+			err, buf = c.H.ReadResponse(c.Conn)
 			if err != nil {
 				err = utils.ErrInErr{ErrDesc: "http HeaderConn Read failed", ErrDetail: err}
 				return
 			}
 
-			pc.optionalReader = io.MultiReader(buf, pc.Conn)
+			c.optionalReader = io.MultiReader(buf, c.Conn)
 		}
 	}
-	return pc.optionalReader.Read(p)
+	return c.optionalReader.Read(p)
 
 }
 
-func (pc *HeaderConn) Write(p []byte) (n int, err error) {
+func (c *HeaderConn) Write(p []byte) (n int, err error) {
 
-	if pc.IsServerEnd {
-		if pc.notFirstWrite {
-			return pc.Conn.Write(p)
+	if c.IsServerEnd {
+		if c.notFirstWrite {
+			return c.Conn.Write(p)
 		}
-		pc.notFirstWrite = true
-		err = pc.H.WriteResponse(pc.Conn, p)
+		c.notFirstWrite = true
+		err = c.H.WriteResponse(c.Conn, p)
 
 	} else {
 
-		if pc.notFirstWrite {
-			return pc.Conn.Write(p)
+		if c.notFirstWrite {
+			return c.Conn.Write(p)
 		}
-		pc.notFirstWrite = true
-		err = pc.H.WriteRequest(pc.Conn, p)
+		c.notFirstWrite = true
+		err = c.H.WriteRequest(c.Conn, p)
 	}
 
 	if err != nil {
diff --git a/httpLayer/httpLayer.go b/httpLayer/httpLayer.go
index 0f1c485..b270a2f 100644
--- a/httpLayer/httpLayer.go
+++ b/httpLayer/httpLayer.go
@@ -99,12 +99,12 @@ func (e *RequestErr) Is(err error) bool {
 	return false
 }
 
-func (pe *RequestErr) Error() string {
+func (e *RequestErr) Error() string {
 	var sb strings.Builder
 	sb.WriteString("InvaidRequest ")
-	sb.WriteString(pe.Method)
+	sb.WriteString(e.Method)
 	sb.WriteString(",")
-	sb.WriteString(pe.Path)
+	sb.WriteString(e.Path)
 
 	return sb.String()
 }
diff --git a/netLayer/listen.go b/netLayer/listen.go
index 206f5ef..e985830 100644
--- a/netLayer/listen.go
+++ b/netLayer/listen.go
@@ -17,7 +17,7 @@ func loopAccept(listener net.Listener, xver int, acceptFunc func(net.Conn)) {
 	if xver > 0 {
 
 		if ce := utils.CanLogDebug("Listening PROXY protocol"); ce != nil {
-			ce.Write(zap.Int("prefered version", xver))
+			ce.Write(zap.Int("preferred version", xver))
 		}
 
 		listener = &proxyproto.Listener{Listener: listener, Policy: proxyProtocolListenPolicyFunc}
diff --git a/proxy/base.go b/proxy/base.go
index 61527c5..b91ce7d 100644
--- a/proxy/base.go
+++ b/proxy/base.go
@@ -107,56 +107,56 @@ type Base struct {
 
 }
 
-func (pcs *Base) GetBase() *Base {
-	return pcs
+func (b *Base) GetBase() *Base {
+	return b
 }
 
-func (pcs *Base) Network() string {
-	return pcs.TransportLayer
+func (b *Base) Network() string {
+	return b.TransportLayer
 }
 
-func (pcs *Base) GetXver() int {
-	return pcs.Xver
+func (b *Base) GetXver() int {
+	return b.Xver
 }
 
-func (pcs *Base) HasHeader() *httpLayer.HeaderPreset {
-	return pcs.Header
+func (b *Base) HasHeader() *httpLayer.HeaderPreset {
+	return b.Header
 }
 
-func (pcs *Base) GetFallback() *netLayer.Addr {
-	return pcs.FallbackAddr
+func (b *Base) GetFallback() *netLayer.Addr {
+	return b.FallbackAddr
 }
 
-func (pcs *Base) MiddleName() string {
+func (b *Base) MiddleName() string {
 	var sb strings.Builder
 	sb.WriteString("")
 
-	if pcs.TLS {
+	if b.TLS {
 		sb.WriteString("+tls")
 	}
-	if pcs.Header != nil {
-		if pcs.AdvancedL != "ws" {
+	if b.Header != nil {
+		if b.AdvancedL != "ws" {
 			sb.WriteString("+http")
 		}
 	}
-	if pcs.AdvancedL != "" {
+	if b.AdvancedL != "" {
 		sb.WriteString("+")
-		sb.WriteString(pcs.AdvancedL)
+		sb.WriteString(b.AdvancedL)
 	}
 	sb.WriteString("+")
 	return sb.String()
 }
 
-func (pcs *Base) CantRoute() bool {
-	return pcs.IsCantRoute
+func (b *Base) CantRoute() bool {
+	return b.IsCantRoute
 }
 
-func (pcs *Base) InnerMuxEstablished() bool {
-	return pcs.Innermux != nil && !pcs.Innermux.IsClosed()
+func (b *Base) InnerMuxEstablished() bool {
+	return b.Innermux != nil && !b.Innermux.IsClosed()
 }
 
 //placeholder
-func (pcs *Base) HasInnerMux() (int, string) {
+func (b *Base) HasInnerMux() (int, string) {
 	return 0, ""
 }
 
@@ -174,16 +174,16 @@ func (*Base) GetServerInnerMuxSession(wlc io.ReadWriteCloser) *smux.Session {
 	return smuxSession
 }
 
-func (pcs *Base) CloseInnerMuxSession() {
-	if pcs.Innermux != nil && !pcs.Innermux.IsClosed() {
-		pcs.Innermux.Close()
-		pcs.Innermux = nil
+func (b *Base) CloseInnerMuxSession() {
+	if b.Innermux != nil && !b.Innermux.IsClosed() {
+		b.Innermux.Close()
+		b.Innermux = nil
 	}
 }
 
-func (pcs *Base) GetClientInnerMuxSession(wrc io.ReadWriteCloser) *smux.Session {
-	if pcs.Innermux != nil && !pcs.Innermux.IsClosed() {
-		return pcs.Innermux
+func (b *Base) GetClientInnerMuxSession(wrc io.ReadWriteCloser) *smux.Session {
+	if b.Innermux != nil && !b.Innermux.IsClosed() {
+		return b.Innermux
 	} else {
 		smuxConfig := smux.DefaultConfig()
 		smuxSession, err := smux.Client(wrc, smuxConfig)
@@ -195,112 +195,112 @@ func (pcs *Base) GetClientInnerMuxSession(wrc io.ReadWriteCloser) *smux.Session
 			}
 			return nil
 		}
-		pcs.Innermux = smuxSession
+		b.Innermux = smuxSession
 		return smuxSession
 	}
 }
 
 //return false. As a placeholder.
-func (pcs *Base) IsUDP_MultiChannel() bool {
+func (b *Base) IsUDP_MultiChannel() bool {
 	return false
 }
 
-func (pcs *Base) GetTag() string {
-	return pcs.Tag
+func (b *Base) GetTag() string {
+	return b.Tag
 }
-func (pcs *Base) GetSockopt() *netLayer.Sockopt {
-	return pcs.Sockopt
+func (b *Base) GetSockopt() *netLayer.Sockopt {
+	return b.Sockopt
 }
 
-func (pcs *Base) setNetwork(network string) {
+func (b *Base) setNetwork(network string) {
 	if network == "" {
-		pcs.TransportLayer = "tcp"
+		b.TransportLayer = "tcp"
 
 	} else {
-		pcs.TransportLayer = network
+		b.TransportLayer = network
 
 	}
 }
 
-func (pcs *Base) AdvancedLayer() string {
-	return pcs.AdvancedL
+func (b *Base) AdvancedLayer() string {
+	return b.AdvancedL
 }
 
 //try close inner mux and AdvS
-func (s *Base) Stop() {
-	if s.Innermux != nil {
-		s.Innermux.Close()
+func (b *Base) Stop() {
+	if b.Innermux != nil {
+		b.Innermux.Close()
 	}
 
-	if s.AdvS != nil {
-		s.AdvS.Stop()
+	if b.AdvS != nil {
+		b.AdvS.Stop()
 	}
 }
 
 //return false. As a placeholder.
-func (s *Base) CanFallback() bool {
+func (b *Base) CanFallback() bool {
 	return false
 }
 
-func (s *Base) GetTLS_Server() *tlsLayer.Server {
-	return s.Tls_s
+func (b *Base) GetTLS_Server() *tlsLayer.Server {
+	return b.Tls_s
 }
-func (s *Base) GetTLS_Client() *tlsLayer.Client {
-	return s.Tls_c
+func (b *Base) GetTLS_Client() *tlsLayer.Client {
+	return b.Tls_c
 }
 
-func (s *Base) AddrStr() string {
-	return s.Addr
+func (b *Base) AddrStr() string {
+	return b.Addr
 }
-func (s *Base) SetAddrStr(a string) {
-	s.Addr = a
+func (b *Base) SetAddrStr(a string) {
+	b.Addr = a
 }
 
-func (s *Base) IsUseTLS() bool {
-	return s.TLS
+func (b *Base) IsUseTLS() bool {
+	return b.TLS
 }
 
-func (s *Base) GetAdvClient() advLayer.Client {
-	return s.AdvC
+func (b *Base) GetAdvClient() advLayer.Client {
+	return b.AdvC
 }
-func (s *Base) GetAdvServer() advLayer.Server {
-	return s.AdvS
+func (b *Base) GetAdvServer() advLayer.Server {
+	return b.AdvS
 }
 
 //setNetwork, xver, Tag,Sockopt,header,AdvancedL, InitAdvLayer
-func (c *Base) ConfigCommon(cc *CommonConf) {
+func (b *Base) ConfigCommon(cc *CommonConf) {
 
-	c.setNetwork(cc.Network)
-	c.Xver = cc.Xver
-	c.Tag = cc.Tag
-	c.Sockopt = cc.Sockopt
+	b.setNetwork(cc.Network)
+	b.Xver = cc.Xver
+	b.Tag = cc.Tag
+	b.Sockopt = cc.Sockopt
 
 	if cc.HttpHeader != nil {
 		cc.HttpHeader.AssignDefaultValue()
-		c.Header = (cc.HttpHeader)
+		b.Header = (cc.HttpHeader)
 	}
 
-	c.AdvancedL = cc.AdvancedLayer
+	b.AdvancedL = cc.AdvancedLayer
 
-	c.InitAdvLayer()
+	b.InitAdvLayer()
 }
 
-func (s *Base) InitAdvLayer() {
-	switch s.AdvancedL {
+func (b *Base) InitAdvLayer() {
+	switch b.AdvancedL {
 	case "":
 		return
 	case "quic":
-		s.setNetwork("udp")
+		b.setNetwork("udp")
 	}
 
-	creator := advLayer.ProtocolsMap[s.AdvancedL]
+	creator := advLayer.ProtocolsMap[b.AdvancedL]
 	if creator == nil {
-		utils.Error("InitAdvLayer failed, not supported, " + s.AdvancedL)
+		utils.Error("InitAdvLayer failed, not supported, " + b.AdvancedL)
 
 		return
 	}
 
-	ad, err := netLayer.NewAddr(s.Addr)
+	ad, err := netLayer.NewAddr(b.Addr)
 	if err != nil {
 		if ce := utils.CanLogErr("InitAdvLayer addr failed "); ce != nil {
 			ce.Write(
@@ -311,7 +311,7 @@ func (s *Base) InitAdvLayer() {
 		return
 	}
 
-	if dc := s.DialConf; dc != nil {
+	if dc := b.DialConf; dc != nil {
 
 		var Headers *httpLayer.HeaderPreset
 		if creator.CanHandleHeaders() {
@@ -336,18 +336,18 @@ func (s *Base) InitAdvLayer() {
 
 			if ce := utils.CanLogErr("InitAdvLayer client failed "); ce != nil {
 				ce.Write(
-					zap.String("protocol", s.AdvancedL),
+					zap.String("protocol", b.AdvancedL),
 					zap.Error(err),
 				)
 			}
 
 			return
 		}
-		s.AdvC = advClient
+		b.AdvC = advClient
 
 	}
 
-	if lc := s.ListenConf; lc != nil {
+	if lc := b.ListenConf; lc != nil {
 
 		var Headers *httpLayer.HeaderPreset
 
@@ -390,7 +390,7 @@ func (s *Base) InitAdvLayer() {
 
 			if ce := utils.CanLogErr("InitAdvLayer server failed "); ce != nil {
 				ce.Write(
-					zap.String("protocol", s.AdvancedL),
+					zap.String("protocol", b.AdvancedL),
 					zap.Error(err),
 				)
 			}
@@ -398,6 +398,6 @@ func (s *Base) InitAdvLayer() {
 			return
 		}
 
-		s.AdvS = advSer
+		b.AdvS = advSer
 	}
 }
diff --git a/proxy/client_reject.go b/proxy/client_reject.go
index c809257..f9540b4 100644
--- a/proxy/client_reject.go
+++ b/proxy/client_reject.go
@@ -52,8 +52,8 @@ type RejectClient struct {
 
 func (*RejectClient) Name() string { return RejectName }
 
-func (b *RejectClient) tryResponseAndClose(underlay net.Conn) {
-	switch b.theType {
+func (c *RejectClient) tryResponseAndClose(underlay net.Conn) {
+	switch c.theType {
 	case "http":
 		underlay.Write([]byte(httpLayer.Err403response))
 	}
@@ -62,13 +62,13 @@ func (b *RejectClient) tryResponseAndClose(underlay net.Conn) {
 }
 
 //optionally response a 403 and close the underlay.
-func (b *RejectClient) Handshake(underlay net.Conn, _ []byte, _ netLayer.Addr) (result io.ReadWriteCloser, err error) {
-	b.tryResponseAndClose(underlay)
+func (c *RejectClient) Handshake(underlay net.Conn, _ []byte, _ netLayer.Addr) (result io.ReadWriteCloser, err error) {
+	c.tryResponseAndClose(underlay)
 	return nil, io.EOF
 }
 
 //function the same as Handshake
-func (b *RejectClient) EstablishUDPChannel(underlay net.Conn, _ netLayer.Addr) (netLayer.MsgConn, error) {
-	b.tryResponseAndClose(underlay)
+func (c *RejectClient) EstablishUDPChannel(underlay net.Conn, _ netLayer.Addr) (netLayer.MsgConn, error) {
+	c.tryResponseAndClose(underlay)
 	return nil, io.EOF
 }
diff --git a/proxy/simplesocks/tcpconn.go b/proxy/simplesocks/tcpconn.go
index 9954c0c..5b7c8a7 100644
--- a/proxy/simplesocks/tcpconn.go
+++ b/proxy/simplesocks/tcpconn.go
@@ -19,19 +19,19 @@ type TCPConn struct {
 	isServerEnd bool
 }
 
-func (uc *TCPConn) Read(p []byte) (int, error) {
-	if uc.remainFirstBufLen > 0 {
-		n, err := uc.optionalReader.Read(p)
+func (c *TCPConn) Read(p []byte) (int, error) {
+	if c.remainFirstBufLen > 0 {
+		n, err := c.optionalReader.Read(p)
 		if n > 0 {
-			uc.remainFirstBufLen -= n
+			c.remainFirstBufLen -= n
 		}
 		return n, err
 	} else {
-		return uc.Conn.Read(p)
+		return c.Conn.Read(p)
 	}
 }
-func (uc *TCPConn) Write(p []byte) (int, error) {
-	return uc.Conn.Write(p)
+func (c *TCPConn) Write(p []byte) (int, error) {
+	return c.Conn.Write(p)
 }
 
 func (c *TCPConn) EverPossibleToSplice() bool {
diff --git a/proxy/trojan/tcpconn.go b/proxy/trojan/tcpconn.go
index aacb595..421b4c7 100644
--- a/proxy/trojan/tcpconn.go
+++ b/proxy/trojan/tcpconn.go
@@ -22,19 +22,19 @@ type UserTCPConn struct {
 	isServerEnd bool
 }
 
-func (uc *UserTCPConn) Read(p []byte) (int, error) {
-	if uc.remainFirstBufLen > 0 {
-		n, err := uc.optionalReader.Read(p)
+func (c *UserTCPConn) Read(p []byte) (int, error) {
+	if c.remainFirstBufLen > 0 {
+		n, err := c.optionalReader.Read(p)
 		if n > 0 {
-			uc.remainFirstBufLen -= n
+			c.remainFirstBufLen -= n
 		}
 		return n, err
 	} else {
-		return uc.Conn.Read(p)
+		return c.Conn.Read(p)
 	}
 }
-func (uc *UserTCPConn) Write(p []byte) (int, error) {
-	return uc.Conn.Write(p)
+func (c *UserTCPConn) Write(p []byte) (int, error) {
+	return c.Conn.Write(p)
 }
 
 func (c *UserTCPConn) EverPossibleToSplice() bool {
diff --git a/proxy/vless/tcpconn.go b/proxy/vless/tcpconn.go
index a9420b9..cf211b8 100644
--- a/proxy/vless/tcpconn.go
+++ b/proxy/vless/tcpconn.go
@@ -31,15 +31,15 @@ type UserTCPConn struct {
 	mr utils.MultiReader //用于 Readbuffers
 }
 
-func (uc *UserTCPConn) GetProtocolVersion() int {
-	return uc.version
+func (c *UserTCPConn) GetProtocolVersion() int {
+	return c.version
 }
-func (uc *UserTCPConn) GetIdentityStr() string {
-	if uc.convertedUUIDStr == "" {
-		uc.convertedUUIDStr = utils.UUIDToStr(uc.uuid)
+func (c *UserTCPConn) GetIdentityStr() string {
+	if c.convertedUUIDStr == "" {
+		c.convertedUUIDStr = utils.UUIDToStr(c.uuid)
 	}
 
-	return uc.convertedUUIDStr
+	return c.convertedUUIDStr
 }
 
 //当前连接状态是否可以直接写入底层Conn而不经任何改动/包装
@@ -112,16 +112,16 @@ func (c *UserTCPConn) WriteBuffers(buffers [][]byte) (int64, error) {
 
 //如果是udp，则是多线程不安全的，如果是tcp，则安不安全看底层的链接。
 // 这里规定，如果是UDP，则 每Write一遍，都要Write一个 完整的UDP 数据包
-func (uc *UserTCPConn) Write(p []byte) (int, error) {
+func (c *UserTCPConn) Write(p []byte) (int, error) {
 
-	if uc.version == 0 {
+	if c.version == 0 {
 
 		originalSupposedWrittenLenth := len(p)
 
 		var writeBuf *bytes.Buffer
 
-		if uc.isServerEnd && !uc.isntFirstPacket {
-			uc.isntFirstPacket = true
+		if c.isServerEnd && !c.isntFirstPacket {
+			c.isntFirstPacket = true
 
 			writeBuf = utils.GetBuf()
 
@@ -135,7 +135,7 @@ func (uc *UserTCPConn) Write(p []byte) (int, error) {
 		if writeBuf != nil {
 			writeBuf.Write(p)
 
-			_, err := uc.Conn.Write(writeBuf.Bytes())
+			_, err := c.Conn.Write(writeBuf.Bytes())
 
 			utils.PutBuf(writeBuf)
 
@@ -144,7 +144,7 @@ func (uc *UserTCPConn) Write(p []byte) (int, error) {
 			}
 
 		} else {
-			_, err := uc.Conn.Write(p)
+			_, err := c.Conn.Write(p)
 
 			if err != nil {
 				return 0, err
@@ -153,52 +153,52 @@ func (uc *UserTCPConn) Write(p []byte) (int, error) {
 		return originalSupposedWrittenLenth, nil
 
 	} else {
-		return uc.Conn.Write(p)
+		return c.Conn.Write(p)
 
 	}
 }
 
 //专门适用于 裸奔splice的情况
-func (uc *UserTCPConn) ReadFrom(r io.Reader) (written int64, err error) {
+func (c *UserTCPConn) ReadFrom(r io.Reader) (written int64, err error) {
 
-	return netLayer.TryReadFrom_withSplice(uc, uc.Conn, r, uc.canDirectWrite)
+	return netLayer.TryReadFrom_withSplice(c, c.Conn, r, c.canDirectWrite)
 }
 
 //如果是udp，则是多线程不安全的，如果是tcp，则安不安全看底层的链接。
 // 这里规定，如果是UDP，则 每次 Read 得到的都是一个 完整的UDP 数据包，除非p给的太小……
-func (uc *UserTCPConn) Read(p []byte) (int, error) {
+func (c *UserTCPConn) Read(p []byte) (int, error) {
 
-	if uc.isServerEnd {
-		var from io.Reader = uc.Conn
-		if uc.optionalReader != nil {
-			from = uc.optionalReader
+	if c.isServerEnd {
+		var from io.Reader = c.Conn
+		if c.optionalReader != nil {
+			from = c.optionalReader
 		}
 
-		if uc.remainFirstBufLen > 0 {
+		if c.remainFirstBufLen > 0 {
 
 			n, err := from.Read(p)
 
 			if n > 0 {
-				uc.remainFirstBufLen -= n
-				if uc.remainFirstBufLen <= 0 {
-					uc.optionalReader = nil
+				c.remainFirstBufLen -= n
+				if c.remainFirstBufLen <= 0 {
+					c.optionalReader = nil
 				}
 			}
 			return n, err
 
 		} else {
-			return uc.Conn.Read(p)
+			return c.Conn.Read(p)
 		}
 
-	} else if uc.version == 0 {
+	} else if c.version == 0 {
 
-		if !uc.isntFirstPacket {
+		if !c.isntFirstPacket {
 			//先读取响应头
 
-			uc.isntFirstPacket = true
+			c.isntFirstPacket = true
 
 			bs := utils.GetPacket()
-			n, e := uc.Conn.Read(bs)
+			n, e := c.Conn.Read(bs)
 
 			if e != nil {
 				utils.PutPacket(bs)
@@ -214,12 +214,12 @@ func (uc *UserTCPConn) Read(p []byte) (int, error) {
 			return n, nil
 
 		} else {
-			return uc.Conn.Read(p)
+			return c.Conn.Read(p)
 
 		}
 
 	} else {
-		return uc.Conn.Read(p)
+		return c.Conn.Read(p)
 
 	}
 }