chore: use Go1.26

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM golang:1.24-alpine AS build-env
+FROM golang:1.26-alpine AS build-env
 ADD . /src
 RUN apk --no-cache add git \
     && cd /src && go build -v -ldflags "-s -w"

dns/message.go

@@ -443,7 +443,7 @@ func (m *Message) UnmarshalRR(start int, rr *RR) (n int, err error) {
 // MarshalDomainTo marshals domain string struct to []byte and write to w.
 func MarshalDomainTo(w io.Writer, domain string) (n int, err error) {
 	nn := 0
-	for _, seg := range strings.Split(domain, ".") {
+	for seg := range strings.SplitSeq(domain, ".") {
 		nn, err = w.Write([]byte{byte(len(seg))})
 		if err != nil {
 			return

proxy/anytls/padding.go

@@ -20,7 +20,7 @@ func parsePaddingScheme(raw string) (paddingScheme, error) {
 		raw = defaultPaddingScheme
 	}
 	ps := paddingScheme{raw: raw, authRange: [2]int{0, 0}}
-	for _, line := range strings.Split(raw, "\n") {
+	for line := range strings.SplitSeq(raw, "\n") {
 		line = strings.TrimSpace(line)
 		if line == "" {
 			continue

proxy/anytls/settings.go

@@ -26,7 +26,7 @@ func encodeSettings(m map[string]string) []byte {
 
 func parseSettings(data []byte) map[string]string {
 	out := map[string]string{}
-	for _, line := range strings.Split(string(data), "\n") {
+	for line := range strings.SplitSeq(string(data), "\n") {
 		if line == "" {
 			continue
 		}

proxy/anytls/stream.go

@@ -49,10 +49,7 @@ func (st *stream) Write(p []byte) (int, error) {
 	}
 	written := 0
 	for len(p) > 0 {
-		n := len(p)
+		n := min(len(p), maxFrameData)
-		if n > maxFrameData {
-			n = maxFrameData
-		}
 		if err := st.s.writeFrame(frame{command: cmdPSH, streamID: st.id, data: p[:n]}); err != nil {
 			return written, err
 		}

proxy/conn.go

@@ -57,12 +57,10 @@ func Relay(left, right net.Conn) error {
 	var wg sync.WaitGroup
 	var wait = 5 * time.Second
 
-	wg.Add(1)
+	wg.Go(func() {
-	go func() {
-		defer wg.Done()
 		_, err1 = Copy(right, left)
 		right.SetReadDeadline(time.Now().Add(wait)) // unblock read on right
-	}()
+	})
 
 	_, err = Copy(left, right)
 	left.SetReadDeadline(time.Now().Add(wait)) // unblock read on left

proxy/obfs/tls.go

@@ -104,10 +104,7 @@ func (c *TLSObfsConn) Read(b []byte) (int, error) {
 		c.leftBytes = int(binary.BigEndian.Uint16(c.buf[:lenSize]))
 	}
 
-	readLen := len(b)
+	readLen := min(len(b), c.leftBytes)
-	if readLen > c.leftBytes {
-		readLen = c.leftBytes
-	}
 
 	m, err := c.reader.Read(b[:readLen])
 	if err != nil {

proxy/ss/cipher/shadowstream/stream.go

@@ -24,10 +24,7 @@ func (w *writer) Write(p []byte) (n int, err error) {
 	defer pool.PutBuffer(buf)
 
 	for nw := 0; n < len(p) && err == nil; n += nw {
-		end := n + len(buf)
+		end := min(n+len(buf), len(p))
-		if end > len(p) {
-			end = len(p)
-		}
 		w.XORKeyStream(buf, p[n:end])
 		nw, err = w.Writer.Write(buf[:end-n])
 	}

proxy/vmess/aead.go

@@ -39,10 +39,7 @@ func (w *aeadWriter) Write(b []byte) (n int, err error) {
 
 	nonce := w.nonce[:w.NonceSize()]
 	for left := len(b); left != 0; {
-		writeLen = left + w.Overhead()
+		writeLen = min(left+w.Overhead(), chunkSize)
-		if writeLen > chunkSize {
-			writeLen = chunkSize
-		}
 		dataLen = writeLen - w.Overhead()
 
 		w.chunkSizeEncoder.Encode(uint16(writeLen), lenBuf)

proxy/vmess/chunk.go

@@ -23,10 +23,7 @@ func ChunkedWriter(w io.Writer, chunkSizeEncoder ChunkSizeEncoder) io.Writer {
 func (w *chunkedWriter) Write(p []byte) (n int, err error) {
 	var dataLen int
 	for left := len(p); left != 0; {
-		dataLen = left
+		dataLen = min(left, chunkSize)
-		if dataLen > chunkSize {
-			dataLen = chunkSize
-		}
 		w.chunkSizeEncoder.Encode(uint16(dataLen), w.buf)
 		if _, err = (&net.Buffers{w.buf[:], p[n : n+dataLen]}).WriteTo(w.Writer); err != nil {
 			break
@@ -69,10 +66,7 @@ func (r *chunkedReader) Read(p []byte) (int, error) {
 		}
 	}
 
-	readLen := len(p)
+	readLen := min(len(p), r.left)
-	if readLen > r.left {
-		readLen = r.left
-	}
 
 	n, err := r.Reader.Read(p[:readLen])
 	if err != nil {

proxy/ws/frame.go

@@ -151,10 +151,7 @@ func (r *frameReader) Read(b []byte) (int, error) {
 		}
 	}
 
-	readLen := int64(len(b))
+	readLen := min(int64(len(b)), r.left)
-	if readLen > r.left {
-		readLen = r.left
-	}
 
 	m, err := io.ReadFull(r.Reader, b[:readLen])
 	if err != nil {