Host.php

Go to the documentation of this file.

<?php
 
namespace PlanetTeamSpeak\TeamSpeak3Framework\Node;
 
use PlanetTeamSpeak\TeamSpeak3Framework\Adapter\ServerQuery;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\AdapterException;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\HelperException;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\ServerQueryException;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\Convert;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\Crypt;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\Signal;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\StringHelper;
use PlanetTeamSpeak\TeamSpeak3Framework\TeamSpeak3;
use ReflectionClass;

class Host extends Node
{
    protected array|null $whoami = null;

    protected array|null $version = null;

    protected array|null $serverList = null;

    protected array|null $permissionEnds = null;

    protected array|null $permissionList = null;

    protected array|null $permissionCats = null;

    protected string|null $predefined_query_name = null;

    protected bool $exclude_query_clients = false;

    protected bool $start_offline_virtual = false;

    protected bool $sort_clients_channels = false;

    public function __construct(ServerQuery $squery)
    {
        $this->parent = $squery;
    }

    public function serverSelectedId(): int
    {
        return $this->whoamiGet("virtualserver_id", 0);
    }

    public function serverSelectedPort(): int
    {
        return $this->whoamiGet("virtualserver_port", 0);
    }

    public function version(string $ident = null): mixed
    {
        if ($this->version === null) {
            $this->version = $this->request("version")->toList();
        }
 
        return ($ident && isset($this->version[$ident])) ? $this->version[$ident] : $this->version;
    }

    public function serverSelect(int $sid, bool $virtual = null): void
    {
        if ($this->whoami !== null && $this->serverSelectedId() == $sid) {
            return;
        }
 
        $virtual = ($virtual !== null) ? $virtual : $this->start_offline_virtual;
        $getargs = func_get_args();
 
        if ($sid != 0 && $this->predefined_query_name !== null) {
            $this->execute("use", ["sid" => $sid, "client_nickname" => (string)$this->predefined_query_name, $virtual ? "-virtual" : null]);
        } else {
            $this->execute("use", ["sid" => $sid, $virtual ? "-virtual" : null]);
        }
 
        $this->whoamiReset();
 
        if ($sid != 0 && $this->predefined_query_name !== null && $this->whoamiGet("client_nickname") != $this->predefined_query_name) {
            $this->execute("clientupdate", ["client_nickname" => (string)$this->predefined_query_name]);
        }
 
        $this->setStorage("_server_use", [__FUNCTION__, $getargs]);
 
        Signal::getInstance()->emit("notifyServerselected", $this);
    }

    public function serverSelectById(int $sid, bool $virtual = null): void
    {
        $this->serverSelect($sid, $virtual);
    }

    public function serverSelectByPort(int $port, bool $virtual = null): void
    {
        if ($this->whoami !== null && $this->serverSelectedPort() == $port) {
            return;
        }
 
        $virtual = ($virtual !== null) ? $virtual : $this->start_offline_virtual;
        $getargs = func_get_args();
 
        if ($port != 0 && $this->predefined_query_name !== null) {
            $this->execute("use", ["port" => $port, "client_nickname" => (string)$this->predefined_query_name, $virtual ? "-virtual" : null]);
        } else {
            $this->execute("use", ["port" => $port, $virtual ? "-virtual" : null]);
        }
 
        $this->whoamiReset();
 
        if ($port != 0 && $this->predefined_query_name !== null && $this->whoamiGet("client_nickname") != $this->predefined_query_name) {
            $this->execute("clientupdate", ["client_nickname" => (string)$this->predefined_query_name]);
        }
 
        $this->setStorage("_server_use", [__FUNCTION__, $getargs]);
 
        Signal::getInstance()->emit("notifyServerselected", $this);
    }

    public function serverDeselect(): void
    {
        $this->serverSelect(0);
 
        $this->delStorage("_server_use");
    }

    public function serverIdGetByPort(int $port): int
    {
        $sid = $this->execute("serveridgetbyport", ["virtualserver_port" => $port])->toList();
 
        return $sid["server_id"];
    }

    public function serverGetPortById(int $sid): int
    {
        if (!array_key_exists((string)$sid, $this->serverList())) {
            throw new ServerQueryException("invalid serverID", 0x400);
        }
 
        return $this->serverList[intval((string)$sid)]["virtualserver_port"];
    }

