Session Class Reference

Public Member Functions
	__construct (SessionManager $sessionManager, $address, $port)
	getAddress ()
	getPort ()
	getID ()
	update ($time)
	disconnect ($reason="unknown")
	sendQueue ()
	addEncapsulatedToQueue (EncapsulatedPacket $packet, $flags=RakLib::PRIORITY_NORMAL)
	getState ()
	isTemporal ()
	handlePacket (Packet $packet)
	close ()

Data Fields
const	STATE_UNCONNECTED = 0
const	STATE_CONNECTING_1 = 1
const	STATE_CONNECTING_2 = 2
const	STATE_CONNECTED = 3
const	MAX_SPLIT_SIZE = 128
const	MAX_SPLIT_COUNT = 4

Static Public Attributes
static	$WINDOW_SIZE = 2048

Constructor & Destructor Documentation

__construct()

__construct	(	SessionManager	$sessionManager,
			$address,
			$port
	)

                                                                                {
        $this->sessionManager = $sessionManager;
        $this->address = $address;
        $this->port = $port;
        $this->sendQueue = new DATA_PACKET_4();
        $this->lastUpdate = microtime(true);
        $this->startTime = microtime(true);
        $this->isActive = false;
        $this->windowStart = -1;
        $this->windowEnd = self::$WINDOW_SIZE;

        $this->reliableWindowStart = 0;
        $this->reliableWindowEnd = self::$WINDOW_SIZE;

        for($i = 0; $i < 32; ++$i){
            $this->channelIndex[$i] = 0;
        }
    }

Member Function Documentation

addEncapsulatedToQueue()

addEncapsulatedToQueue	(	EncapsulatedPacket	$packet,
			$flags = RakLib::PRIORITY_NORMAL
	)

Parameters

EncapsulatedPacket	$packet
int	$flags

                                                                                                      {

        if(($packet->needACK = ($flags & RakLib::FLAG_NEED_ACK) > 0) === true){
            $this->needACK[$packet->identifierACK] = [];
        }

        if(
            $packet->reliability === PacketReliability::RELIABLE or
            $packet->reliability === PacketReliability::RELIABLE_ORDERED or
            $packet->reliability === PacketReliability::RELIABLE_SEQUENCED or
            $packet->reliability === PacketReliability::RELIABLE_WITH_ACK_RECEIPT or
            $packet->reliability === PacketReliability::RELIABLE_ORDERED_WITH_ACK_RECEIPT
        ){
            $packet->messageIndex = $this->messageIndex++;

            if($packet->reliability === PacketReliability::RELIABLE_ORDERED){
                $packet->orderIndex = $this->channelIndex[$packet->orderChannel]++;
            }
        }

        if($packet->getTotalLength() + 4 > $this->mtuSize){
            $buffers = str_split($packet->buffer, $this->mtuSize - 34);
            $splitID = ++$this->splitID % 65536;
            foreach($buffers as $count => $buffer){
                $pk = new EncapsulatedPacket();
                $pk->splitID = $splitID;
                $pk->hasSplit = true;
                $pk->splitCount = count($buffers);
                $pk->reliability = $packet->reliability;
                $pk->splitIndex = $count;
                $pk->buffer = $buffer;
                if($count > 0){
                    $pk->messageIndex = $this->messageIndex++;
                }else{
                    $pk->messageIndex = $packet->messageIndex;
                }
                if($pk->reliability === PacketReliability::RELIABLE_ORDERED){
                    $pk->orderChannel = $packet->orderChannel;
                    $pk->orderIndex = $packet->orderIndex;
                }
                $this->addToQueue($pk, $flags | RakLib::PRIORITY_IMMEDIATE);
            }
        }else{
            $this->addToQueue($packet, $flags);
        }
    }

close()

close

(

)

                           {
        $data = "\x60\x00\x08\x00\x00\x00\x00\x00\x00\x00\x15";
        $this->addEncapsulatedToQueue(EncapsulatedPacket::fromBinary($data)); //CLIENT_DISCONNECT packet 0x15
        $this->sessionManager = null;
    }

disconnect()

disconnect

(

$reason = "unknown"

)

                                                   {
        $this->sessionManager->removeSession($this, $reason);
    }

getAddress()

getAddress

(

)

                                {
        return $this->address;
    }

getID()

getID

(

)

                           {
        return $this->id;
    }

getPort()

getPort

(

)

                             {
        return $this->port;
    }

getState()

getState

(

)

                              {
        return $this->state;
    }

handlePacket()

handlePacket

