lnwire+peer: ignore no-reply pings

Allow pings in the BOLT 1 no-reply range to decode and be ignored
instead of disconnecting peers. This keeps reconnects compatible with
peers that pad channel_reestablish with no-reply pings.

Author: yyforyongyu

lnwire/ping.go

@@ -47,10 +47,8 @@ func (p *Ping) Decode(r io.Reader, pver uint32) error {
 		return err
 	}
 
-	if p.NumPongBytes > MaxPongBytes {
-		return ErrMaxPongBytesExceeded
-	}
-
+	// Values above MaxPongBytes are still valid on the wire. Per BOLT 1,
+	// receivers must ignore those pings rather than fail deserialization.
 	return nil
 }
 

lnwire/ping_test.go

@@ -0,0 +1,51 @@
+package lnwire
+
+import (
+	"bytes"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestPingDecodeAllowsNoReplyPongSizes asserts that ping messages using the
+// BOLT 1 no-reply sentinel range still deserialize successfully.
+func TestPingDecodeAllowsNoReplyPongSizes(t *testing.T) {
+	t.Parallel()
+
+	// Arrange: Pick values from the BOLT 1 no-reply range. These
+	// pings are valid on the wire and should decode successfully
+	// even though they do not require a pong response.
+	testCases := []uint16{65532, 65535}
+
+	for _, numPongBytes := range testCases {
+		numPongBytes := numPongBytes
+		testName := strconv.FormatUint(uint64(numPongBytes), 10)
+
+		t.Run(testName, func(t *testing.T) {
+			// Arrange: Encode a ping carrying a no-reply pong
+			// size together with a small payload so we exercise
+			// the normal wire format.
+			var buf bytes.Buffer
+
+			want := &Ping{
+				NumPongBytes: numPongBytes,
+				PaddingBytes: PingPayload{1, 2, 3},
+			}
+
+			_, err := WriteMessage(&buf, want, 0)
+			require.NoError(t, err)
+
+			// Act: Decode the serialized message through the
+			// standard parser.
+			msg, err := ReadMessage(bytes.NewReader(buf.Bytes()), 0)
+			require.NoError(t, err)
+
+			// Assert: The decoded ping matches the original
+			// input exactly.
+			got, ok := msg.(*Ping)
+			require.True(t, ok)
+			require.Equal(t, want, got)
+		})
+	}
+}

peer/brontide.go

@@ -2220,6 +2220,13 @@ out:
 			// the relevant atomic variable.
 			p.lastPingPayload.Store(msg.PaddingBytes[:])
 
+			// BOLT 1 requires us to ignore pings requesting 65532
+			// or more pong bytes instead of replying or
+			// disconnecting.
+			if msg.NumPongBytes > lnwire.MaxPongBytes {
+				continue
+			}
+
 			// Next, we'll send over the amount of specified pong
 			// bytes.
 			pong := lnwire.NewPong(p.cfg.PongBuf[0:msg.NumPongBytes])

peer/brontide_test.go

@@ -1073,6 +1073,76 @@ func TestPeerCustomMessage(t *testing.T) {
 	require.Equal(t, receivedCustomMsg, &receivedCustom.msg)
 }
 
+// TestPeerIgnoresPingWithoutPongReply ensures we keep the connection alive for
+// pings using the BOLT 1 no-reply sentinel range.
+func TestPeerIgnoresPingWithoutPongReply(t *testing.T) {
+	t.Parallel()
+
+	// Arrange: Start a peer using the mock connection so we can
+	// inject incoming pings and observe any outgoing responses.
+	params := createTestPeer(t)
+
+	var (
+		mockConn  = params.mockConn
+		alicePeer = params.peer
+	)
+
+	startPeerDone := startPeer(t, mockConn, alicePeer)
+	_, err := fn.RecvOrTimeout(startPeerDone, 2*timeout)
+	require.NoError(t, err)
+
+	writePing := func(msg *lnwire.Ping) {
+		t.Helper()
+
+		var b bytes.Buffer
+		_, err := lnwire.WriteMessage(&b, msg, 0)
+		require.NoError(t, err)
+
+		select {
+		case mockConn.readMessages <- b.Bytes():
+		case <-time.After(timeout):
+			t.Fatal("timeout sending ping to peer")
+		}
+	}
+
+	// Act: Deliver a ping in the BOLT 1 no-reply range.
+	ignoredPayload := []byte{1, 2, 3}
+	writePing(&lnwire.Ping{
+		NumPongBytes: 65535,
+		PaddingBytes: ignoredPayload,
+	})
+
+	// Assert: The peer records the latest ping payload for observability.
+	require.Eventually(t, func() bool {
+		return bytes.Equal(
+			alicePeer.LastRemotePingPayload(), ignoredPayload,
+		)
+	}, timeout, 10*time.Millisecond)
+
+	// Assert: No pong is sent for the no-reply sentinel range.
+	select {
+	case rawMsg := <-mockConn.writtenMessages:
+		t.Fatalf("expected no pong reply, got %x", rawMsg)
+	case <-time.After(100 * time.Millisecond):
+	}
+
+	// Act: Send a normal ping afterward to prove the peer
+	// stayed connected and still handles standard ping/pong
+	// traffic.
+	writePing(&lnwire.Ping{NumPongBytes: 1})
+
+	rawMsg, err := fn.RecvOrTimeout(mockConn.writtenMessages, timeout)
+	require.NoError(t, err)
+
+	msg, err := lnwire.ReadMessage(bytes.NewReader(rawMsg), 0)
+	require.NoError(t, err)
+
+	// Assert: The follow-up ping receives the requested pong reply.
+	pong, ok := msg.(*lnwire.Pong)
+	require.True(t, ok)
+	require.Len(t, pong.PongBytes, 1)
+}
+
 // TestUpdateNextRevocation checks that the method `updateNextRevocation` is
 // behave as expected.
 func TestUpdateNextRevocation(t *testing.T) {