GenisysPro  for Minecraft PE/Windows 10 v1.1.x
Feature-rich server software for Minecraft PE and Windows 10 Edition
Public Member Functions | Data Fields | Protected Member Functions | Protected Attributes
SessionManager Class Reference

Public Member Functions

 __construct (RakLibServer $server, UDPServerSocket $socket)
 
 getPort ()
 
 getLogger ()
 
 run ()
 
 sendPacket (Packet $packet, $dest, $port)
 
 streamEncapsulated (Session $session, EncapsulatedPacket $packet, $flags=RakLib::PRIORITY_NORMAL)
 
 streamRaw ($address, $port, $payload)
 
 receiveStream ()
 
 blockAddress ($address, $timeout=300)
 
 unblockAddress ($address)
 
 getSession ($ip, $port)
 
 removeSession (Session $session, $reason="unknown")
 
 openSession (Session $session)
 
 notifyACK (Session $session, $identifierACK)
 
 getName ()
 
 getID ()
 
 getPacketFromPool ($id)
 

Data Fields

 $portChecking = true
 

Protected Member Functions

 streamClose ($identifier, $reason)
 
 streamInvalid ($identifier)
 
 streamOpen (Session $session)
 
 streamACK ($identifier, $identifierACK)
 
 streamOption ($name, $value)
 

Protected Attributes

 $packetPool = []
 
 $server
 
 $socket
 
 $receiveBytes = 0
 
 $sendBytes = 0
 
 $sessions = []
 
 $name = ""
 
 $packetLimit = 1000
 
 $shutdown = false
 
 $ticks = 0
 
 $lastMeasure
 
 $block = []
 
 $ipSec = []
 

Constructor & Destructor Documentation

◆ __construct()

__construct ( RakLibServer  $server,
UDPServerSocket  $socket 
)
77  {
78  $this->server = $server;
79  $this->socket = $socket;
80  $this->registerPackets();
81 
82  $this->serverId = mt_rand(0, PHP_INT_MAX);
83 
84  $this->run();
85  }

Member Function Documentation

◆ blockAddress()

blockAddress (   $address,
  $timeout = 300 
)
338  {
339  $final = microtime(true) + $timeout;
340  if(!isset($this->block[$address]) or $timeout === -1){
341  if($timeout === -1){
342  $final = PHP_INT_MAX;
343  }else{
344  $this->getLogger()->notice("Blocked $address for $timeout seconds");
345  }
346  $this->block[$address] = $final;
347  }elseif($this->block[$address] < $final){
348  $this->block[$address] = $final;
349  }
350  }

◆ getID()

getID ( )
393  {
394  return $this->serverId;
395  }

◆ getLogger()

getLogger ( )
91  {
92  return $this->server->getLogger();
93  }

◆ getName()

getName ( )
389  {
390  return $this->name;
391  }

◆ getPacketFromPool()

getPacketFromPool (   $id)
Parameters
$id
Returns
Packet
406  {
407  if(isset($this->packetPool[$id])){
408  return clone $this->packetPool[$id];
409  }
410 
411  return null;
412  }

◆ getPort()

getPort ( )
87  {
88  return $this->server->getPort();
89  }

◆ getSession()

getSession (   $ip,
  $port 
)
Parameters
string$ip
int$port
Returns
Session
362  {
363  $id = $ip . ":" . $port;
364  if(!isset($this->sessions[$id])){
365  $this->checkSessions();
366  $this->sessions[$id] = new Session($this, $ip, $port);
367  }
368 
369  return $this->sessions[$id];
370  }

◆ notifyACK()

notifyACK ( Session  $session,
  $identifierACK 
)
385  {
386  $this->streamACK($session->getAddress() . ":" . $session->getPort(), $identifierACK);
387  }

◆ openSession()

openSession ( Session  $session)
381  {
382  $this->streamOpen($session);
383  }

◆ receiveStream()

receiveStream ( )
255  {
256  if(strlen($packet = $this->server->readMainToThreadPacket()) > 0){
257  $id = ord($packet{0});
258  $offset = 1;
259  if($id === RakLib::PACKET_ENCAPSULATED){
260  $len = ord($packet{$offset++});
261  $identifier = substr($packet, $offset, $len);
262  $offset += $len;
263  if(isset($this->sessions[$identifier])){
264  $flags = ord($packet{$offset++});
265  $buffer = substr($packet, $offset);
266  $this->sessions[$identifier]->addEncapsulatedToQueue(EncapsulatedPacket::fromBinary($buffer, true), $flags);
267  }else{
268  $this->streamInvalid($identifier);
269  }
270  }elseif($id === RakLib::PACKET_RAW){
271  $len = ord($packet{$offset++});
272  $address = substr($packet, $offset, $len);
273  $offset += $len;
274  $port = Binary::readShort(substr($packet, $offset, 2));
275  $offset += 2;
276  $payload = substr($packet, $offset);
277  $this->socket->writePacket($payload, $address, $port);
278  }elseif($id === RakLib::PACKET_CLOSE_SESSION){
279  $len = ord($packet{$offset++});
280  $identifier = substr($packet, $offset, $len);
281  if(isset($this->sessions[$identifier])){
282  $this->removeSession($this->sessions[$identifier]);
283  }else{
284  $this->streamInvalid($identifier);
285  }
286  }elseif($id === RakLib::PACKET_INVALID_SESSION){
287  $len = ord($packet{$offset++});
288  $identifier = substr($packet, $offset, $len);
289  if(isset($this->sessions[$identifier])){
290  $this->removeSession($this->sessions[$identifier]);
291  }
292  }elseif($id === RakLib::PACKET_SET_OPTION){
293  $len = ord($packet{$offset++});
294  $name = substr($packet, $offset, $len);
295  $offset += $len;
296  $value = substr($packet, $offset);
297  switch($name){
298  case "name":
299  $this->name = $value;
300  break;
301  case "portChecking":
302  $this->portChecking = (bool) $value;
303  break;
304  case "packetLimit":
305  $this->packetLimit = (int) $value;
306  break;
307  }
308  }elseif($id === RakLib::PACKET_BLOCK_ADDRESS){
309  $len = ord($packet{$offset++});
310  $address = substr($packet, $offset, $len);
311  $offset += $len;
312  $timeout = Binary::readInt(substr($packet, $offset, 4));
313  $this->blockAddress($address, $timeout);
314  }elseif($id === RakLib::PACKET_UNBLOCK_ADDRESS){
315  $len = ord($packet{$offset++});
316  $address = substr($packet, $offset, $len);
317  $offset += $len;
318  $this->unblockAddress($address);
319  }elseif($id === RakLib::PACKET_SHUTDOWN){
320  foreach($this->sessions as $session){
321  $this->removeSession($session);
322  }
323 
324  $this->socket->close();
325  $this->shutdown = true;
326  }elseif($id === RakLib::PACKET_EMERGENCY_SHUTDOWN){
327  $this->shutdown = true;
328  }else{
329  return false;
330  }
331 
332  return true;
333  }
334 
335  return false;
336  }