(

Packet

$packet

)

                                                {
        $this->isActive = true;
        $this->lastUpdate = microtime(true);
        if($this->state === self::STATE_CONNECTED or $this->state === self::STATE_CONNECTING_2){
            if($packet::$ID >= 0x80 and $packet::$ID <= 0x8f and $packet instanceof DataPacket){ //Data packet
                $packet->decode();

                if($packet->seqNumber < $this->windowStart or $packet->seqNumber > $this->windowEnd or isset($this->receivedWindow[$packet->seqNumber])){
                    return;
                }

                $diff = $packet->seqNumber - $this->lastSeqNumber;

                unset($this->NACKQueue[$packet->seqNumber]);
                $this->ACKQueue[$packet->seqNumber] = $packet->seqNumber;
                $this->receivedWindow[$packet->seqNumber] = $packet->seqNumber;

                if($diff !== 1){
                    for($i = $this->lastSeqNumber + 1; $i < $packet->seqNumber; ++$i){
                        if(!isset($this->receivedWindow[$i])){
                            $this->NACKQueue[$i] = $i;
                        }
                    }
                }

                if($diff >= 1){
                    $this->lastSeqNumber = $packet->seqNumber;
                    $this->windowStart += $diff;
                    $this->windowEnd += $diff;
                }

                foreach($packet->packets as $pk){
                    $this->handleEncapsulatedPacket($pk);
                }
            }else{
                if($packet instanceof ACK){
                    $packet->decode();
                    foreach($packet->packets as $seq){
                        if(isset($this->recoveryQueue[$seq])){
                            foreach($this->recoveryQueue[$seq]->packets as $pk){
                                if($pk instanceof EncapsulatedPacket and $pk->needACK and $pk->messageIndex !== null){
                                    unset($this->needACK[$pk->identifierACK][$pk->messageIndex]);
                                }
                            }
                            unset($this->recoveryQueue[$seq]);
                        }
                    }
                }elseif($packet instanceof NACK){
                    $packet->decode();
                    foreach($packet->packets as $seq){
                        if(isset($this->recoveryQueue[$seq])){
                            $pk = $this->recoveryQueue[$seq];
                            $pk->seqNumber = $this->sendSeqNumber++;
                            $this->packetToSend[] = $pk;
                            unset($this->recoveryQueue[$seq]);
                        }
                    }
                }
            }

        }elseif($packet::$ID > 0x00 and $packet::$ID < 0x80){ //Not Data packet :)
            $packet->decode();
            if($packet instanceof OPEN_CONNECTION_REQUEST_1){
                $packet->protocol; //TODO: check protocol number and refuse connections
                $pk = new OPEN_CONNECTION_REPLY_1();
                $pk->mtuSize = $packet->mtuSize;
                $pk->serverID = $this->sessionManager->getID();
                $this->sendPacket($pk);
                $this->state = self::STATE_CONNECTING_1;
            }elseif($this->state === self::STATE_CONNECTING_1 and $packet instanceof OPEN_CONNECTION_REQUEST_2){
                $this->id = $packet->clientID;
                if($packet->serverPort === $this->sessionManager->getPort() or !$this->sessionManager->portChecking){
                    $this->mtuSize = min(abs($packet->mtuSize), 1464); //Max size, do not allow creating large buffers to fill server memory
                    $pk = new OPEN_CONNECTION_REPLY_2();
                    $pk->mtuSize = $this->mtuSize;
                    $pk->serverID = $this->sessionManager->getID();
                    $pk->clientAddress = $this->address;
                    $pk->clientPort = $this->port;
                    $this->sendPacket($pk);
                    $this->state = self::STATE_CONNECTING_2;
                }
            }
        }
    }

isTemporal()

isTemporal

(

)

                                {
        return $this->isTemporal;
    }

sendQueue()

sendQueue

(

)

                               {
        if(count($this->sendQueue->packets) > 0){
            $this->sendQueue->seqNumber = $this->sendSeqNumber++;
            $this->sendPacket($this->sendQueue);
            $this->sendQueue->sendTime = microtime(true);
            $this->recoveryQueue[$this->sendQueue->seqNumber] = $this->sendQueue;
            $this->sendQueue = new DATA_PACKET_4();
        }
    }

update()

update

(

$time

)

                                 {
        if(!$this->isActive and ($this->lastUpdate + 10) < $time){
            $this->disconnect("timeout");

            return;
        }
        $this->isActive = false;

        if(count($this->ACKQueue) > 0){
            $pk = new ACK();
            $pk->packets = $this->ACKQueue;
            $this->sendPacket($pk);
            $this->ACKQueue = [];
        }

        if(count($this->NACKQueue) > 0){
            $pk = new NACK();
            $pk->packets = $this->NACKQueue;
            $this->sendPacket($pk);
            $this->NACKQueue = [];
        }

        if(count($this->packetToSend) > 0){
            $limit = 16;
            foreach($this->packetToSend as $k => $pk){
                $pk->sendTime = $time;
                $pk->encode();
                $this->recoveryQueue[$pk->seqNumber] = $pk;
                unset($this->packetToSend[$k]);
                $this->sendPacket($pk);

                if(--$limit <= 0){
                    break;
                }
            }

            if(count($this->packetToSend) > self::$WINDOW_SIZE){
                $this->packetToSend = [];
            }
        }

        if(count($this->needACK) > 0){
            foreach($this->needACK as $identifierACK => $indexes){
                if(count($indexes) === 0){
                    unset($this->needACK[$identifierACK]);
                    $this->sessionManager->notifyACK($this, $identifierACK);
                }
            }
        }


        foreach($this->recoveryQueue as $seq => $pk){
            if($pk->sendTime < (time() - 8)){
                $this->packetToSend[] = $pk;
                unset($this->recoveryQueue[$seq]);
            }else{
                break;
            }
        }

        foreach($this->receivedWindow as $seq => $bool){
            if($seq < $this->windowStart){
                unset($this->receivedWindow[$seq]);
            }else{
                break;
            }
        }

        $this->sendQueue();
    }

Field Documentation

$WINDOW_SIZE

$WINDOW_SIZE = 2048

static

MAX_SPLIT_COUNT

const MAX_SPLIT_COUNT = 4

MAX_SPLIT_SIZE

const MAX_SPLIT_SIZE = 128

STATE_CONNECTED

const STATE_CONNECTED = 3

STATE_CONNECTING_1

const STATE_CONNECTING_1 = 1

STATE_CONNECTING_2

const STATE_CONNECTING_2 = 2

STATE_UNCONNECTED

const STATE_UNCONNECTED = 0

---

The documentation for this class was generated from the following file:

• src/raklib/server/Session.php