Cloak/internal/multiplex/datagramBuffer.go

// This is base on https://github.com/golang/go/blob/0436b162397018c45068b47ca1b5924a3eafdee0/src/net/net_fake.go#L173

package multiplex

import (
	"bytes"
	"io"
	"sync"
	"sync/atomic"
	"time"
)

// datagramBuffer is the same as bufferedPipe with the exception that it's message-oriented,
// instead of byte-oriented. The integrity of datagrams written into this buffer is preserved.
// it won't get chopped up into individual bytes
type datagramBuffer struct {
	pLens     []int
	buf       *bytes.Buffer
	closed    uint32
	rwCond    *sync.Cond
	rDeadline time.Time
}

func NewDatagramBuffer() *datagramBuffer {
	d := &datagramBuffer{
		rwCond: sync.NewCond(&sync.Mutex{}),
	}
	return d
}

func (d *datagramBuffer) Read(target []byte) (int, error) {
	d.rwCond.L.Lock()
	defer d.rwCond.L.Unlock()
	if d.buf == nil {
		d.buf = new(bytes.Buffer)
	}
	for {
		if atomic.LoadUint32(&d.closed) == 1 && len(d.pLens) == 0 {
			return 0, io.EOF
		}

		if !d.rDeadline.IsZero() {
			delta := time.Until(d.rDeadline)
			if delta <= 0 {
				return 0, ErrTimeout
			}
			time.AfterFunc(delta, d.rwCond.Broadcast)
		}

		if len(d.pLens) > 0 {
			break
		}
		d.rwCond.Wait()
	}
	dataLen := d.pLens[0]
	if len(target) < dataLen {
		return 0, io.ErrShortBuffer
	}
	d.pLens = d.pLens[1:]
	d.buf.Read(target[:dataLen])
	// err will always be nil because we have already verified that buf.Len() != 0
	d.rwCond.Broadcast()
	return dataLen, nil
}

func (d *datagramBuffer) WriteTo(w io.Writer) (n int64, err error) {
	d.rwCond.L.Lock()
	defer d.rwCond.L.Unlock()
	if d.buf == nil {
		d.buf = new(bytes.Buffer)
	}
	for {
		if atomic.LoadUint32(&d.closed) == 1 && len(d.pLens) == 0 {
			return 0, io.EOF
		}

		if !d.rDeadline.IsZero() {
			delta := time.Until(d.rDeadline)
			if delta <= 0 {
				return 0, ErrTimeout
			}
			time.AfterFunc(delta, d.rwCond.Broadcast)
		}

		if len(d.pLens) > 0 {
			var dataLen int
			dataLen, d.pLens = d.pLens[0], d.pLens[1:]
			written, er := w.Write(d.buf.Next(dataLen))
			n += int64(written)
			if er != nil {
				d.rwCond.Broadcast()
				return n, er
			}
			d.rwCond.Broadcast()
		}
		d.rwCond.Wait()
	}
}

func (d *datagramBuffer) Write(f Frame) (toBeClosed bool, err error) {
	d.rwCond.L.Lock()
	defer d.rwCond.L.Unlock()
	if d.buf == nil {
		d.buf = new(bytes.Buffer)
	}
	for {
		if atomic.LoadUint32(&d.closed) == 1 {
			return true, io.ErrClosedPipe
		}
		if d.buf.Len() <= BUF_SIZE_LIMIT {
			// if d.buf gets too large, write() will panic. We don't want this to happen
			break
		}
		d.rwCond.Wait()
	}

	if f.Closing != C_NOOP {
		atomic.StoreUint32(&d.closed, 1)
		d.rwCond.Broadcast()
		return true, nil
	}

	dataLen := len(f.Payload)
	d.pLens = append(d.pLens, dataLen)
	d.buf.Write(f.Payload)
	// err will always be nil
	d.rwCond.Broadcast()
	return false, nil
}

func (d *datagramBuffer) Close() error {
	atomic.StoreUint32(&d.closed, 1)
	d.rwCond.Broadcast()
	return nil
}

func (d *datagramBuffer) SetReadDeadline(t time.Time) {
	d.rwCond.L.Lock()
	defer d.rwCond.L.Unlock()

	d.rDeadline = t
	d.rwCond.Broadcast()
}