    public function serverGetSelected(): Server
    {
        return $this->serverGetById($this->serverSelectedId());
    }

    public function serverGetById(int $sid): Server
    {
        $this->serverSelectById($sid);
 
        return new Server($this, ["virtualserver_id" => $sid]);
    }

    public function serverGetByPort(int $port): Server
    {
        $this->serverSelectByPort($port);
 
        return new Server($this, ["virtualserver_id" => $this->serverSelectedId()]);
    }

    public function serverGetByName(string $name): Server
    {
        foreach ($this->serverList() as $server) {
            if ($server["virtualserver_name"] == $name) {
                return $server;
            }
        }
 
        throw new ServerQueryException("invalid serverID", 0x400);
    }

    public function serverGetByUid(string $uid): Server
    {
        foreach ($this->serverList() as $server) {
            if ($server["virtualserver_unique_identifier"] == $uid) {
                return $server;
            }
        }
 
        throw new ServerQueryException("invalid serverID", 0x400);
    }

    public function serverCreate(array $properties = []): array
    {
        $this->serverListReset();
 
        $detail = $this->execute("servercreate", $properties)->toList();
        $server = new Server($this, ["virtualserver_id" => intval($detail["sid"])]);
 
        Signal::getInstance()->emit("notifyServercreated", $this, $detail["sid"]);
        Signal::getInstance()->emit("notifyTokencreated", $server, $detail["token"]);
 
        return $detail;
    }

    public function serverDelete(int $sid): void
    {
        if ($sid == $this->serverSelectedId()) {
            $this->serverDeselect();
        }
 
        $this->execute("serverdelete", ["sid" => $sid]);
        $this->serverListReset();
 
        Signal::getInstance()->emit("notifyServerdeleted", $this, $sid);
    }

    public function serverStart(int $sid): void
    {
        if ($sid == $this->serverSelectedId()) {
            $this->serverDeselect();
        }
 
        $this->execute("serverstart", ["sid" => $sid]);
        $this->serverListReset();
 
        Signal::getInstance()->emit("notifyServerstarted", $this, $sid);
    }

    public function serverStop(int $sid, string $msg = null): void
    {
        if ($sid == $this->serverSelectedId()) {
            $this->serverDeselect();
        }
 
        $this->execute("serverstop", ["sid" => $sid, "reasonmsg" => $msg]);
        $this->serverListReset();
 
        Signal::getInstance()->emit("notifyServerstopped", $this, $sid);
    }

    public function serverStopProcess(string $msg = null): void
    {
        Signal::getInstance()->emit("notifyServershutdown", $this);
 
        $this->execute("serverprocessstop", ["reasonmsg" => $msg]);
    }

    public function serverList(array $filter = []): array|Server
    {
        if ($this->serverList === null) {
            $servers = $this->request("serverlist -uid")->toAssocArray("virtualserver_id");
 
            $this->serverList = [];
 
            foreach ($servers as $sid => $server) {
                $this->serverList[$sid] = new Server($this, $server);
            }
 
            $this->resetNodeList();
        }
 
        return $this->filterList($this->serverList, $filter);
    }

    public function serverListReset(): void
    {
        $this->resetNodeList();
        $this->serverList = null;
    }

    public function bindingList(string $subsystem = "voice"): array
    {
        return $this->execute("bindinglist", ["subsystem" => $subsystem])->toArray();
    }

    public function apiKeyCount(): int
    {
        return current($this->execute("apikeylist -count", ["duration" => 1])->toList("count"));
    }

    public function apiKeyList(int $offset = null, int $limit = null, mixed $cldbid = null): array
    {
        return $this->execute("apikeylist -count", ["start" => $offset, "duration" => $limit, "cldbid" => $cldbid])->toAssocArray("id");
    }

    public function apiKeyCreate(string $scope = TeamSpeak3::APIKEY_READ, int $lifetime = 14, int $cldbid = null): array
    {
        $detail = $this->execute("apikeyadd", ["scope" => $scope, "lifetime" => $lifetime, "cldbid" => $cldbid])->toList();
 
        Signal::getInstance()->emit("notifyApikeycreated", $this, $detail["apikey"]);
 
        return $detail;
    }

