BUG/MEDIUM: runtime: fix data race on lastError causing nil pointer panic

The lastError field was read by Listen() and written by the internal
listen() goroutine without synchronization. When Close() was called
externally (e.g. during HAProxy reload), the events channel could be
closed before listen() had set lastError. The caller would then read
a partially-written error interface value: a non-nil interface with a
nil underlying *wrapError pointer. Calling errors.Is() on this would
dereference the nil pointer in fmt.(*wrapError).Unwrap().

Fix by protecting lastError with a sync.Mutex via setLastError/
getLastError accessors. Also return io.EOF as a fallback when the
events channel is closed but no error was recorded, instead of
returning nil which callers would interpret as success.

Author: mjuraga

runtime/runtime_event_listener.go

@@ -20,9 +20,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"io"
 	"net"
 	"slices"
 	"strings"
+	"sync"
 	"sync/atomic"
 	"time"
 )
@@ -57,11 +59,12 @@ type EventListener struct {
 	// Write timeout. Can be set before calling Listen.
 	WriteTimeout time.Duration
 	// Message delimiter. Either \n or 0 (zero).
-	delim     byte
-	events    chan Event
-	done      chan struct{}
-	lastError error
-	closed    atomic.Bool
+	delim   byte
+	events  chan Event
+	done    chan struct{}
+	errMu   sync.Mutex
+	lastErr error
+	closed  atomic.Bool
 }
 
 // NewEventListener connects to HAProxy's master socket and returns a new
@@ -115,14 +118,29 @@ func (l *EventListener) Listen(ctx context.Context) (Event, error) {
 	select {
 	case event, ok := <-l.events:
 		if !ok {
-			return Event{}, l.lastError
+			if err := l.getLastError(); err != nil {
+				return Event{}, err
+			}
+			return Event{}, io.EOF
 		}
 		return event, nil
 	case <-ctx.Done():
 		return Event{}, l.Close()
 	}
 }
 
+func (l *EventListener) setLastError(err error) {
+	l.errMu.Lock()
+	l.lastErr = err
+	l.errMu.Unlock()
+}
+
+func (l *EventListener) getLastError() error {
+	l.errMu.Lock()
+	defer l.errMu.Unlock()
+	return l.lastErr
+}
+
 // Close the EventListener cleanly. The events channel will be closed
 // asynchronously by the internal listen goroutine after it exits.
 func (l *EventListener) Close() error {
@@ -147,22 +165,22 @@ func (l *EventListener) listen() {
 
 	_, err := fmt.Fprintf(l.conn, "@@1 set severity-output number;%s\n", l.listenCmd)
 	if err != nil {
-		l.lastError = l.errorf("%w", err)
+		l.setLastError(l.errorf("%w", err))
 		_ = l.Close()
 		return
 	}
 
 	for {
 		data, err := l.reader.ReadBytes(l.delim)
 		if err != nil {
-			l.lastError = l.errorf("%w", err)
+			l.setLastError(l.errorf("%w", err))
 			_ = l.Close()
 			return
 		}
 
 		event, err := l.parseEvent(data)
 		if err != nil {
-			l.lastError = err
+			l.setLastError(err)
 			_ = l.Close()
 			return
 		}