package muxer import ( "errors" "io" ) // Reader implements a buffered message reader for the muxer protocol. // It reads and decodes messages from an underlying io.Reader, handling buffering, // message framing, and varint-based length encoding. Reader is not safe for // concurrent use by multiple goroutines. type Reader struct { rd io.Reader r, w int buf []byte size int err error state int shift uint varint uint64 header uint64 length int consumed int latest []byte latestN int missing int ready bool } const ( minReadBufferSize = 16 defaultMaxMessageSize = 8 * 1024 * 1024 defaultBufSize = 4096 maxConsecutiveEmptyReads = 100 ) var ( ErrMessageSizeExceeded = errors.New("muxer: message too big") ErrMessageMalformed = errors.New("muxer: message malformed") ) // NewReader returns a new Reader reading from r. // // By default, a Reader allocates 4096 bytes for its internal buffer. // Use NewReaderSize to specify a different buffer size. func NewReader(rd io.Reader) *Reader { return NewReaderSize(rd, defaultBufSize) } // NewReaderSize returns a new Reader with the specified buffer size. func NewReaderSize(rd io.Reader, size int) *Reader { if size < minReadBufferSize { size = minReadBufferSize } r := new(Reader) r.reset(make([]byte, size), rd) return r } func (b *Reader) fill() { if b.r > 0 { copy(b.buf, b.buf[b.r:b.w]) b.w -= b.r b.r = 0 } length := len(b.buf) if b.w >= length { panic("muxer: tried to fill full buffer") } for i := maxConsecutiveEmptyReads; i > 0; i-- { n, err := b.rd.Read(b.buf[b.w:]) if n < 0 { panic("muxer: reader returned negative count from Read") } b.w += n if err != nil { if errors.Is(err, io.EOF) && b.state != 0 { err = io.ErrUnexpectedEOF } b.err = err return } if n > 0 { if length < n { b.err = io.ErrShortBuffer return } return } } b.err = io.ErrNoProgress } // ReadMessage reads a single message from r into the provided Message struct. func (b *Reader) ReadMessage(message *Message) (err error) { for { if b.err != nil { message = nil b.r = b.w err = b.readErr() break } // Found message? if b.state == 0 && b.ready { message.ID = b.header >> 4 message.Type = uint8(b.header & 0b1111) message.Data = b.latest[:b.latestN] b.ready = false b.latestN = 0 b.missing = 0 copy(b.buf, b.buf[b.r:b.w]) b.w -= b.r b.r = 0 break } // Reading ok? if b.state == 0 && b.r > 1 { b.r = b.w err = io.ErrNoProgress break } if b.r < b.w { if b.state == 2 { b.r = b.readMessage() } else { b.r = b.readVarint() } continue } if b.state == 2 && b.length == 0 { b.r = b.readMessage() continue } // Is buffer big enough? remaining := b.length - b.consumed if b.w+remaining > b.size { b.r = b.w err = io.ErrShortBuffer break } b.fill() } return } // Reset resets this Reader with the new source r, using the existing buffer. func (b *Reader) Reset(r io.Reader) { if b.buf == nil { b.buf = make([]byte, defaultBufSize) } b.reset(b.buf, r) } func (b *Reader) next() bool { switch b.state { case 0: b.state = 1 b.shift = 0 b.length = int(b.varint) b.consumed = 0 b.varint = 0 if b.length == 0 { b.state = 0 } return true case 1: b.state = 2 b.shift = 0 b.header = b.varint b.length -= b.consumed b.consumed = 0 b.varint = 0 if b.length < 0 || b.length > defaultMaxMessageSize { b.err = ErrMessageSizeExceeded return false } extra := len(b.buf[:b.w]) - b.r if b.length > extra { b.missing = b.length - extra } return true case 2: b.state = 0 b.ready = true return b.err == nil default: return false } } func (b *Reader) readMessage() int { data, offset := b.buf[:b.w], b.r length := len(data) free := length - offset if free >= b.length { copy(b.latest[b.latestN:], data[offset:offset+b.length]) b.latestN += b.length offset += b.length if b.next() { return offset } return length } copy(b.latest[b.latestN:], data[offset:offset+free]) b.latestN += free b.length -= free return length } func (b *Reader) readVarint() int { data, offset := b.buf[:b.w], b.r for ; offset < len(data); offset++ { b.varint |= uint64(data[offset]&0x7F) << b.shift b.consumed += 1 if data[offset] < 128 { offset += 1 if b.next() { return offset } return len(data) } b.shift += 7 } if b.consumed >= 11 { b.err = ErrMessageMalformed } return len(data) } func (b *Reader) readErr() error { err := b.err b.err = nil return err } func (b *Reader) reset(buf []byte, r io.Reader) { latest := b.latest if cap(latest) < len(buf) { latest = make([]byte, len(buf)) } *b = Reader{ rd: r, buf: buf, size: len(buf), shift: 0, latest: latest[:cap(latest)], } }