chore: optimize code
Build / Build (push) Has been cancelled

This commit is contained in:
nadoo committed 2026-11-16 21:08:27 +08:00
1 parent 9eadb8d9f4
commit a7d0421c93
15 files changed
+422 -171

No files matched your search

+27 -12
View File
@@ -4,6 +4,7 @@ import (
"crypto/tls"
"fmt"
"net"
"time"
"github.com/nadoo/glider/pkg/log"
"github.com/nadoo/glider/pkg/socks"
@@ -60,7 +61,7 @@ func (s *AnyTLS) Dial(network, addr string) (net.Conn, error) {
_ = ss.Close()
return nil, err
}
return &clientConn{Conn: st, session: ss}, nil
return &clientConn{stream: st}, nil
}
func (s *AnyTLS) DialUDP(network, addr string) (net.PacketConn, error) {
@@ -99,7 +100,7 @@ func (s *AnyTLS) DialUDP(network, addr string) (net.PacketConn, error) {
_ = ss.Close()
return nil, err
}
return &clientPacketConn{PacketConn: newUOTPacketConn(st, target), session: ss}, nil
return &clientPacketConn{PacketConn: newUOTPacketConn(st, target), stream: st}, nil
}
func (s *AnyTLS) newClientSession() (*session, error) {
@@ -123,7 +124,7 @@ func (s *AnyTLS) newClientSession() (*session, error) {
}
ss := newSession(c)
if err := ss.writeFrame(frame{command: cmdSettings, data: clientSettings(s.padding)}); err != nil {
_ = c.Close()
_ = ss.Close()
return nil, err
}
ss.start()
@@ -131,23 +132,37 @@ func (s *AnyTLS) newClientSession() (*session, error) {
}
type clientConn struct {
net.Conn
session *session
*stream
}
func (c *clientConn) Close() error {
err := c.Conn.Close()
_ = c.session.Close()
return err
return closeClientSession(c.stream)
}
type clientPacketConn struct {
net.PacketConn
session *session
stream *stream
}
func (c *clientPacketConn) Close() error {
err := c.PacketConn.Close()
_ = c.session.Close()
return err
return closeClientSession(c.stream)
}
const clientFINTimeout = time.Second
// The client owns the whole session. Give FIN a chance to reach the transport
// before tearing it down, while keeping standalone stream.Close nonblocking.
func closeClientSession(st *stream) error {
_ = st.Close()
defer st.s.Close()
if st.fin != nil {
timer := time.NewTimer(clientFINTimeout)
defer timer.Stop()
select {
case <-st.fin.result:
case <-st.s.done:
case <-timer.C:
}
}
return nil
}
+7 -4
View File
@@ -83,15 +83,18 @@ func readFrame(r io.Reader) (frame, error) {
return frame{command: head[0], streamID: binary.BigEndian.Uint32(head[1:5]), data: data}, nil
}
func writeFrame(w io.Writer, f frame) error {
func writeFrame(w io.Writer, f frame) (int, error) {
if len(f.data) > maxFrameData {
return errors.New("frame data too large")
return 0, errors.New("frame data too large")
}
buf := make([]byte, 7+len(f.data))
buf[0] = f.command
binary.BigEndian.PutUint32(buf[1:5], f.streamID)
binary.BigEndian.PutUint16(buf[5:7], uint16(len(f.data)))
copy(buf[7:], f.data)
_, err := w.Write(buf)
return err
n, err := w.Write(buf)
if n < len(buf) && err == nil {
err = io.ErrShortWrite
}
return max(0, n-7), err
}
+162 -14
View File
@@ -1,10 +1,13 @@
package anytls
import (
"bytes"
"container/list"
"errors"
"fmt"
"io"
"net"
"os"
"sync"
"sync/atomic"
"time"
@@ -13,16 +16,19 @@ import (
type session struct {
conn net.Conn
writeMu sync.Mutex
mu sync.Mutex
streams map[uint32]*stream
synack map[uint32]chan synackResult
nextID atomic.Uint32
writeMu sync.Mutex
writes list.List
writeWake chan struct{}
mu sync.Mutex
streams map[uint32]*stream
synack map[uint32]chan synackResult
nextID atomic.Uint32
incoming chan *stream
done chan struct{}
closeOnce sync.Once
err atomic.Value
errOnce sync.Once
settingsSeen bool
}
@@ -31,15 +37,33 @@ type synackResult struct {
data []byte
}
type frameWrite struct {
frame frame
stream *stream
deadline <-chan struct{}
result chan frameWriteResult
// Guarded by session.writeMu.
elem *list.Element
started bool
}
type frameWriteResult struct {
n int // payload bytes, excluding the frame header
err error
}
func newSession(conn net.Conn) *session {
s := &session{
conn: conn,
streams: map[uint32]*stream{},
synack: map[uint32]chan synackResult{},
incoming: make(chan *stream, 32),
done: make(chan struct{}),
conn: conn,
streams: map[uint32]*stream{},
synack: map[uint32]chan synackResult{},
incoming: make(chan *stream, 32),
done: make(chan struct{}),
writeWake: make(chan struct{}, 1),
}
s.nextID.Store(1)
go s.writeLoop()
return s
}
@@ -103,9 +127,126 @@ func (s *session) waitSYNACK(id uint32, timeout time.Duration) error {
}
func (s *session) writeFrame(f frame) error {
req, err := s.queueFrame(f, nil, nil)
if err != nil {
return err
}
select {
case result := <-req.result:
return result.err
case <-s.done:
return s.Err()
}
}
func (s *session) writeStreamFrame(st *stream, f frame) (int, error) {
if channelClosed(st.done) {
return 0, errStreamClosed
}
deadline := st.writeDeadline.wait()
if channelClosed(deadline) {
return 0, os.ErrDeadlineExceeded
}
req, err := s.queueFrame(f, st, deadline)
if err != nil {
return 0, err
}
select {
case result := <-req.result:
return result.n, result.err
case <-st.done:
err = errStreamClosed
case <-s.done:
err = s.Err()
case <-deadline:
err = os.ErrDeadlineExceeded
}
started := s.cancelWrite(req)
// Prefer the transport result when both completion and cancellation are ready.
select {
case result := <-req.result:
return result.n, result.err
default:
}
if started {
// The writer owns the whole frame once it starts. Its payload can
// still reach the peer after this call returns, so count it in n.
return len(f.data), err
}
return 0, err
}
func (s *session) queueFrame(f frame, st *stream, deadline <-chan struct{}) (*frameWrite, error) {
// A stream may time out while the transport is writing. Own the payload so
// the caller can reuse its buffer without racing with the session writer.
f.data = bytes.Clone(f.data)
req := &frameWrite{frame: f, stream: st, deadline: deadline, result: make(chan frameWriteResult, 1)}
s.writeMu.Lock()
defer s.writeMu.Unlock()
return writeFrame(s.conn, f)
if channelClosed(s.done) {
return nil, s.Err()
}
req.elem = s.writes.PushBack(req)
select {
case s.writeWake <- struct{}{}:
default:
}
return req, nil
}
// cancelWrite removes a pending request and reports whether it had already started.
func (s *session) cancelWrite(req *frameWrite) bool {
s.writeMu.Lock()
defer s.writeMu.Unlock()
if req.elem != nil {
s.writes.Remove(req.elem)
req.elem = nil
}
return req.started
}
func (s *session) writeLoop() {
for {
select {
case <-s.done:
return
case <-s.writeWake:
}
for {
s.writeMu.Lock()
elem := s.writes.Front()
if elem == nil || channelClosed(s.done) {
s.writeMu.Unlock()
break
}
req := s.writes.Remove(elem).(*frameWrite)
req.elem = nil
if st := req.stream; st != nil {
if channelClosed(st.done) {
s.writeMu.Unlock()
req.result <- frameWriteResult{err: errStreamClosed}
continue
}
if channelClosed(req.deadline) {
s.writeMu.Unlock()
req.result <- frameWriteResult{err: os.ErrDeadlineExceeded}
continue
}
}
req.started = true
s.writeMu.Unlock()
// An in-flight frame must finish intact even if its stream times out.
// Only closing the session may interrupt the shared transport write.
n, err := writeFrame(s.conn, req.frame)
req.result <- frameWriteResult{n: n, err: err}
close(req.result)
if err != nil {
s.setErr(err)
s.Close()
return
}
}
}
}
func (s *session) readLoop() {
@@ -202,8 +343,8 @@ func (s *session) removeStream(id uint32) {
}
func (s *session) setErr(err error) {
if err != nil && s.err.Load() == nil {
s.err.Store(err)
if err != nil {
s.errOnce.Do(func() { s.err.Store(err) })
}
}
@@ -218,8 +359,16 @@ func (s *session) Close() error {
s.closeOnce.Do(func() {
close(s.done)
_ = s.conn.Close()
s.writeMu.Lock()
for elem := s.writes.Front(); elem != nil; elem = elem.Next() {
elem.Value.(*frameWrite).elem = nil
}
s.writes.Init()
s.writeMu.Unlock()
s.mu.Lock()
for _, st := range s.streams {
st.readDeadline.stop()
st.writeDeadline.stop()
st.closeRead()
}
s.streams = map[uint32]*stream{}
@@ -227,7 +376,6 @@ func (s *session) Close() error {
delete(s.synack, id)
close(ch)
}
close(s.incoming)
s.mu.Unlock()
})
return nil
+99 -36
View File
@@ -4,6 +4,7 @@ import (
"errors"
"io"
"net"
"os"
"sync"
"time"
)
@@ -14,80 +15,142 @@ type stream struct {
id uint32
s *session
in chan []byte
readBuf []byte
closeIn sync.Once
closeOut sync.Once
in chan []byte
readBuf []byte
readDone chan struct{}
done chan struct{}
closeIn sync.Once
closeOnce sync.Once
fin *frameWrite // published by closeOnce
readMu sync.Mutex
writeMu sync.Mutex
mu sync.Mutex
closed bool
readDeadline streamDeadline
writeDeadline streamDeadline
}
func newStream(id uint32, s *session) *stream {
return &stream{id: id, s: s, in: make(chan []byte, 32)}
return &stream{
id: id, s: s, in: make(chan []byte, 32),
readDone: make(chan struct{}), done: make(chan struct{}),
}
}
func (st *stream) Read(p []byte) (int, error) {
for len(st.readBuf) == 0 {
b, ok := <-st.in
if !ok {
return 0, io.EOF
st.readMu.Lock()
defer st.readMu.Unlock()
for {
if channelClosed(st.done) {
return 0, net.ErrClosed
}
deadline := st.readDeadline.wait()
if channelClosed(deadline) {
return 0, os.ErrDeadlineExceeded
}
if len(p) == 0 {
return 0, nil
}
if len(st.readBuf) > 0 {
n := copy(p, st.readBuf)
st.readBuf = st.readBuf[n:]
return n, nil
}
// A peer FIN ends input after previously received data has been read.
select {
case st.readBuf = <-st.in:
continue
default:
}
select {
case st.readBuf = <-st.in:
case <-st.readDone:
select {
case st.readBuf = <-st.in:
default:
return 0, io.EOF
}
case <-st.done:
return 0, net.ErrClosed
case <-st.s.done:
return 0, st.s.Err()
case <-deadline:
return 0, os.ErrDeadlineExceeded
}
st.readBuf = b
}
n := copy(p, st.readBuf)
st.readBuf = st.readBuf[n:]
return n, nil
}
func (st *stream) Write(p []byte) (int, error) {
st.mu.Lock()
closed := st.closed
st.mu.Unlock()
if closed {
st.writeMu.Lock()
defer st.writeMu.Unlock()
if channelClosed(st.done) {
return 0, errStreamClosed
}
if channelClosed(st.writeDeadline.wait()) {
return 0, os.ErrDeadlineExceeded
}
written := 0
for len(p) > 0 {
n := min(len(p), maxFrameData)
if err := st.s.writeFrame(frame{command: cmdPSH, streamID: st.id, data: p[:n]}); err != nil {
accepted, err := st.s.writeStreamFrame(st, frame{command: cmdPSH, streamID: st.id, data: p[:n]})
written += accepted
if err != nil {
return written, err
}
written += n
p = p[n:]
}
return written, nil
}
func (st *stream) Close() error {
st.mu.Lock()
already := st.closed
st.closed = true
st.mu.Unlock()
if !already {
st.closeOut.Do(func() {
_ = st.s.writeFrame(frame{command: cmdFIN, streamID: st.id})
})
st.closeOnce.Do(func() {
close(st.done)
st.readDeadline.stop()
st.writeDeadline.stop()
st.s.removeStream(st.id)
}
// FIN is queued behind any frame already being written. Closing a stream
// must not wait for a stalled transport or interrupt another stream.
st.fin, _ = st.s.queueFrame(frame{command: cmdFIN, streamID: st.id}, nil, nil)
})
return nil
}
func (st *stream) closeRead() {
st.closeIn.Do(func() { close(st.in) })
st.closeIn.Do(func() { close(st.readDone) })
}
func (st *stream) push(data []byte) {
if channelClosed(st.done) || channelClosed(st.readDone) || channelClosed(st.s.done) {
return
}
cp := make([]byte, len(data))
copy(cp, data)
select {
case st.in <- cp:
case <-st.done:
case <-st.readDone:
case <-st.s.done:
}
}
func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() }
func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() }
func (st *stream) SetDeadline(t time.Time) error { return st.s.conn.SetDeadline(t) }
func (st *stream) SetReadDeadline(t time.Time) error { return st.s.conn.SetReadDeadline(t) }
func (st *stream) SetWriteDeadline(t time.Time) error { return st.s.conn.SetWriteDeadline(t) }
func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() }
func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() }
func (st *stream) SetDeadline(t time.Time) error {
if err := st.SetReadDeadline(t); err != nil {
return err
}
return st.SetWriteDeadline(t)
}
func (st *stream) SetReadDeadline(t time.Time) error {
if channelClosed(st.done) || channelClosed(st.s.done) {
return net.ErrClosed
}
st.readDeadline.set(t)
return nil
}
func (st *stream) SetWriteDeadline(t time.Time) error {
if channelClosed(st.done) || channelClosed(st.s.done) {
return net.ErrClosed
}
st.writeDeadline.set(t)
return nil
}