diff --git a/advLayer/ws/conn.go b/advLayer/ws/conn.go
index 56ce671..aca764a 100644
--- a/advLayer/ws/conn.go
+++ b/advLayer/ws/conn.go
@@ -32,7 +32,7 @@ type Conn struct {
 	realRaddr net.Addr //可从 X-Forwarded-For 读取用户真实ip，用于反代等情况
 }
 
-//Read websocket binary frames
+// Read websocket binary frames
 func (c *Conn) Read(p []byte) (int, error) {
 
 	if len(c.serverEndGotEarlyData) > 0 {
@@ -112,11 +112,11 @@ func (c *Conn) Read(p []byte) (int, error) {
 	return n, nil
 }
 
-func (c *Conn) EverPossibleToSplice() bool {
+func (c *Conn) EverPossibleToSpliceWrite() bool {
 	return c.underlayIsTCP && c.state == ws.StateServerSide
 }
 
-//采用 “超长包” 的办法 试图进行splice
+// 采用 “超长包” 的办法 试图进行splice
 func (c *Conn) tryWriteBigHeader() (e error) {
 	if c.bigHeaderEverUsed {
 		return
@@ -134,8 +134,8 @@ func (c *Conn) tryWriteBigHeader() (e error) {
 	return
 }
 
-func (c *Conn) CanSplice() (r bool, conn *net.TCPConn) {
-	if !c.EverPossibleToSplice() {
+func (c *Conn) CanSpliceWrite() (r bool, conn *net.TCPConn) {
+	if !c.EverPossibleToSpliceWrite() {
 		return
 	}
 
@@ -177,7 +177,7 @@ func (c *Conn) ReadFrom(r io.Reader) (written int64, err error) {
 	})
 }
 
-//实现 utils.MultiWriter
+// 实现 utils.MultiWriter
 // 主要是针对一串数据的情况，如果底层连接可以用writev， 此时我们不要每一小段都包包头 然后写N次，
 // 而是只在最前面包数据头，然后即可用writev 一次发送出去
 // 比如从 socks5 读数据，写入 tcp +ws + vless 协议, 就是这种情况
@@ -249,7 +249,7 @@ func (c *Conn) WriteBuffers(buffers [][]byte) (int64, error) {
 	}
 }
 
-//Write websocket binary frames
+// Write websocket binary frames
 func (c *Conn) Write(p []byte) (n int, e error) {
 
 	//查看了代码，wsutil.WriteClientBinary 等类似函数会直接调用 ws.WriteFrame， 是不分片的.
diff --git a/netLayer/splice.go b/netLayer/splice.go
index 8117c32..88c0c4c 100644
--- a/netLayer/splice.go
+++ b/netLayer/splice.go
@@ -13,13 +13,13 @@ var ErrInvalidWrite = errors.New("readfrom, invalid write result")
 
 var SystemCanSplice = runtime.GOARCH != "wasm" && runtime.GOOS != "windows"
 
-//Splicer 是一个 可以进行Write时使用splice的接口。
+// Splicer 是一个 可以进行Write时使用splice的接口。
 type Splicer interface {
-	EverPossibleToSplice() bool      //是否有机会splice, 如果这个返回false，则永远无法splice; 主要审视自己能否向裸连接写入数据; 读不用splicer担心。
-	CanSplice() (bool, *net.TCPConn) //当前状态是否可以splice
+	EverPossibleToSpliceWrite() bool      //是否有机会splice, 如果这个返回false，则永远无法splice; 主要审视自己能否向裸连接写入数据; 读不用splicer担心。
+	CanSpliceWrite() (bool, *net.TCPConn) //当前状态是否可以splice
 }
 
-//tcp, unix
+// tcp, unix
 func CanRSplice(r io.Reader) bool {
 	switch r.(type) {
 	case *net.TCPConn, *net.UnixConn:
@@ -29,7 +29,7 @@ func CanRSplice(r io.Reader) bool {
 	}
 }
 
-//tcp
+// tcp
 func CanWSplice(w io.Writer) bool {
 	switch w.(type) {
 	case *net.TCPConn:
@@ -38,8 +38,8 @@ func CanWSplice(w io.Writer) bool {
 	return false
 }
 
-//这里认为能 splice 或 sendfile的 都算，具体可参考go标准代码的实现, 之前以为tcp和 unix domain socket 可以，仔细观察才发现，只有tcp可以。unix只是可以接受tcp的splice，但是不能主动进行splice。
-//就是说，tcp可以从tcp或者 stream oriented unix 来读取数据，用 splice 来写入tcp。但是unix不能被splice写入。
+// 这里认为能 splice 或 sendfile的 都算，具体可参考go标准代码的实现, 之前以为tcp和 unix domain socket 可以，仔细观察才发现，只有tcp可以。unix只是可以接受tcp的splice，但是不能主动进行splice。
+// 就是说，tcp可以从tcp或者 stream oriented unix 来读取数据，用 splice 来写入tcp。但是unix不能被splice写入。
 func CanSpliceDirectly(w io.Writer, r io.Reader) bool {
 
 	if CanWSplice(w) {
@@ -52,19 +52,18 @@ func CanSpliceDirectly(w io.Writer, r io.Reader) bool {
 
 func CanSpliceEventually(r any) bool {
 	if s, ok := r.(Splicer); ok {
-		return s.EverPossibleToSplice()
+		return s.EverPossibleToSpliceWrite()
 	}
 	return false
 }
 
-//从r读取数据，写入 maySpliceConn / classicWriter, 在条件合适时会使用splice进行加速。
+// 从r读取数据，写入 maySpliceConn / classicWriter, 在条件合适时会使用splice进行加速。
 //
 // 若maySpliceConn不是基本Conn，则会试图转换为Splicer并获取底层Conn.
 // 本函数主要应用于裸奔时，一端是socks5/直连,另一端是vless/vless+ws的情况, 因为vless等协议就算裸奔也是要处理一下数据头等情况的, 所以需要进行处理才可裸奔.
 //
 // 注意，splice只有在 maySpliceConn【本身是】/【变成】 basicConn， 且 r 也是 basicConn时，才会发生。
 // 如果r本身就不是 basicConn，则调用本函数没有意义, 因为既然拿不到basicConn那就不是裸奔，也就不可能splice。
-//
 func TryReadFrom_withSplice(classicWriter io.Writer, maySpliceW io.Writer, r io.Reader, canDirectFunc func() bool) (written int64, err error) {
 
 	underlay_canSpliceDirectly := CanSpliceDirectly(maySpliceW, r)
@@ -137,7 +136,7 @@ func TryReadFrom_withSplice(classicWriter io.Writer, maySpliceW io.Writer, r io.
 					}
 				} else {
 
-					if canStartSplice, rawConn := splicerW.CanSplice(); canStartSplice {
+					if canStartSplice, rawConn := splicerW.CanSpliceWrite(); canStartSplice {
 						if rawConn != nil {
 							var readfromN int64
 							readfromN, err = rawConn.ReadFrom(r)
@@ -167,8 +166,9 @@ func TryReadFrom_withSplice(classicWriter io.Writer, maySpliceW io.Writer, r io.
 
 }
 
-//拷贝自 io.CopyBuffer。 因为原始的 CopyBuffer会又调用ReadFrom, 如果splice调用的话会产生无限递归。
-//  这里删掉了ReadFrom, 直接进行经典拷贝
+// 拷贝自 io.CopyBuffer。 因为原始的 CopyBuffer会又调用ReadFrom, 如果splice调用的话会产生无限递归。
+//
+//	这里删掉了ReadFrom, 直接进行经典拷贝
 func ClassicCopy(w io.Writer, r io.Reader) (written int64, err error) {
 	buf := utils.GetPacket()
 	defer utils.PutPacket(buf)
diff --git a/proxy/simplesocks/tcpconn.go b/proxy/simplesocks/tcpconn.go
index b6c7f65..9e2618b 100644
--- a/proxy/simplesocks/tcpconn.go
+++ b/proxy/simplesocks/tcpconn.go
@@ -38,18 +38,18 @@ func (c *TCPConn) Write(p []byte) (int, error) {
 	return c.Conn.Write(p)
 }
 
-func (c *TCPConn) EverPossibleToSplice() bool {
+func (c *TCPConn) EverPossibleToSpliceWrite() bool {
 
 	if netLayer.IsTCP(c.Conn) != nil {
 		return true
 	}
 	if s, ok := c.Conn.(netLayer.Splicer); ok {
-		return s.EverPossibleToSplice()
+		return s.EverPossibleToSpliceWrite()
 	}
 	return false
 }
 
-func (c *TCPConn) CanSplice() (r bool, conn *net.TCPConn) {
+func (c *TCPConn) CanSpliceWrite() (r bool, conn *net.TCPConn) {
 	if !c.isServerEnd && c.remainFirstBufLen > 0 {
 		return false, nil
 	}
@@ -59,7 +59,7 @@ func (c *TCPConn) CanSplice() (r bool, conn *net.TCPConn) {
 		conn = tc
 
 	} else if s, ok := c.Conn.(netLayer.Splicer); ok {
-		r, conn = s.CanSplice()
+		r, conn = s.CanSpliceWrite()
 	}
 
 	return
diff --git a/proxy/trojan/tcpconn.go b/proxy/trojan/tcpconn.go
index d034ab2..c1a8976 100644
--- a/proxy/trojan/tcpconn.go
+++ b/proxy/trojan/tcpconn.go
@@ -41,18 +41,18 @@ func (c *UserTCPConn) Write(p []byte) (int, error) {
 	return c.Conn.Write(p)
 }
 
-func (c *UserTCPConn) EverPossibleToSplice() bool {
+func (c *UserTCPConn) EverPossibleToSpliceWrite() bool {
 
 	if netLayer.IsTCP(c.Conn) != nil {
 		return true
 	}
 	if s, ok := c.Conn.(netLayer.Splicer); ok {
-		return s.EverPossibleToSplice()
+		return s.EverPossibleToSpliceWrite()
 	}
 	return false
 }
 
-func (c *UserTCPConn) CanSplice() (r bool, conn *net.TCPConn) {
+func (c *UserTCPConn) CanSpliceWrite() (r bool, conn *net.TCPConn) {
 	if !c.isServerEnd && c.remainFirstBufLen > 0 {
 		return false, nil
 	}
@@ -62,7 +62,7 @@ func (c *UserTCPConn) CanSplice() (r bool, conn *net.TCPConn) {
 		conn = tc
 
 	} else if s, ok := c.Conn.(netLayer.Splicer); ok {
-		r, conn = s.CanSplice()
+		r, conn = s.CanSpliceWrite()
 	}
 
 	return
diff --git a/proxy/vless/tcpconn.go b/proxy/vless/tcpconn.go
index 7b89f2d..8bb9bbd 100644
--- a/proxy/vless/tcpconn.go
+++ b/proxy/vless/tcpconn.go
@@ -45,18 +45,18 @@ func (c *UserTCPConn) canDirectWrite() bool {
 	return c.version == 1 || (c.version == 0 && !(c.isServerEnd && !c.isntFirstPacket))
 }
 
-func (c *UserTCPConn) EverPossibleToSplice() bool {
+func (c *UserTCPConn) EverPossibleToSpliceWrite() bool {
 
 	if netLayer.IsTCP(c.Conn) != nil {
 		return true
 	}
 	if s, ok := c.Conn.(netLayer.Splicer); ok {
-		return s.EverPossibleToSplice()
+		return s.EverPossibleToSpliceWrite()
 	}
 	return false
 }
 
-func (c *UserTCPConn) CanSplice() (r bool, conn *net.TCPConn) {
+func (c *UserTCPConn) CanSpliceWrite() (r bool, conn *net.TCPConn) {
 
 	if !c.canDirectWrite() {
 		return
@@ -67,7 +67,7 @@ func (c *UserTCPConn) CanSplice() (r bool, conn *net.TCPConn) {
 		conn = tc
 
 	} else if s, ok := c.Conn.(netLayer.Splicer); ok {
-		r, conn = s.CanSplice()
+		r, conn = s.CanSpliceWrite()
 	}
 
 	return