0
0
package channelconn
import (
"io"
"net"
"os"
"sync"
"time"
)
const chunk = 16 << 10
type addr struct {
network string
address string
}
func (a addr) Network() string { return a.network }
func (a addr) String() string { return a.address }
type Conn struct {
send func([]byte) error
shut func() error
in chan []byte
done chan struct{}
once sync.Once
err error
mu sync.Mutex
buf []byte
readDeadline time.Time
writeDeadline time.Time
}
func New(send func([]byte) error, shut func() error) *Conn {
if send == nil {
send = func([]byte) error { return io.ErrClosedPipe }
}
if shut == nil {
shut = func() error { return nil }
}
return &Conn{
send: send,
shut: shut,
in: make(chan []byte, 64),
done: make(chan struct{}),
}
}
func (c *Conn) Push(data []byte) bool {
if len(data) == 0 {
return true
}
select {
case <-c.done:
return false
default:
}
copied := append([]byte(nil), data...)
select {
case c.in <- copied:
return true
case <-c.done:
return false
}
}
func (c *Conn) CloseWithError(err error) {
if err == nil {
err = io.EOF
}
c.once.Do(func() {
c.mu.Lock()
c.err = err
c.mu.Unlock()
close(c.done)
})
}
func (c *Conn) Read(p []byte) (int, error) {
c.mu.Lock()
if len(c.buf) > 0 {
n := copy(p, c.buf)
c.buf = c.buf[n:]
c.mu.Unlock()
return n, nil
}
deadline := c.readDeadline
c.mu.Unlock()
var expire <-chan time.Time
if !deadline.IsZero() {
left := time.Until(deadline)
if left <= 0 {
return 0, os.ErrDeadlineExceeded
}
timer := time.NewTimer(left)
defer timer.Stop()
expire = timer.C
}
select {
case data := <-c.in:
n := copy(p, data)
if n < len(data) {
c.mu.Lock()
c.buf = append(c.buf, data[n:]...)
c.mu.Unlock()
}
return n, nil
case <-c.done:
select {
case data := <-c.in:
n := copy(p, data)
if n < len(data) {
c.mu.Lock()
c.buf = append(c.buf, data[n:]...)
c.mu.Unlock()
}
return n, nil
default:
return 0, c.closeError()
}
case <-expire:
return 0, os.ErrDeadlineExceeded
}
}
func (c *Conn) Write(p []byte) (int, error) {
written := 0
for written < len(p) {
select {
case <-c.done:
return written, c.closeError()
default:
}
if err := c.writeExpired(); err != nil {
return written, err
}
n := min(len(p)-written, chunk)
if err := c.send(p[written : written+n]); err != nil {
return written, err
}
written += n
}
return written, nil
}
func (c *Conn) writeExpired() error {
c.mu.Lock()
deadline := c.writeDeadline
c.mu.Unlock()
if !deadline.IsZero() && !time.Now().Before(deadline) {
return os.ErrDeadlineExceeded
}
return nil
}
func (c *Conn) Close() error {
c.CloseWithError(io.EOF)
return c.shut()
}
func (c *Conn) closeError() error {
c.mu.Lock()
defer c.mu.Unlock()
if c.err == nil {
return io.EOF
}
return c.err
}
func (c *Conn) LocalAddr() net.Addr { return addr{network: "webrtc", address: "local"} }
func (c *Conn) RemoteAddr() net.Addr { return addr{network: "webrtc", address: "remote"} }
func (c *Conn) SetDeadline(at time.Time) error {
c.mu.Lock()
c.readDeadline, c.writeDeadline = at, at
c.mu.Unlock()
return nil
}
func (c *Conn) SetReadDeadline(at time.Time) error {
c.mu.Lock()
c.readDeadline = at
c.mu.Unlock()
return nil
}
func (c *Conn) SetWriteDeadline(at time.Time) error {
c.mu.Lock()
c.writeDeadline = at
c.mu.Unlock()
return nil
}
var _ net.Conn = (*Conn)(nil)