mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
383 lines
7.7 KiB
Go
383 lines
7.7 KiB
Go
package anytls
|
|
|
|
import (
|
|
"bytes"
|
|
"container/list"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
type session struct {
|
|
conn net.Conn
|
|
|
|
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
|
|
}
|
|
|
|
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{}),
|
|
writeWake: make(chan struct{}, 1),
|
|
}
|
|
s.nextID.Store(1)
|
|
go s.writeLoop()
|
|
return s
|
|
}
|
|
|
|
func (s *session) start() {
|
|
go s.readLoop()
|
|
}
|
|
|
|
func (s *session) acceptStream() (*stream, error) {
|
|
select {
|
|
case st, ok := <-s.incoming:
|
|
if !ok {
|
|
return nil, s.Err()
|
|
}
|
|
return st, nil
|
|
case <-s.done:
|
|
return nil, s.Err()
|
|
}
|
|
}
|
|
|
|
func (s *session) openStream() (*stream, error) {
|
|
id := s.nextID.Add(1) - 1
|
|
st := newStream(id, s)
|
|
s.mu.Lock()
|
|
s.streams[id] = st
|
|
s.synack[id] = make(chan synackResult, 1)
|
|
s.mu.Unlock()
|
|
if err := s.writeFrame(frame{command: cmdSYN, streamID: id}); err != nil {
|
|
s.removeStream(id)
|
|
return nil, err
|
|
}
|
|
return st, nil
|
|
}
|
|
|
|
func (s *session) waitSYNACK(id uint32, timeout time.Duration) error {
|
|
s.mu.Lock()
|
|
ch := s.synack[id]
|
|
s.mu.Unlock()
|
|
if ch == nil {
|
|
return nil
|
|
}
|
|
var timer <-chan time.Time
|
|
if timeout > 0 {
|
|
t := time.NewTimer(timeout)
|
|
defer t.Stop()
|
|
timer = t.C
|
|
}
|
|
select {
|
|
case r, ok := <-ch:
|
|
if !ok {
|
|
return s.Err()
|
|
}
|
|
if len(r.data) > 0 {
|
|
return fmt.Errorf("stream open failed: %s", string(r.data))
|
|
}
|
|
return nil
|
|
case <-timer:
|
|
return errors.New("timeout waiting for SYNACK")
|
|
case <-s.done:
|
|
return s.Err()
|
|
}
|
|
}
|
|
|
|
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()
|
|
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() {
|
|
for {
|
|
f, err := readFrame(s.conn)
|
|
if err != nil {
|
|
if !errors.Is(err, io.EOF) {
|
|
s.setErr(err)
|
|
}
|
|
s.Close()
|
|
return
|
|
}
|
|
if err := s.handleFrame(f); err != nil {
|
|
s.setErr(err)
|
|
s.Close()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *session) handleFrame(f frame) error {
|
|
switch f.command {
|
|
case cmdWaste:
|
|
return nil
|
|
case cmdHeartRequest:
|
|
return s.writeFrame(frame{command: cmdHeartResponse, streamID: f.streamID})
|
|
case cmdHeartResponse:
|
|
return nil
|
|
case cmdSettings:
|
|
m := parseSettings(f.data)
|
|
s.settingsSeen = true
|
|
if settingsVersion(m) >= 2 {
|
|
return s.writeFrame(frame{command: cmdServerSettings, data: serverSettings()})
|
|
}
|
|
case cmdServerSettings:
|
|
return nil
|
|
case cmdAlert:
|
|
return errors.New("alert: " + string(f.data))
|
|
case cmdUpdatePaddingScheme:
|
|
return nil
|
|
case cmdSYN:
|
|
if !s.settingsSeen {
|
|
_ = s.writeFrame(frame{command: cmdAlert, data: []byte("cmdSYN received before cmdSettings")})
|
|
return errors.New("cmdSYN received before cmdSettings")
|
|
}
|
|
st := newStream(f.streamID, s)
|
|
s.mu.Lock()
|
|
s.streams[f.streamID] = st
|
|
s.mu.Unlock()
|
|
select {
|
|
case s.incoming <- st:
|
|
case <-s.done:
|
|
}
|
|
case cmdSYNACK:
|
|
s.mu.Lock()
|
|
ch := s.synack[f.streamID]
|
|
delete(s.synack, f.streamID)
|
|
s.mu.Unlock()
|
|
if ch != nil {
|
|
ch <- synackResult{data: f.data}
|
|
close(ch)
|
|
}
|
|
case cmdPSH:
|
|
st := s.getStream(f.streamID)
|
|
if st != nil {
|
|
st.push(f.data)
|
|
}
|
|
case cmdFIN:
|
|
st := s.getStream(f.streamID)
|
|
if st != nil {
|
|
st.closeRead()
|
|
s.removeStream(f.streamID)
|
|
}
|
|
default:
|
|
return errors.New("unknown command")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *session) getStream(id uint32) *stream {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.streams[id]
|
|
}
|
|
|
|
func (s *session) removeStream(id uint32) {
|
|
s.mu.Lock()
|
|
delete(s.streams, id)
|
|
if ch := s.synack[id]; ch != nil {
|
|
delete(s.synack, id)
|
|
close(ch)
|
|
}
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func (s *session) setErr(err error) {
|
|
if err != nil {
|
|
s.errOnce.Do(func() { s.err.Store(err) })
|
|
}
|
|
}
|
|
|
|
func (s *session) Err() error {
|
|
if v := s.err.Load(); v != nil {
|
|
return v.(error)
|
|
}
|
|
return net.ErrClosed
|
|
}
|
|
|
|
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{}
|
|
for id, ch := range s.synack {
|
|
delete(s.synack, id)
|
|
close(ch)
|
|
}
|
|
s.mu.Unlock()
|
|
})
|
|
return nil
|
|
}
|