mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
157 lines
3.3 KiB
Go
157 lines
3.3 KiB
Go
package anytls
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var errStreamClosed = errors.New("stream closed")
|
|
|
|
type stream struct {
|
|
id uint32
|
|
s *session
|
|
|
|
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
|
|
|
|
readDeadline streamDeadline
|
|
writeDeadline streamDeadline
|
|
}
|
|
|
|
func newStream(id uint32, s *session) *stream {
|
|
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) {
|
|
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
|
|
}
|
|
}
|
|
}
|
|
|
|
func (st *stream) Write(p []byte) (int, error) {
|
|
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)
|
|
accepted, err := st.s.writeStreamFrame(st, frame{command: cmdPSH, streamID: st.id, data: p[:n]})
|
|
written += accepted
|
|
if err != nil {
|
|
return written, err
|
|
}
|
|
p = p[n:]
|
|
}
|
|
return written, nil
|
|
}
|
|
|
|
func (st *stream) Close() error {
|
|
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.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 {
|
|
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
|
|
}
|