◆ removeSession()

removeSession ( Session  $session,
  $reason = "unknown" 
)
372  {
373  $id = $session->getAddress() . ":" . $session->getPort();
374  if(isset($this->sessions[$id])){
375  $this->sessions[$id]->close();
376  unset($this->sessions[$id]);
377  $this->streamClose($id, $reason);
378  }
379  }

◆ run()

run ( )
95  {
96  $this->tickProcessor();
97  }

◆ sendPacket()

sendPacket ( Packet  $packet,
  $dest,
  $port 
)
200  {
201  $packet->encode();
202  $this->sendBytes += $this->socket->writePacket($packet->buffer, $dest, $port);
203  }

◆ streamACK()

streamACK (   $identifier,
  $identifierACK 
)
protected
232  {
233  $buffer = chr(RakLib::PACKET_ACK_NOTIFICATION) . chr(strlen($identifier)) . $identifier . Binary::writeInt($identifierACK);
234  $this->server->pushThreadToMainPacket($buffer);
235  }

◆ streamClose()

streamClose (   $identifier,
  $reason 
)
protected
216  {
217  $buffer = chr(RakLib::PACKET_CLOSE_SESSION) . chr(strlen($identifier)) . $identifier . chr(strlen($reason)) . $reason;
218  $this->server->pushThreadToMainPacket($buffer);
219  }

◆ streamEncapsulated()

streamEncapsulated ( Session  $session,
EncapsulatedPacket  $packet,
  $flags = RakLib::PRIORITY_NORMAL 
)
205  {
206  $id = $session->getAddress() . ":" . $session->getPort();
207  $buffer = chr(RakLib::PACKET_ENCAPSULATED) . chr(strlen($id)) . $id . chr($flags) . $packet->toBinary(true);
208  $this->server->pushThreadToMainPacket($buffer);
209  }

◆ streamInvalid()

streamInvalid (   $identifier)
protected
221  {
222  $buffer = chr(RakLib::PACKET_INVALID_SESSION) . chr(strlen($identifier)) . $identifier;
223  $this->server->pushThreadToMainPacket($buffer);
224  }

◆ streamOpen()

streamOpen ( Session  $session)
protected
226  {
227  $identifier = $session->getAddress() . ":" . $session->getPort();
228  $buffer = chr(RakLib::PACKET_OPEN_SESSION) . chr(strlen($identifier)) . $identifier . chr(strlen($session->getAddress())) . $session->getAddress() . Binary::writeShort($session->getPort()) . Binary::writeLong($session->getID());
229  $this->server->pushThreadToMainPacket($buffer);
230  }

◆ streamOption()

streamOption (   $name,
  $value 
)
protected
237  {
238  $buffer = chr(RakLib::PACKET_SET_OPTION) . chr(strlen($name)) . $name . $value;
239  $this->server->pushThreadToMainPacket($buffer);
240  }

◆ streamRaw()

streamRaw (   $address,
  $port,
  $payload 
)
211  {
212  $buffer = chr(RakLib::PACKET_RAW) . chr(strlen($address)) . $address . Binary::writeShort($port) . $payload;
213  $this->server->pushThreadToMainPacket($buffer);
214  }

◆ unblockAddress()

unblockAddress (   $address)
352  {
353  unset($this->block[$address]);
354  }

Field Documentation

◆ $block

$block = []
protected

◆ $ipSec

$ipSec = []
protected

◆ $lastMeasure

$lastMeasure
protected

◆ $name

$name = ""
protected

◆ $packetLimit

$packetLimit = 1000
protected

◆ $packetPool

$packetPool = []
protected

◆ $portChecking

$portChecking = true

◆ $receiveBytes

$receiveBytes = 0
protected

◆ $sendBytes

$sendBytes = 0
protected

◆ $server

$server
protected

◆ $sessions

$sessions = []
protected

◆ $shutdown

$shutdown = false
protected

◆ $socket

$socket
protected

◆ $ticks

$ticks = 0
protected
The documentation for this class was generated from the following file: