Rebase & make chunked RLPx messages optional by a compiler flag

why:
  This is a legacy feature and its usage should peter out over time.

details:
  Use -d:chunked_rlpx_enabled for enabling chunked RLPx message handling.

eth/p2p/rlpx.nim

@@ -13,6 +13,17 @@ import
   ".."/[rlp, common, keys, async_utils],
   ./private/p2p_types, "."/[kademlia, auth, rlpxcrypt, enode, p2p_protocol_dsl]
 
+const
+  # Insane kludge for suppporting chunked messages when syncing against clients
+  # like Nethermind.
+  #
+  # The original specs which are now obsoleted can be found here:
+  # github.com/ethereum/devp2p/commit/6504d410bc4b8dda2b43941e1cb48c804b90cf22.
+  #
+  # The current requirement is stated at
+  # github.com/ethereum/devp2p/blob/master/rlpx.md#framing
+  allowObsoletedChunkedMessages = defined(chunked_rlpx_enabled)
+
 when useSnappy:
   import snappy
   const devp2pSnappyVersion* = 5
@@ -455,8 +466,8 @@ proc resolveResponseFuture(peer: Peer, msgId: int, msg: pointer, reqId: int) =
 
 proc getRlpxHeaderData(header: RlpxHeader): (int,int,int) =
   ## Helper for `recvMsg()`
-  # This is insane. Some clients like Nethermid use the now obsoleted
-  # chunked frame protocol, see
+  # This is insane. Some clients like Nethermind use the now obsoleted
+  # chunked message frame protocol, see
   # github.com/ethereum/devp2p/commit/6504d410bc4b8dda2b43941e1cb48c804b90cf22.
   result = (-1, -1, 0)
   proc datagramSize: int =
@@ -535,6 +546,22 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
       if decryptedBytes.len == 0:
         await peer.disconnectAndRaise(BreachOfProtocol,
                                       "Snappy uncompress encountered malformed data")
+
+  # Check embedded header-data for start of an obsoleted chunked message.
+  #
+  # The current RLPx requirements need all triple entries <= 0, see
+  # github.com/ethereum/devp2p/blob/master/rlpx.md#framing
+  let (capaId, ctxId, totalMsgSize) = msgHeader.getRlpxHeaderData
+
+  when not allowObsoletedChunkedMessages:
+    # Note that the check should come *before* the `msgId` is read. For
+    # instance, if this is a malformed packet, then the `msgId` might be
+    # random which in turn might try to access a `peer.dispatcher.messages[]`
+    # slot with a `nil` entry.
+    if 0 < capaId or 0 < ctxId or 0 < totalMsgSize:
+      await peer.disconnectAndRaise(
+        BreachOfProtocol, "Rejected obsoleted chunked message header")
+
   var rlp = rlpFromBytes(decryptedBytes)
 
   var msgId: int32
@@ -546,14 +573,13 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
     await peer.disconnectAndRaise(BreachOfProtocol,
                                   "Cannot read RLPx message id")
 
+  # Handle chunked messages
+  when allowObsoletedChunkedMessages:
     # Snappy with obsolete chunked RLPx message datagrams is unsupported here
     when useSnappy:
       if peer.snappyEnabled:
         return
 
-  # Check embedded header-data for start of a chunked message
-  let (capaId, ctxId, totalMsgSize) = msgHeader.getRlpxHeaderData
-
     # This also covers totalMessageSize <= 0
     if totalMsgSize <= msgSize:
       return
@@ -569,8 +595,8 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
                                       headerBytes, msgSize, msgHeader).isErr():
           trace "RLPx next chunked header-data failed",
             peer, msgId, ctxId, maxSize = moreData
-        await peer.disconnectAndRaise(BreachOfProtocol,
-                                      "Cannot decrypt next chunked RLPx header")
+          await peer.disconnectAndRaise(
+            BreachOfProtocol, "Cannot decrypt next chunked RLPx header")
 
       # Verify that this is really the next chunk
       block:
@@ -578,8 +604,8 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
         if ctyId != ctxId or 0 < totalSize:
           trace "Malformed RLPx next chunked header-data",
             peer, msgId, msgSize, ctxtId = ctyId, expCtxId = ctxId, totalSize
-        await peer.disconnectAndRaise(BreachOfProtocol,
-                                      "Malformed next chunked RLPx header")
+          await peer.disconnectAndRaise(
+            BreachOfProtocol, "Malformed next chunked RLPx header")
 
       # Append payload to `decryptedBytes` collector
       block:
@@ -592,8 +618,8 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
         # `decryptedBytes` where to append the data.
         if decryptBody(peer.secretsState, encBytes, msgSize,
                        dcrBytes, dcrBytesCount).isErr():
-        await peer.disconnectAndRaise(BreachOfProtocol,
-                                  "Cannot decrypt next chunked RLPx frame body")
+          await peer.disconnectAndRaise(
+            BreachOfProtocol, "Cannot decrypt next chunked RLPx frame body")
         decryptedBytes.add dcrBytes[0 ..< dcrBytesCount]
         moreData -= msgSize
         #[
@@ -605,8 +631,8 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
       # End While
 
     if moreData != 0:
-    await peer.disconnectAndRaise(BreachOfProtocol,
-                                  "Malformed assembly of chunked RLPx message")
+      await peer.disconnectAndRaise(
+        BreachOfProtocol, "Malformed assembly of chunked RLPx message")
 
     # Pass back extended message (first entry remains `msgId`)
     result[1] = decryptedBytes.rlpFromBytes
@@ -615,6 +641,8 @@ proc recvMsg*(peer: Peer): Future[tuple[msgId: int, msgData: Rlp]] {.async.} =
     trace "RLPx chunked datagram payload",
       peer, msgId, ctxId, totalMsgSize, moreData, payload = decryptedBytes.len
 
+    # End `allowObsoletedChunkedMessages`
+
 
 proc checkedRlpRead(peer: Peer, r: var Rlp, MsgType: type):
     auto {.raises: [RlpError, Defect].} =