fix(net): correct sync completion and chain summary request timeouts

framework/src/main/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandler.java

@@ -10,6 +10,7 @@
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.tron.common.utils.Pair;
 import org.tron.core.capsule.BlockCapsule.BlockId;
 import org.tron.core.config.Parameter.ChainConstant;
 import org.tron.core.config.Parameter.NetConstants;
@@ -40,7 +41,8 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep
 
     ChainInventoryMessage chainInventoryMessage = (ChainInventoryMessage) msg;
 
-    check(peer, chainInventoryMessage);
+    Pair<Deque<BlockId>, Long> requested = peer.getSyncChainRequested();
+    check(requested, chainInventoryMessage);
 
     peer.setFetchAble(false);
 
@@ -51,7 +53,11 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep
     Deque<BlockId> blockIdWeGet = new LinkedList<>(chainInventoryMessage.getBlockIds());
 
     if (blockIdWeGet.size() == 1 && tronNetDelegate.containBlock(blockIdWeGet.peek())) {
+      peer.setRemainNum(0);
       peer.setTronState(TronState.SYNC_COMPLETED);
+      // This trusts the peer's claim that no blocks remain. A peer can echo an earlier
+      // known summary block while withholding newer blocks, so ending this download
+      // does not prove that we have caught up with the peer's actual chain. todo fix
       peer.setNeedSyncFromPeer(false);
       return;
     }
@@ -98,8 +104,9 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep
     }
   }
 
-  private void check(PeerConnection peer, ChainInventoryMessage msg) throws P2pException {
-    if (peer.getSyncChainRequested() == null) {
+  private void check(Pair<Deque<BlockId>, Long> requested, ChainInventoryMessage msg)
+      throws P2pException {
+    if (requested == null) {
       throw new P2pException(TypeEnum.BAD_MESSAGE, "not send syncBlockChainMsg");
     }
 
@@ -112,7 +119,8 @@ private void check(PeerConnection peer, ChainInventoryMessage msg) throws P2pExc
       throw new P2pException(TypeEnum.BAD_MESSAGE, "big blockIds size: " + blockIds.size());
     }
 
-    if (msg.getRemainNum() != 0 && blockIds.size() < NetConstants.SYNC_FETCH_BATCH_NUM) {
+    if (msg.getRemainNum() < 0
+        || (msg.getRemainNum() != 0 && blockIds.size() < NetConstants.SYNC_FETCH_BATCH_NUM)) {
       throw new P2pException(TypeEnum.BAD_MESSAGE,
           "remain: " + msg.getRemainNum() + ", blockIds size: " + blockIds.size());
     }
@@ -124,9 +132,9 @@ private void check(PeerConnection peer, ChainInventoryMessage msg) throws P2pExc
       }
     }
 
-    if (!peer.getSyncChainRequested().getKey().contains(blockIds.get(0))) {
+    if (!requested.getKey().contains(blockIds.get(0))) {
       throw new P2pException(TypeEnum.BAD_MESSAGE, "unlinked block, my head: "
-          + peer.getSyncChainRequested().getKey().getLast().getString()
+          + requested.getKey().getLast().getString()
           + ", peer: " + blockIds.get(0).getString());
     }
 
@@ -137,7 +145,7 @@ private void check(PeerConnection peer, ChainInventoryMessage msg) throws P2pExc
       long maxFutureNum =
           maxRemainTime / BLOCK_PRODUCED_INTERVAL + tronNetDelegate.getSolidBlockId().getNum();
       long lastNum = blockIds.get(blockIds.size() - 1).getNum();
-      if (lastNum + msg.getRemainNum() > maxFutureNum) {
+      if (lastNum > maxFutureNum || msg.getRemainNum() > maxFutureNum - lastNum) {
         throw new P2pException(TypeEnum.BAD_MESSAGE, "lastNum: " + lastNum + " + remainNum: "
             + msg.getRemainNum() + " > futureMaxNum: " + maxFutureNum);
       }

framework/src/main/java/org/tron/core/net/peer/PeerStatusCheck.java

@@ -1,11 +1,14 @@
 package org.tron.core.net.peer;
 
+import java.util.Deque;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.tron.common.es.ExecutorServiceManager;
+import org.tron.common.utils.Pair;
+import org.tron.core.capsule.BlockCapsule.BlockId;
 import org.tron.core.config.Parameter.NetConstants;
 import org.tron.core.net.TronNetDelegate;
 import org.tron.protos.Protocol.ReasonCode;
@@ -64,6 +67,15 @@ public void statusCheck() {
         }
       }
 
+      if (!isDisconnected) {
+        Pair<Deque<BlockId>, Long> requested = peer.getSyncChainRequested();
+        isDisconnected = requested != null
+            && requested.getValue() < now - NetConstants.SYNC_TIME_OUT;
+        if (isDisconnected) {
+          logger.warn("Peer {} get chain inventory timeout", peer.getInetAddress());
+        }
+      }
+
       if (!isDisconnected) {
         isDisconnected = peer.getSyncBlockRequested().values().stream()
             .anyMatch(time -> time < now - NetConstants.SYNC_TIME_OUT);

framework/src/test/java/org/tron/core/net/PeerSyncTestSupport.java

@@ -0,0 +1,36 @@
+package org.tron.core.net;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.net.InetSocketAddress;
+import org.tron.common.utils.ReflectUtils;
+import org.tron.common.utils.Sha256Hash;
+import org.tron.core.capsule.BlockCapsule.BlockId;
+import org.tron.core.net.peer.PeerConnection;
+import org.tron.p2p.connection.Channel;
+
+public final class PeerSyncTestSupport {
+
+  private PeerSyncTestSupport() {
+  }
+
+  public static BlockId blockId(long number) {
+    return new BlockId(Sha256Hash.ZERO_HASH, number);
+  }
+
+  public static PeerConnection peer(int port) {
+    PeerConnection peer = spy(new PeerConnection());
+    Channel channel = mock(Channel.class);
+    InetSocketAddress address = new InetSocketAddress("127.0.0.1", port);
+    when(channel.getInetSocketAddress()).thenReturn(address);
+    when(channel.getInetAddress()).thenReturn(address.getAddress());
+    ReflectUtils.setFieldValue(peer, "channel", channel);
+    doNothing().when(peer).sendMessage(any());
+    doNothing().when(peer).disconnect(any());
+    return peer;
+  }
+}