    public function apiKeyDelete(int $id): void
    {
        $this->execute("apikeydel", ["id" => $id]);
    }

    public function permissionList(): array
    {
        if ($this->permissionList === null) {
            $this->fetchPermissionList();
        }
 
        foreach ($this->permissionList as $permname => $permdata) {
            if (isset($permdata["permcatid"]) && $permdata["permgrant"]) {
                continue;
            }
 
            $this->permissionList[$permname]["permcatid"] = $this->permissionGetCategoryById($permdata["permid"]);
            $this->permissionList[$permname]["permgrant"] = $this->permissionGetGrantById($permdata["permid"]);
 
            $grantsid = "i_needed_modify_power_" . substr($permname, 2);
 
            if (!$permdata["permname"]->startsWith("i_needed_modify_power_") && !isset($this->permissionList[$grantsid])) {
                $this->permissionList[$grantsid]["permid"] = $this->permissionList[$permname]["permgrant"];
                $this->permissionList[$grantsid]["permname"] = StringHelper::factory($grantsid);
                $this->permissionList[$grantsid]["permdesc"] = null;
                $this->permissionList[$grantsid]["permcatid"] = 0xFF;
                $this->permissionList[$grantsid]["permgrant"] = $this->permissionList[$permname]["permgrant"];
            }
        }
 
        return $this->permissionList;
    }

    public function permissionCats(): array
    {
        if ($this->permissionCats === null) {
            $this->fetchPermissionCats();
        }
 
        return $this->permissionCats;
    }

    public function permissionEnds(): array
    {
        if ($this->permissionEnds === null) {
            $this->fetchPermissionList();
        }
 
        return $this->permissionCats;
    }

    public function permissionTree(): array
    {
        $permissionList = $this->permissionList();
 
        $permtree = [];
 
        foreach ($this->permissionCats() as $val) {
            $permtree[$val]["permcatid"] = $val;
            $permtree[$val]["permcathex"] = "0x" . dechex($val);
            $permtree[$val]["permcatname"] = StringHelper::factory(Convert::permissionCategory($val));
            $permtree[$val]["permcatparent"] = $permtree[$val]["permcathex"][3] == 0 ? 0 : hexdec($permtree[$val]["permcathex"][2] . 0);
            $permtree[$val]["permcatchilren"] = 0;
            $permtree[$val]["permcatcount"] = 0;
 
            if (isset($permtree[$permtree[$val]["permcatparent"]])) {
                $permtree[$permtree[$val]["permcatparent"]]["permcatchilren"]++;
            }
 
            if ($permtree[$val]["permcatname"]->contains("/")) {
                $permtree[$val]["permcatname"] = $permtree[$val]["permcatname"]->section("/", 1)->trim();
            }
 
            foreach ($permissionList as $permission) {
                if ((! array_key_exists("permid", $permission)) or (! array_key_exists("permcatid", $permission["permid"]))) {
                    continue;
                }
                if ($permission["permid"]["permcatid"] == $val) {
                    $permtree[$val]["permcatcount"]++;
                }
            }
        }
 
        return $permtree;
    }

