Backend.php

<?php
namespace SmartData;

if (!extension_loaded('cassandra'))
    die ("Unable to load cassandra extension\n");

require_once( __DIR__ . '/Config.php');
require_once( __DIR__ . '/Logger.php');
require_once( __DIR__ . '/Exception.php');
require_once( __DIR__ . '/Aggregators.php');
require_once( __DIR__ . '/Series.php');
require_once( __DIR__ . '/SmartData.php');
require_once( __DIR__ . '/Unit.php');
require_once( __DIR__ . '/Packer.php');
require_once( __DIR__ . '/Time.php');

use SmartData\Utility\{Pack,Unpack};
use SmartData\Exception\{AuthenticationException,BadRequestException,InternalException};

class Backend_Common
{
    protected $_domain;
    protected $_username;
    protected $_password;

    protected $_client_ip;
    protected $_client_name;

    protected $_gw_id;

    private $_session_id;

    private $_internal;
    protected function internal(){ return $this->_internal; }

    protected const READ = 'r';
    protected const WRITE = 'w';

    // The parameter "$internal" means that the Backend has been called without a requisition.
    // Please, be careful and use only for development tasks.
    public function __construct(Credentials $credentials = NULL, $internal=false) {
        $credentials = $credentials ?? new Credentials();

        $testint = 0x00FF; // Ensure the machine is little-endian
        if(!($testint===current(unpack('v', pack('S', $testint))))) throw new \Exception("The machine is not little-endian");
        $this->_gw_id = -1; //NOTE: That means that the client isn't a known gateway
        $this->_internal = $internal; //NOTE: just for developers

        $USER   = ($credentials->username != NULL and $credentials->password != NULL);
        $DOMAIN = ($credentials->domain != NULL);

        // If it's not in an internal mode and the request is not secure (SSL), only the
        // domains listed in Config::config()::ACCESSIBLE_WITHOUT_SSL can be accessed.
        if (!$internal && !REQUEST_HTTPS && !in_array($credentials->domain, Config::config()::ACCESSIBLE_WITHOUT_SSL)){
            throw new AuthenticationException("Authentication failure [{$credentials}]");
        }

        switch (REQUEST_URI) {
            case 'get.php':
                /**
                 *  ====== Summary of rules ======
                 *  HTTPS ^ CERT ^ domain -> OK, domain = $domain
                 *  HTTPS ^ CERT  -> OK, domain = DB(CERT)->domain
                 *  HTTPS ^ domain ^ valid(usr+password) -> OK, domain = $domain
                 *  HTTPS ^ valid(usr+password) -> OK, domain = public
                 *  HTTPS ^ domain -> OK, domain is public ? domain = $domain : fail
                 *  HTTPS -> OK, domain = public
                 *  HTTP ^ valid(usr+password) -> OK, domain = hydrology
                 *  Fail
                 */

                if ( REQUEST_HTTPS && REQUEST_CERT && $DOMAIN ) {
                    if(!$this->_checkCertificate(REQUEST_SERIAL, self::READ, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(CD) Unauthorized access');
                } else if ( REQUEST_HTTPS && REQUEST_CERT ) {
                    if(!$this->_checkCertificate(REQUEST_SERIAL, self::READ))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(C) Unauthorized access');
                } else if ( REQUEST_HTTPS && $DOMAIN && $USER ) {
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::READ, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(DU) Unauthorized access');
                } else if ( REQUEST_HTTPS && $USER ) {
                    $credentials->domain = Config::config()::PUBLIC_DOMAIN;
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::READ, Config::config()::PUBLIC_DOMAIN))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(U) Unauthorized access');
                } else if ( REQUEST_HTTPS && $DOMAIN ) {
                    // NOTE: Publicly readable domains
                    if(!$this->_checkUser(Config::config()::DEFAULT_USERNAME, Config::config()::DEFAULT_PASSWORD, self::READ, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(D) Unauthorized access');
                } else if ( REQUEST_HTTPS ) {
                    $this->_domain   = Config::config()::PUBLIC_DOMAIN;
                    $this->_username = Config::config()::DEFAULT_USERNAME;
                    $this->_password = Config::config()::DEFAULT_PASSWORD;
                } else if ( !REQUEST_HTTPS && $DOMAIN && $USER ) {
                    //NOTE: Domain that are accessible with HTTP (without SSL)
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::READ, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(DU) Unauthorized access');
                } else {
                    throw new BadRequestException(REQUEST_DBG.' crd:'.$credentials.' Bad protocol and options');
                }
                break;

            case 'create.php'    :
            case 'attach.php'    :
            case 'put.php'       :
            case 'batch.php'     :
            case 'put_batch.php' :
                /**
                 *  ====== Summary of rules ======
                 *  HTTPS ^ CERT ^ domain -> OK, domain = $domain
                 *  HTTPS ^ CERT  -> OK, domain = DB(CERT)->domain
                 *  HTTPS ^ domain ^ valid(usr+password) -> OK, domain = $domain
                 *  HTTPS ^ valid(usr+password) -> OK, domain = public
                 *  HTTP  ^ valid(usr+password) -> OK, domain = hydrology
                 *  Fail
                 */

                if ( REQUEST_HTTPS && REQUEST_CERT && $DOMAIN ) {
                    if(!$this->_checkCertificate(REQUEST_SERIAL, self::WRITE, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(CD) Unauthorized access');
                } else if ( REQUEST_HTTPS && REQUEST_CERT ) {
                    if(!$this->_checkCertificate(REQUEST_SERIAL, self::WRITE))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(C) Unauthorized access');
                } else if ( REQUEST_HTTPS && $DOMAIN && $USER ) {
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::WRITE, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(DU) Unauthorized access');
                } else if ( REQUEST_HTTPS && $USER ) {
                    //TODO: Check what is the main idea
                    $credentials->domain = Config::config()::PUBLIC_DOMAIN;
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::WRITE, Config::config()::PUBLIC_DOMAIN))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(U) Unauthorized access');
                } else if ( REQUEST_HTTPS && $DOMAIN ) {
                    // NOTE: Public writable domains
                    if(!$this->_checkUser(Config::config()::DEFAULT_USERNAME, Config::config()::DEFAULT_PASSWORD, self::WRITE, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(D) Unauthorized access');
                } else if ( !REQUEST_HTTPS && $DOMAIN && $USER ) {
                    //NOTE: Domain that are accessible with HTTP (without SSL)
                    if(!$this->_checkUser($credentials->username, $credentials->password, self::WRITE, $credentials->domain))
                        throw new AuthenticationException(REQUEST_DBG.' crd:'.$credentials.'(DU) Unauthorized access');
                } else {
                    throw new BadRequestException(REQUEST_DBG.' crd:'.$credentials.' Bad protocol and options');
                }
                break;
            default:
                if($this->internal()){
                    $this->_domain = $credentials->domain;
                    $this->_username = $credentials->username;
                    $this->_password = $credentials->password;
                } else
                    throw new BadRequestException(REQUEST_DBG.' crd:'.$credentials.' Bad protocol and options');
                break;
        }

        if($this->_domain == null || $this->_username == null || $this->_password == null){
            throw new BadRequestException("Incorrect use of protocol and options {$credentials}");
        }

        $this->_session_id = $this->_domain.'_'.substr(uniqid(), -5);
        if(REQUEST_URI != 'get.php')
            self::debug_X($this);
    }

    // Checks the health of databases
    public static function health_check() : bool {
        $sucess = true;
        try {
            $conn = self::_mysqlConnect(Config::config()::MYSQL_SEVERNAME,
                                        Config::config()::MYSQL_PORT,
                                        Config::config()::MYSQL_DBNAME,
                                        Config::config()::MYSQL_USERNAME,
                                        Config::config()::MYSQL_PASSWORD);
            $conn = null;
            $session = self::_cassandraConnect(Config::config()::CASSANDRA_SERVERNAME,
                                               Config::config()::CASSANDRA_PORT,
                                               Config::config()::DEFAULT_USERNAME,
                                               Config::config()::DEFAULT_PASSWORD,
                                               Config::config()::CASSANDRA_KEYSPACE);
            $session->close();
        } catch (\Exception $e) {
            Logger::exception($e);
            $sucess = false;
        } finally {
            if (isset($session))
                $session->close();
            $conn = null;
        }
        return $sucess;
    }

    // Check Certificate
    private function _checkCertificate(string $certificate, string $level, string $domain = null) : bool {
        $sucess = true;
        $target_domain = "";
        $gw_id = -1;

        $parameters = array(':certificate' => $certificate,
                            ':level'       => $level);

        try {

            $conn = self::_mysqlConnect(Config::config()::MYSQL_SEVERNAME, Config::config()::MYSQL_PORT, Config::config()::MYSQL_DBNAME, Config::config()::MYSQL_USERNAME, Config::config()::MYSQL_PASSWORD);