Merge remote-tracking branch 'origin/stable' into major-next

dktapps · dktapps · commit bc2e0c7026f5 · 2024-12-03T14:30:38.000Z
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
@@ -0,0 +1 @@
+* @pmmp/server-developers
diff --git a/src/generic/DisconnectReason.php b/src/generic/DisconnectReason.php
@@ -22,6 +22,10 @@ final class DisconnectReason{
 	public const PEER_TIMEOUT = 2;
 	public const CLIENT_RECONNECT = 3;
 	public const SERVER_SHUTDOWN = 4; //TODO: do we really need a separate reason for this in addition to SERVER_DISCONNECT?
+	public const SPLIT_PACKET_TOO_LARGE = 5;
+	public const SPLIT_PACKET_TOO_MANY_CONCURRENT = 6;
+	public const SPLIT_PACKET_INVALID_PART_INDEX = 7;
+	public const SPLIT_PACKET_INCONSISTENT_HEADER = 8;
 
 	public static function toString(int $reason) : string{
 		return match($reason){
@@ -30,6 +34,10 @@ public static function toString(int $reason) : string{
 			self::PEER_TIMEOUT => "timeout",
 			self::CLIENT_RECONNECT => "new session established on same address and port",
 			self::SERVER_SHUTDOWN => "server shutdown",
+			self::SPLIT_PACKET_TOO_LARGE => "received packet split into more parts than allowed",
+			self::SPLIT_PACKET_TOO_MANY_CONCURRENT => "too many received split packets being reassembled at once",
+			self::SPLIT_PACKET_INVALID_PART_INDEX => "invalid split packet part index",
+			self::SPLIT_PACKET_INCONSISTENT_HEADER => "received split packet header inconsistent with previous fragments",
 			default => "Unknown reason $reason"
 		};
 	}
diff --git a/src/generic/PacketHandlingException.php b/src/generic/PacketHandlingException.php
@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of RakLib.
+ * Copyright (C) 2014-2022 PocketMine Team <https://github.com/pmmp/RakLib>
+ *
+ * RakLib is not affiliated with Jenkins Software LLC nor RakNet.
+ *
+ * RakLib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+declare(strict_types=1);
+
+namespace raklib\generic;
+
+class PacketHandlingException extends \RuntimeException{
+
+	/** @phpstan-var DisconnectReason::* */
+	private int $disconnectReason;
+
+	/**
+	 * @phpstan-param DisconnectReason::* $disconnectReason
+	 */
+	public function __construct(string $message, int $disconnectReason, int $code = 0, ?\Throwable $previous = null){
+		$this->disconnectReason = $disconnectReason;
+		parent::__construct($message, $code, $previous);
+	}
+
+	/**
+	 * @phpstan-return DisconnectReason::*
+	 */
+	public function getDisconnectReason() : int{
+		return $this->disconnectReason;
+	}
+}
diff --git a/src/generic/ReceiveReliabilityLayer.php b/src/generic/ReceiveReliabilityLayer.php
@@ -84,33 +84,36 @@ private function handleEncapsulatedPacketRoute(EncapsulatedPacket $pk) : void{
 
 	/**
 	 * Processes a split part of an encapsulated packet.
+	 * If an error occurs (limit exceeded, inconsistent header, etc.) a PacketHandlingException is thrown.
+	 *
+	 * An error processing a split packet means we can't fulfill reliability promises, which at best would lead to some
+	 * packets not arriving, and in the worst case (reliable-ordered) cause no more packets to be processed.
+	 * Therefore, the owning session MUST disconnect the peer if this exception is thrown.
 	 *
 	 * @return null|EncapsulatedPacket Reassembled packet if we have all the parts, null otherwise.
+	 * @throws PacketHandlingException if there was a problem with processing the split packet.
 	 */
 	private function handleSplit(EncapsulatedPacket $packet) : ?EncapsulatedPacket{
 		if($packet->splitInfo === null){
 			return $packet;
 		}
 		$totalParts = $packet->splitInfo->getTotalPartCount();
 		$partIndex = $packet->splitInfo->getPartIndex();
-		if(
-			$totalParts >= $this->maxSplitPacketPartCount or $totalParts < 0 or
-			$partIndex >= $totalParts or $partIndex < 0
-		){
-			$this->logger->debug("Invalid split packet part, too many parts or invalid split index (part index $partIndex, part count $totalParts)");
-			return null;
+		if($totalParts >= $this->maxSplitPacketPartCount || $totalParts < 0){
+			throw new PacketHandlingException("Invalid split packet part count ($totalParts)", DisconnectReason::SPLIT_PACKET_TOO_LARGE);
+		}
+		if($partIndex >= $totalParts || $partIndex < 0){
+			throw new PacketHandlingException("Invalid split packet part index (part index $partIndex, part count $totalParts)", DisconnectReason::SPLIT_PACKET_INVALID_PART_INDEX);
 		}
 
 		$splitId = $packet->splitInfo->getId();
 		if(!isset($this->splitPackets[$splitId])){
 			if(count($this->splitPackets) >= $this->maxConcurrentSplitPackets){
-				$this->logger->debug("Ignored split packet part because reached concurrent split packet limit of $this->maxConcurrentSplitPackets");
-				return null;
+				throw new PacketHandlingException("Exceeded concurrent split packet reassembly limit of $this->maxConcurrentSplitPackets", DisconnectReason::SPLIT_PACKET_TOO_MANY_CONCURRENT);
 			}
 			$this->splitPackets[$splitId] = array_fill(0, $totalParts, null);
 		}elseif(count($this->splitPackets[$splitId]) !== $totalParts){
-			$this->logger->debug("Wrong split count $totalParts for split packet $splitId, expected " . count($this->splitPackets[$splitId]));
-			return null;
+			throw new PacketHandlingException("Wrong split count $totalParts for split packet $splitId, expected " . count($this->splitPackets[$splitId]), DisconnectReason::SPLIT_PACKET_INCONSISTENT_HEADER);
 		}
 
 		$this->splitPackets[$splitId][$partIndex] = $packet;
@@ -142,6 +145,9 @@ private function handleSplit(EncapsulatedPacket $packet) : ?EncapsulatedPacket{
 		return $pk;
 	}
 
+	/**
+	 * @throws PacketHandlingException
+	 */
 	private function handleEncapsulatedPacket(EncapsulatedPacket $packet) : void{
 		if($packet->messageIndex !== null){
 			//check for duplicates or out of range
@@ -209,6 +215,9 @@ private function handleEncapsulatedPacket(EncapsulatedPacket $packet) : void{
 		}
 	}
 
+	/**
+	 * @throws PacketHandlingException
+	 */
 	public function onDatagram(Datagram $packet) : void{
 		if($packet->seqNumber < $this->windowStart or $packet->seqNumber > $this->windowEnd or isset($this->ACKQueue[$packet->seqNumber])){
 			$this->logger->debug("Received duplicate or out-of-window packet (sequence number $packet->seqNumber, window " . $this->windowStart . "-" . $this->windowEnd . ")");
diff --git a/src/generic/SendReliabilityLayer.php b/src/generic/SendReliabilityLayer.php
@@ -23,14 +23,21 @@
 use raklib\protocol\PacketReliability;
 use raklib\protocol\SplitPacketInfo;
 use function array_fill;
+use function array_push;
+use function assert;
 use function count;
+use function microtime;
 use function str_split;
 use function strlen;
-use function time;
 
 final class SendReliabilityLayer{
 	private const DATAGRAM_MTU_OVERHEAD = 36 + Datagram::HEADER_SIZE; //IP header (20 bytes) + UDP header (8 bytes) + RakNet weird (8 bytes) = 36
 	private const MIN_POSSIBLE_PACKET_SIZE_LIMIT = Session::MIN_MTU_SIZE - self::DATAGRAM_MTU_OVERHEAD;
+	/**
+	 * Delay in seconds before an unacked packet is retransmitted.
+	 * TODO: Replace this with dynamic calculation based on roundtrip times (that's a complex task for another time)
+	 */
+	private const UNACKED_RETRANSMIT_DELAY = 2.0;
 
 	/** @var EncapsulatedPacket[] */
 	private array $sendQueue = [];
@@ -41,12 +48,23 @@ final class SendReliabilityLayer{
 
 	private int $messageIndex = 0;
 
+	private int $reliableWindowStart;
+	private int $reliableWindowEnd;
+	/**
+	 * @var bool[] message index => acked
+	 * @phpstan-var array<int, bool>
+	 */
+	private array $reliableWindow = [];
+
 	/** @var int[] */
 	private array $sendOrderedIndex;
 	/** @var int[] */
 	private array $sendSequencedIndex;
 
-	/** @var ReliableCacheEntry[] */
+	/** @var EncapsulatedPacket[] */
+	private array $reliableBacklog = [];
+
+	/** @var EncapsulatedPacket[] */
 	private array $resendQueue = [];
 
 	/** @var ReliableCacheEntry[] */
@@ -60,18 +78,22 @@ final class SendReliabilityLayer{
 
 	/**
 	 * @phpstan-param int<Session::MIN_MTU_SIZE, max> $mtuSize
-	 * @phpstan-param \Closure(Datagram) : void $sendDatagramCallback
-	 * @phpstan-param \Closure(int) : void      $onACK
+	 * @phpstan-param \Closure(Datagram) : void       $sendDatagramCallback
+	 * @phpstan-param \Closure(int) : void            $onACK
 	 */
 	public function __construct(
 		private int $mtuSize,
 		private \Closure $sendDatagramCallback,
-		private \Closure $onACK
+		private \Closure $onACK,
+		private int $reliableWindowSize = 512,
 	){
 		$this->sendOrderedIndex = array_fill(0, PacketReliability::MAX_ORDER_CHANNELS, 0);
 		$this->sendSequencedIndex = array_fill(0, PacketReliability::MAX_ORDER_CHANNELS, 0);
 
 		$this->maxDatagramPayloadSize = $this->mtuSize - self::DATAGRAM_MTU_OVERHEAD;
+
+		$this->reliableWindowStart = 0;
+		$this->reliableWindowEnd = $this->reliableWindowSize;
 	}
 
 	/**
@@ -102,6 +124,19 @@ public function sendQueue() : void{
 	}
 
 	private function addToQueue(EncapsulatedPacket $pk, bool $immediate) : void{
+		if(PacketReliability::isReliable($pk->reliability)){
+			if($pk->messageIndex === null || $pk->messageIndex < $this->reliableWindowStart){
+				throw new \InvalidArgumentException("Cannot send a reliable packet with message index less than the window start ($pk->messageIndex < $this->reliableWindowStart)");
+			}
+			if($pk->messageIndex >= $this->reliableWindowEnd){
+				//If we send this now, the client's reliable window may overflow, causing the packet to need redelivery
+				$this->reliableBacklog[$pk->messageIndex] = $pk;
+				return;
+			}
+
+			$this->reliableWindow[$pk->messageIndex] = false;
+		}
+
 		if($pk->identifierACK !== null and $pk->messageIndex !== null){
 			$this->needACK[$pk->identifierACK][$pk->messageIndex] = $pk->messageIndex;
 		}
@@ -152,6 +187,7 @@ public function addEncapsulatedToQueue(EncapsulatedPacket $packet, bool $immedia
 				$pk->splitInfo = new SplitPacketInfo($splitID, $count, $bufferCount);
 				$pk->reliability = $packet->reliability;
 				$pk->buffer = $buffer;
+				$pk->identifierACK = $packet->identifierACK;
 
 				if($pk->reliability->isReliable()){
 					$pk->messageIndex = $this->messageIndex++;
@@ -171,11 +207,26 @@ public function addEncapsulatedToQueue(EncapsulatedPacket $packet, bool $immedia
 		}
 	}
 
+	private function updateReliableWindow() : void{
+		while(
+			isset($this->reliableWindow[$this->reliableWindowStart]) && //this messageIndex has been used
+			$this->reliableWindow[$this->reliableWindowStart] === true //we received an ack for this messageIndex
+		){
+			unset($this->reliableWindow[$this->reliableWindowStart]);
+			$this->reliableWindowStart++;
+			$this->reliableWindowEnd++;
+		}
+	}
+
 	public function onACK(ACK $packet) : void{
 		foreach($packet->packets as $seq){
 			if(isset($this->reliableCache[$seq])){
 				foreach($this->reliableCache[$seq]->getPackets() as $pk){
-					if($pk->identifierACK !== null and $pk->messageIndex !== null){
+					assert($pk->messageIndex !== null && $pk->messageIndex >= $this->reliableWindowStart && $pk->messageIndex < $this->reliableWindowEnd);
+					$this->reliableWindow[$pk->messageIndex] = true;
+					$this->updateReliableWindow();
+
+					if($pk->identifierACK !== null){
 						unset($this->needACK[$pk->identifierACK][$pk->messageIndex]);
 						if(count($this->needACK[$pk->identifierACK]) === 0){
 							unset($this->needACK[$pk->identifierACK]);
@@ -191,8 +242,9 @@ public function onACK(ACK $packet) : void{
 	public function onNACK(NACK $packet) : void{
 		foreach($packet->packets as $seq){
 			if(isset($this->reliableCache[$seq])){
-				//TODO: group resends if the resulting datagram is below the MTU
-				$this->resendQueue[] = $this->reliableCache[$seq];
+				foreach($this->reliableCache[$seq]->getPackets() as $pk){
+					$this->resendQueue[] = $pk;
+				}
 				unset($this->reliableCache[$seq]);
 			}
 		}
@@ -201,34 +253,42 @@ public function onNACK(NACK $packet) : void{
 	public function needsUpdate() : bool{
 		return (
 			count($this->sendQueue) !== 0 or
+			count($this->reliableBacklog) !== 0 or
 			count($this->resendQueue) !== 0 or
 			count($this->reliableCache) !== 0
 		);
 	}
 
 	public function update() : void{
-		if(count($this->resendQueue) > 0){
-			$limit = 16;
-			foreach($this->resendQueue as $k => $pk){
-				$this->sendDatagram($pk->getPackets());
-				unset($this->resendQueue[$k]);
-
-				if(--$limit <= 0){
-					break;
-				}
+		$retransmitOlderThan = microtime(true) - self::UNACKED_RETRANSMIT_DELAY;
+		foreach($this->reliableCache as $seq => $pk){
+			if($pk->getTimestamp() < $retransmitOlderThan){
+				//behave as if a NACK was received
+				array_push($this->resendQueue, ...$pk->getPackets());
+				unset($this->reliableCache[$seq]);
+			}else{
+				break;
 			}
+		}
 
-			if(count($this->resendQueue) > ReceiveReliabilityLayer::$WINDOW_SIZE){
-				$this->resendQueue = [];
+		if(count($this->resendQueue) > 0){
+			foreach($this->resendQueue as $pk){
+				//resends should always be within the reliable window
+				$this->addToQueue($pk, false);
 			}
+			$this->resendQueue = [];
 		}
 
-		foreach($this->reliableCache as $seq => $pk){
-			if($pk->getTimestamp() < (time() - 8)){
-				$this->resendQueue[] = $pk;
-				unset($this->reliableCache[$seq]);
-			}else{
-				break;
+		if(count($this->reliableBacklog) > 0){
+			foreach($this->reliableBacklog as $k => $pk){
+				assert($pk->messageIndex !== null && $pk->messageIndex >= $this->reliableWindowStart);
+				if($pk->messageIndex >= $this->reliableWindowEnd){
+					//we can't send this packet yet, the client's reliable window will drop it
+					break;
+				}
+
+				$this->addToQueue($pk, false);
+				unset($this->reliableBacklog[$k]);
 			}
 		}
 
diff --git a/src/generic/Session.php b/src/generic/Session.php
@@ -155,6 +155,10 @@ protected function getRakNetTimeMS() : int{
 		return intdiv(hrtime(true), 1_000_000);
 	}
 
+	public function getLogger() : \Logger{
+		return $this->logger;
+	}
+
 	public function getAddress() : InternetAddress{
 		return $this->address;
 	}
@@ -275,6 +279,9 @@ private function handlePong(int $sendPingTime, int $sendPongTime) : void{
 		}
 	}
 
+	/**
+	 * @throws PacketHandlingException
+	 */
 	public function handlePacket(Packet $packet) : void{
 		$this->isActive = true;
 		$this->lastUpdate = microtime(true);
diff --git a/src/server/Server.php b/src/server/Server.php
@@ -20,6 +20,7 @@
 use raklib\generic\DisconnectReason;
 use raklib\generic\Session;
 use raklib\generic\SocketException;
+use raklib\generic\PacketHandlingException;
 use raklib\protocol\ACK;
 use raklib\protocol\Datagram;
 use raklib\protocol\EncapsulatedPacket;
@@ -247,7 +248,12 @@ private function receivePacket() : bool{
 						$packet = new Datagram();
 					}
 					$packet->decode(new PacketSerializer($buffer));
-					$session->handlePacket($packet);
+					try{
+						$session->handlePacket($packet);
+					}catch(PacketHandlingException $e){
+						$session->getLogger()->error("Error receiving packet: " . $e->getMessage());
+						$session->forciblyDisconnect($e->getDisconnectReason());
+					}
 					return true;
 				}elseif($session->isConnected()){
 					//allows unconnected packets if the session is stuck in DISCONNECTING state, useful if the client

Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,10 @@ protected function getRakNetTimeMS() : int{`
`155`	`155`	`return intdiv(hrtime(true), 1_000_000);`
`156`	`156`	`}`
`157`	`157`
	`158`	`+ public function getLogger() : \Logger{`
	`159`	`+ return $this->logger;`
	`160`	`+ }`
	`161`	`+`
`158`	`162`	`public function getAddress() : InternetAddress{`
`159`	`163`	`return $this->address;`
`160`	`164`	`}`
`@@ -275,6 +279,9 @@ private function handlePong(int $sendPingTime, int $sendPongTime) : void{`
`275`	`279`	`}`
`276`	`280`	`}`
`277`	`281`
	`282`	`+ /**`
	`283`	`+ * @throws PacketHandlingException`
	`284`	`+ */`
`278`	`285`	`public function handlePacket(Packet $packet) : void{`
`279`	`286`	`$this->isActive = true;`
`280`	`287`	`$this->lastUpdate = microtime(true);`