    public function permissionFind(int|array $permissionId): array
    {
        if (!is_array($permissionId)) {
            $permident = (is_numeric($permissionId)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permissionId))) ? "permid" : "permsid";
        }
 
        return $this->execute("permfind", [$permident => $permissionId])->toArray();
    }

    public function permissionGetIdByName(string $name): int
    {
        if (!array_key_exists($name, $this->permissionList())) {
            throw new ServerQueryException("invalid permission ID", 0xA02);
        }
 
        return $this->permissionList[$name]["permid"];
    }

    public function permissionGetNameById(int $permissionId): StringHelper
    {
        foreach ($this->permissionList() as $name => $perm) {
            if ($perm["permid"] == $permissionId) {
                return new StringHelper($name);
            }
        }
 
        throw new ServerQueryException("invalid permission ID", 0xA02);
    }

    public function permissionGetCategoryById(int $permid): int
    {
        if (!is_numeric($permid)) {
            $permid = $this->permissionGetIdByName($permid);
        }
 
        if ($permid < 0x1000) {
            if ($this->permissionEnds === null) {
                $this->fetchPermissionList();
            }
 
            if ($this->permissionCats === null) {
                $this->fetchPermissionCats();
            }
 
            $catids = array_values($this->permissionCats());
 
            foreach ($this->permissionEnds as $key => $val) {
                if ($val >= $permid && isset($catids[$key])) {
                    return $catids[$key];
                }
            }
 
            return 0;
        } else {
            return (int)$permid >> 8;
        }
    }

    public function permissionGetGrantById(int $permid): int
    {
        if (!is_numeric($permid)) {
            $permid = $this->permissionGetIdByName($permid);
        }
 
        if ($permid < 0x1000) {
            return (int)$permid + 0x8000;
        } else {
            return (int)bindec(substr(decbin($permid), -8)) + 0xFF00;
        }
    }

    public function serverGroupPermAutoAssign(int $sgtype, int|array $permid, int|array $permvalue, int|array $permnegated = 0, array|bool $permskip = false): void
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }
 
        $this->execute("servergroupautoaddperm", ["sgtype" => $sgtype, $permident => $permid, "permvalue" => $permvalue, "permnegated" => $permnegated, "permskip" => $permskip]);
    }

    public function serverGroupPermAutoRemove(int $sgtype, int|array $permid): void
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }
 
        $this->execute("servergroupautodelperm", ["sgtype" => $sgtype, $permident => $permid]);
    }

    public function selfPermCheck(int|array $permid): array
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }
 
        return $this->execute("permget", [$permident => $permid])->toAssocArray("permsid");
    }

    public function modify(array $properties): void
    {
        $this->execute("instanceedit", $properties);
        $this->resetNodeInfo();
    }

    public function message(string $msg): void
    {
        $this->execute("gm", ["msg" => $msg]);
    }

    public function logView(int $lines = 30, int $begin_pos = null, bool $reverse = null, bool $instance = true): array
    {
        return $this->execute("logview", ["lines" => $lines, "begin_pos" => $begin_pos, "instance" => $instance, "reverse" => $reverse])->toArray();
    }

    public function logAdd(string $logmsg, int $loglevel = TeamSpeak3::LOGLEVEL_INFO): void
    {
        $sid = $this->serverSelectedId();
 
        $this->serverDeselect();
        $this->execute("logadd", ["logmsg" => $logmsg, "loglevel" => $loglevel]);
        $this->serverSelect($sid);
    }

    public function login(string $username, string $password): void
    {
        $this->execute("login", ["client_login_name" => $username, "client_login_password" => $password]);
        $this->whoamiReset();
 
        $crypt = new Crypt($username);
 
        $this->setStorage("_login_user", $username);
        $this->setStorage("_login_pass", $crypt->encrypt($password));
 
        Signal::getInstance()->emit("notifyLogin", $this);
    }

    public function logout(): void
    {
        $this->request("logout");
        $this->whoamiReset();
 
        $this->delStorage("_login_user");
        $this->delStorage("_login_pass");
 
        Signal::getInstance()->emit("notifyLogout", $this);
    }

    public function queryCountLogin(string $pattern = null): mixed
    {
        return current($this->execute("queryloginlist -count", ["duration" => 1, "pattern" => $pattern])->toList("count"));
    }

    public function queryListLogin(int $offset = null, int $limit = null, string $pattern = null): array
    {
        return $this->execute("queryloginlist -count", ["start" => $offset, "duration" => $limit, "pattern" => $pattern])->toAssocArray("cldbid");
    }

    public function queryLoginCreate(string $username, int $cldbid = 0): array
    {
        if ($this->serverSelectedId()) {
            return $this->execute("queryloginadd", ["client_login_name" => $username, "cldbid" => $cldbid])->toList();
        } else {
            return $this->execute("queryloginadd", ["client_login_name" => $username])->toList();
        }
    }

    public function queryLoginDelete(int $cldbid)
    {
        $this->execute("querylogindel", ["cldbid" => $cldbid]);
    }

    public function whoami(): array
    {
        if ($this->whoami === null) {
            $this->whoami = $this->request("whoami")->toList();
        }
 
        return $this->whoami;
    }

    public function whoamiGet(string $ident, mixed $default = null): mixed
    {
        if (array_key_exists($ident, $this->whoami())) {
            return $this->whoami[$ident];
        }
 
        return $default;
    }

    public function whoamiSet(string $ident, mixed $value = null)
    {
        $this->whoami();
 
        $this->whoami[$ident] = (is_numeric($value)) ? (int)$value : StringHelper::factory($value);
    }

    public function whoamiReset()
    {
        $this->whoami = null;
    }

    public function getAdapterHost(): string
    {
        return $this->getParent()->getTransportHost();
    }

    public function getAdapterPort(): string
    {
        return $this->getParent()->getTransportPort();
    }

    protected function fetchNodeList()
    {
        $servers = $this->serverList();
 
        foreach ($servers as $server) {
            $this->nodeList[] = $server;
        }
    }

    protected function fetchNodeInfo()
    {
        $info1 = $this->request("hostinfo")->toList();
        $info2 = $this->request("instanceinfo")->toList();
 
        $this->nodeInfo = array_merge($this->nodeInfo, $info1, $info2);
    }

    protected function fetchPermissionList()
    {
        $reply = $this->request("permissionlist -new")->toArray();
        $start = 1;
 
        $this->permissionEnds = [];
        $this->permissionList = [];
 
        foreach ($reply as $line) {
            if (array_key_exists("group_id_end", $line)) {
                $this->permissionEnds[] = $line["group_id_end"];
            } else {
                $this->permissionList[$line["permname"]->toString()] = array_merge(["permid" => $start++], $line);
            }
        }
    }

    protected function fetchPermissionCats()
    {
        $permcats = [];
        $reflects = new ReflectionClass("TeamSpeak3");
 
        foreach ($reflects->getConstants() as $key => $val) {
            if (!StringHelper::factory($key)->startsWith("PERM_CAT") || $val == 0xFF) {
                continue;
            }
 
            $permcats[$key] = $val;
        }
 
        $this->permissionCats = $permcats;
    }

    public function setPredefinedQueryName(string $name = null)
    {
        $this->setStorage("_query_nick", $name);
 
        $this->predefined_query_name = $name;
    }

    public function getPredefinedQueryName(): ?string
    {
        return $this->predefined_query_name;
    }

    public function setExcludeQueryClients(bool $exclude = false): void
    {
        $this->setStorage("_query_hide", $exclude);
 
        $this->exclude_query_clients = $exclude;
    }

    public function getExcludeQueryClients(): bool
    {
        return $this->exclude_query_clients;
    }

    public function setUseOfflineAsVirtual(bool $virtual = false): void
    {
        $this->setStorage("_do_virtual", $virtual);
 
        $this->start_offline_virtual = $virtual;
    }

    public function getUseOfflineAsVirtual(): bool
    {
        return $this->start_offline_virtual;
    }

    public function setLoadClientlistFirst(bool $first = false)
    {
        $this->setStorage("_client_top", $first);
 
        $this->sort_clients_channels = $first;
    }

    public function getLoadClientlistFirst(): bool
    {
        return $this->sort_clients_channels;
    }

    public function getAdapter(): ServerQuery
    {
        return $this->getParent();
    }

    public function getUniqueId(): string
    {
        return "ts3_h";
    }

    public function getIcon(): string
    {
        return "host";
    }

    public function getSymbol(): string
    {
        return "+";
    }

    public function __wakeup()
    {
        $username = $this->getStorage("_login_user");
        $password = $this->getStorage("_login_pass");
 
        if ($username && $password) {
            $crypt = new Crypt($username);
 
            $this->login($username, $crypt->decrypt($password));
        }
 
        $this->predefined_query_name = $this->getStorage("_query_nick");
        $this->exclude_query_clients = $this->getStorage("_query_hide", false);
        $this->start_offline_virtual = $this->getStorage("_do_virtual", false);
        $this->sort_clients_channels = $this->getStorage("_client_top", false);
 
        if ($server = $this->getStorage("_server_use")) {
            $func = array_shift($server);
            $args = array_shift($server);
 
            call_user_func_array([$this, $func], $args);
        }
    }

    public function __toString()
    {
        return $this->getAdapterHost();
    }
}