mcp: add an sse event size cap (#1205)

update sse I/O code to limit the amount of memory a single
non-terminated event can take

---------

Co-authored-by: Guglielmo Colombo <guglielmoc@google.com>
This commit is contained in:
Yaroslav 2026-09-02 11:35:23 +02:00 • committed by GitHub
commit 3632967404
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -65,13 +65,21 @@ func writeEvent(w http.ResponseWriter, evt Event) (int, error) {
return n, err
}
// scanEvents iterates SSE events in the given scanner. The iterated error is
// terminal: if encountered, the stream is corrupt or broken and should no
// longer be used.
// DefaultMaxEventSize is the default maximum number of bytes buffered while
// reading a single server-sent event before the input is rejected.
const DefaultMaxEventSize = 16 << 20 // 16 MiB
// scanEventsLimited iterates SSE events in the given reader, buffering at most
// maxEventSize bytes per event. When maxEventSize > 0, an event is reported as
// [errMalformedEvent] once its size exceeds it; a non-positive maxEventSize
// disables the cap.
//
// The iterated error is terminal: if encountered, the stream is corrupt or
// broken and should no longer be used.
//
// TODO(rfindley): consider a different API here that makes failure modes more
// apparent.
func scanEvents(r io.Reader) iter.Seq2[Event, error] {
func scanEventsLimited(r io.Reader, maxEventSize int) iter.Seq2[Event, error] {
reader := bufio.NewReader(r)
// TODO: investigate proper behavior when events are out of order, or have
@ -94,8 +102,9 @@ func scanEvents(r io.Reader) iter.Seq2[Event, error] {
// - Lines starting with ":" are ignored.
// - Records are terminated with two consecutive newlines.
var (
evt Event
dataBuf *bytes.Buffer // if non-nil, preceding field was also data
evt Event
dataBuf *bytes.Buffer // if non-nil, preceding field was also data
eventBytes int // bytes read for the current, in-progress event
)
yieldEvent := func() bool {
if dataBuf != nil {
@ -112,11 +121,20 @@ func scanEvents(r io.Reader) iter.Seq2[Event, error] {
return true
}
for {
line, err := reader.ReadBytes('\n')
budget := -1
if maxEventSize > 0 {
budget = maxEventSize - eventBytes
}
line, err := readEventLine(reader, budget)
if errors.Is(err, errEventTooLarge) {
yield(Event{}, fmt.Errorf("%w: SSE event exceeded %d bytes without terminating", errMalformedEvent, maxEventSize))
return
}
if err != nil && !errors.Is(err, io.EOF) {
yield(Event{}, fmt.Errorf("error reading event: %v", err))
return
}
eventBytes += len(line)
line = bytes.TrimRight(line, "\r\n")
isEOF := errors.Is(err, io.EOF)
@ -124,6 +142,7 @@ func scanEvents(r io.Reader) iter.Seq2[Event, error] {
if !yieldEvent() {
return
}
eventBytes = 0 // reset the budget between events
if isEOF {
return
}
@ -322,6 +341,31 @@ var ErrEventsPurged = errors.New("data purged")
// transient I/O errors which may be retryable.
var errMalformedEvent = errors.New("malformed event")
// errEventTooLarge is returned by [readEventLine] when a single line would
// exceed the remaining per-event byte budget.
var errEventTooLarge = errors.New("SSE event exceeded maximum size")
// readEventLine reads a single '\n'-terminated line from r. When budget >= 0 it
// reads at most budget bytes, returning [errEventTooLarge] once that budget is
// exceeded before a newline arrives.
func readEventLine(r *bufio.Reader, budget int) ([]byte, error) {
if budget < 0 {
return r.ReadBytes('\n')
}
var line []byte
for {
frag, err := r.ReadSlice('\n')
if len(line)+len(frag) > budget {
return nil, errEventTooLarge
}
line = append(line, frag...)
if errors.Is(err, bufio.ErrBufferFull) {
continue // looking for delim
}
return line, err
}
}
// After implements [EventStore.After].
func (s *MemoryEventStore) After(_ context.Context, sessionID, streamID string, index int) iter.Seq2[[]byte, error] {
// Return the data items to yield.