|
Linux server.jmdstrack.com 3.10.0-1160.119.1.el7.tuxcare.els10.x86_64 #1 SMP Fri Oct 11 21:40:41 UTC 2024 x86_64
/ home/ jmdstrac/ public_html/ devices/ src/ |
|
|
<?php
/**
* ---------------------------------------------------------------------
*
* GLPI - Gestionnaire Libre de Parc Informatique
*
* http://glpi-project.org
*
* @copyright 2015-2023 Teclib' and contributors.
* @copyright 2003-2014 by the INDEPNET Development Team.
* @copyright 2010-2022 by the FusionInventory Development Team.
* @licence https://www.gnu.org/licenses/gpl-3.0.html
*
* ---------------------------------------------------------------------
*
* LICENSE
*
* This file is part of GLPI.
*
* This program 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* ---------------------------------------------------------------------
*/
use Glpi\Application\ErrorHandler;
use Glpi\Application\View\TemplateRenderer;
use Glpi\Inventory\Conf;
use Glpi\Plugin\Hooks;
use Glpi\Toolbox\Sanitizer;
use GuzzleHttp\Client as Guzzle_Client;
use GuzzleHttp\Psr7\Response;
/**
* @since 10.0.0
**/
class Agent extends CommonDBTM
{
/** @var integer */
public const DEFAULT_PORT = 62354;
/** @var string */
public const ACTION_STATUS = 'status';
/** @var string */
public const ACTION_INVENTORY = 'inventory';
/** @var integer */
protected const TIMEOUT = 5;
/** @var boolean */
public $dohistory = true;
/** @var string */
public static $rightname = 'agent';
//static $rightname = 'inventory';
private static $found_address = false;
public static function getTypeName($nb = 0)
{
return _n('Agent', 'Agents', $nb);
}
public function rawSearchOptions()
{
$tab = [
[
'id' => 'common',
'name' => self::getTypeName(1)
], [
'id' => '1',
'table' => $this->getTable(),
'field' => 'name',
'name' => __('Name'),
'datatype' => 'itemlink',
], [
'id' => '2',
'table' => Entity::getTable(),
'field' => 'completename',
'name' => Entity::getTypeName(1),
'datatype' => 'dropdown',
], [
'id' => '3',
'table' => $this->getTable(),
'field' => 'is_recursive',
'name' => __('Child entities'),
'datatype' => 'bool',
], [
'id' => '4',
'table' => $this->getTable(),
'field' => 'last_contact',
'name' => __('Last contact'),
'datatype' => 'datetime',
], [
'id' => '5',
'table' => $this->getTable(),
'field' => 'locked',
'name' => __('Locked'),
'datatype' => 'bool',
], [
'id' => '6',
'table' => $this->getTable(),
'field' => 'deviceid',
'name' => __('Device id'),
'datatype' => 'text',
'massiveaction' => false,
], [
'id' => '8',
'table' => $this->getTable(),
'field' => 'version',
'name' => _n('Version', 'Versions', 1),
'datatype' => 'text',
'massiveaction' => false,
], [
'id' => '10',
'table' => $this->getTable(),
'field' => 'useragent',
'name' => __('Useragent'),
'datatype' => 'text',
'massiveaction' => false,
], [
'id' => '11',
'table' => $this->getTable(),
'field' => 'tag',
'name' => __('Tag'),
'datatype' => 'text',
'massiveaction' => false,
], [
'id' => '14',
'table' => $this->getTable(),
'field' => 'port',
'name' => _n('Port', 'Ports', 1),
'datatype' => 'integer',
], [
'id' => '15',
'table' => $this->getTable(),
'field' => 'items_id',
'name' => _n('Item', 'Items', 1),
'nosearch' => true,
'massiveaction' => false,
'forcegroupby' => true,
'datatype' => 'specific',
'searchtype' => 'equals',
'additionalfields' => ['itemtype'],
'joinparams' => ['jointype' => 'child']
],
[
'id' => '16',
'table' => $this->getTable(),
'field' => 'remote_addr',
'name' => __('Public contact address'),
'datatype' => 'text',
'massiveaction' => false,
],
[
'id' => 17,
'table' => $this->getTable(),
'field' => 'use_module_wake_on_lan',
'name' => __('Wake on LAN'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 18,
'table' => $this->getTable(),
'field' => 'use_module_computer_inventory',
'name' => __('Computer inventory'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 19,
'table' => $this->getTable(),
'field' => 'use_module_esx_remote_inventory',
'name' => __('ESX remote inventory'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 20,
'table' => $this->getTable(),
'field' => 'use_module_network_inventory',
'name' => __('Network inventory (SNMP)'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 21,
'table' => $this->getTable(),
'field' => 'use_module_network_discovery',
'name' => __('Network discovery (SNMP)'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 22,
'table' => $this->getTable(),
'field' => 'use_module_package_deployment',
'name' => __('Package Deployment'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 23,
'table' => $this->getTable(),
'field' => 'use_module_collect_data',
'name' => __('Collect data'),
'datatype' => 'bool',
'massiveaction' => false,
],
[
'id' => 24,
'table' => $this->getTable(),
'field' => 'use_module_remote_inventory',
'name' => __('Remote inventory'),
'datatype' => 'bool',
'massiveaction' => false,
]
];
return $tab;
}
public static function getSpecificValueToDisplay($field, $values, array $options = [])
{
if (!is_array($values)) {
$values = [$field => $values];
}
switch ($field) {
case 'items_id':
$itemtype = $values[str_replace('items_id', 'itemtype', $field)] ?? null;
if ($itemtype !== null && class_exists($itemtype)) {
if ($values[$field] > 0) {
$item = new $itemtype();
$item->getFromDB($values[$field]);
return "<a href='" . $item->getLinkURL() . "'>" . $item->fields['name'] . "</a>";
}
} else {
return ' ';
}
break;
}
return parent::getSpecificValueToDisplay($field, $values, $options);
}
public static function rawSearchOptionsToAdd()
{
$tab = [];
// separator
$tab[] = [
'id' => 'agent',
'name' => self::getTypeName(1),
];
$baseopts = [
'table' => self::getTable(),
'joinparams' => [
'jointype' => 'itemtype_item',
],
];
$tab[] = [
'id' => 900,
'field' => 'name',
'name' => __('Name'),
'datatype' => 'itemlink',
] + $baseopts;
$tab[] = [
'id' => 901,
'field' => 'tag',
'name' => __('Tag'),
'datatype' => 'text',
] + $baseopts;
$tab[] = [
'id' => 902,
'field' => 'last_contact',
'name' => __('Last contact'),
'datatype' => 'datetime',
] + $baseopts;
$tab[] = [
'id' => 903,
'field' => 'version',
'name' => _n('Version', 'Versions', 1),
'datatype' => 'text',
] + $baseopts;
$tab[] = [
'id' => 904,
'field' => 'deviceid',
'name' => __('Device id'),
'datatype' => 'text',
] + $baseopts;
$tab[] = [
'id' => 905,
'field' => 'remote_addr',
'name' => __('Public contact address'),
'datatype' => 'text',
] + $baseopts;
$tab[] = [
'id' => 906,
'field' => 'useragent',
'name' => __('Useragent'),
'datatype' => 'text',
] + $baseopts;
return $tab;
}
/**
* Define tabs to display on form page
*
* @param array $options
* @return array containing the tabs name
*/
public function defineTabs($options = [])
{
$ong = [];
$this->addDefaultFormTab($ong);
$this->addStandardTab('RuleMatchedLog', $ong, $options);
$this->addStandardTab('Log', $ong, $options);
return $ong;
}
/**
* Display form for agent configuration
*
* @param integer $id ID of the agent
* @param array $options Options
*
* @return boolean
*/
public function showForm($id, array $options = [])
{
global $CFG_GLPI;
if (!empty($id)) {
$this->getFromDB($id);
} else {
$this->getEmpty();
}
$this->initForm($id, $options);
// avoid generic form to display generic version field as we have an exploded view
$versions = $this->fields['version'] ?? '';
unset($this->fields['version']);
TemplateRenderer::getInstance()->display('pages/admin/inventory/agent.html.twig', [
'item' => $this,
'params' => $options,
'itemtypes' => array_combine($CFG_GLPI['inventory_types'], $CFG_GLPI['inventory_types']),
'versions_field' => $versions,
]);
return true;
}
/**
* Handle agent
*
* @param array $metadata Agents metadata from Inventory
*
* @return integer
*/
public function handleAgent($metadata)
{
global $CFG_GLPI;
$deviceid = $metadata['deviceid'];
$aid = false;
if ($this->getFromDBByCrit(Sanitizer::dbEscapeRecursive(['deviceid' => $deviceid]))) {
$aid = $this->fields['id'];
}
$atype = new AgentType();
if (!$atype->getFromDBByCrit(['name' => 'Core'])) {
$atype->add([
'name' => 'Core',
]);
}
$input = [
'deviceid' => $deviceid,
'name' => $deviceid,
'last_contact' => date('Y-m-d H:i:s'),
'useragent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
'agenttypes_id' => $atype->fields['id'],
'itemtype' => $metadata['itemtype'] ?? 'Computer'
];
if (isset($metadata['provider']['version'])) {
$input['version'] = $metadata['provider']['version'];
}
if (isset($metadata['tag'])) {
$input['tag'] = $metadata['tag'];
}
if (isset($metadata['port'])) {
$input['port'] = $metadata['port'];
}
if (isset($metadata['enabled-tasks'])) {
$input['use_module_computer_inventory'] = in_array("inventory", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_network_discovery'] = in_array("netdiscovery", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_network_inventory'] = in_array("netinventory", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_remote_inventory'] = in_array("remoteinventory", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_wake_on_lan'] = in_array("wakeonlan", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_esx_remote_inventory'] = in_array("esx", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_package_deployment'] = in_array("deploy", $metadata['enabled-tasks']) ? 1 : 0;
$input['use_module_collect_data'] = in_array("collect", $metadata['enabled-tasks']) ? 1 : 0;
}
$remote_ip = "";
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
//Managing IP through a PROXY
$remote_ip = explode(', ', $_SERVER['HTTP_X_FORWARDED_FOR'])[0];
} elseif (isset($_SERVER['HTTP_X_REAL_IP'])) {
//try with X-Real-IP
$remote_ip = $_SERVER['HTTP_X_REAL_IP'];
} elseif (isset($_SERVER['REMOTE_ADDR'])) {
//then get connected IP
$remote_ip = $_SERVER['REMOTE_ADDR'];
}
$remote_ip = new IPAddress($remote_ip);
if ($remote_ip->is_valid()) {
$input['remote_addr'] = $remote_ip->getTextual();
}
$has_expected_agent_type = in_array($metadata['itemtype'], $CFG_GLPI['agent_types']);
if ($deviceid === 'foo' || (!$has_expected_agent_type && !$aid)) {
$input += [
'items_id' => 0,
'id' => 0
];
$this->fields = $input;
return 0;
}
$input = Sanitizer::sanitize($input);
if ($aid) {
$input['id'] = $aid;
// We should not update itemtype in db if not an expected one
if (!$has_expected_agent_type) {
unset($input['itemtype']);
}
$this->update($input);
// Don't keep linked item unless having expected agent type
if (!$has_expected_agent_type) {
$this->fields['items_id'] = 0;
// But always keep itemtype for class instantiation
$this->fields['itemtype'] = $metadata['itemtype'];
}
} else {
$input['items_id'] = 0;
$aid = $this->add($input);
}
return $aid;
}
/**
* Prepare input for add and update
*
* @param array $input Input
*
* @return array|false
*/
public function prepareInputs(array $input)
{
if ($this->isNewItem() && (!isset($input['deviceid']) || empty($input['deviceid']))) {
Session::addMessageAfterRedirect(__('"deviceid" is mandatory!'), false, ERROR);
return false;
}
return $input;
}
public function prepareInputForAdd($input)
{
global $CFG_GLPI;
if (isset($CFG_GLPI['threads_networkdiscovery']) && !isset($input['threads_networkdiscovery'])) {
$input['threads_networkdiscovery'] = 0;
}
if (isset($CFG_GLPI['threads_networkinventory']) && !isset($input['threads_networkinventory'])) {
$input['threads_networkinventory'] = 0;
}
if (isset($CFG_GLPI['timeout_networkdiscovery']) && !isset($input['timeout_networkdiscovery'])) {
$input['timeout_networkdiscovery'] = 0;
}
if (isset($CFG_GLPI['timeout_networkinventory']) && !isset($input['timeout_networkinventory'])) {
$input['timeout_networkinventory'] = 0;
}
return $this->prepareInputs($input);
}
public function prepareInputForUpdate($input)
{
return $this->prepareInputs($input);
}
/**
* Get item linked to current agent
*
* @return CommonDBTM
*/
public function getLinkedItem(): CommonDBTM
{
$itemtype = $this->fields['itemtype'];
$item = new $itemtype();
$item->getFromDB($this->fields['items_id']);
return $item;
}
/**
* Guess possible addresses the agent should answer on
*
* @return array
*/
public function guessAddresses(): array
{
global $DB;
$addresses = [];
//retrieve linked items
$item = $this->getLinkedItem();
if ((int)$item->getID() > 0) {
$item_name = $item->getFriendlyName();
$addresses[] = $item_name;
//deviceid should contains machines name
$matches = [];
preg_match('/^(\s)+-\d{4}(-\d{2}){5}$/', $this->fields['deviceid'], $matches);
if (isset($matches[1])) {
if (!in_array($matches[1], $addresses)) {
$addresses[] = $matches[1];
}
}
//append linked ips
$ports_iterator = $DB->request([
'SELECT' => ['ips.name', 'ips.version'],
'FROM' => NetworkPort::getTable() . ' AS netports',
'WHERE' => [
'netports.itemtype' => $item->getType(),
'netports.items_id' => $item->getID(),
'NOT' => [
'OR' => [
'AND' => [
'NOT' => [
'netports.instantiation_type' => 'NULL'
],
'netports.instantiation_type' => 'NetworkPortLocal'
],
'ips.name' => ['127.0.0.1', '::1']
]
]
],
'INNER JOIN' => [
NetworkName::getTable() . ' AS netnames' => [
'ON' => [
'netnames' => 'items_id',
'netports' => 'id', [
'AND' => [
'netnames.itemtype' => NetworkPort::getType()
]
]
]
],
IPAddress::getTable() . ' AS ips' => [
'ON' => [
'ips' => 'items_id',
'netnames' => 'id', [
'AND' => [
'ips.itemtype' => NetworkName::getType()
]
]
]
]
]
]);
foreach ($ports_iterator as $row) {
if (!in_array($row['name'], $addresses)) {
if ($row['version'] == 4) {
$addresses[] = $row['name'];
} else {
//surrounds IPV6 with '[' and ']'
$addresses[] = "[" . $row['name'] . "]";
}
}
}
//append linked domains
$iterator = $DB->request([
'SELECT' => ['d.name'],
'FROM' => Domain_Item::getTable(),
'WHERE' => [
'itemtype' => $item->getType(),
'items_id' => $item->getID()
],
'INNER JOIN' => [
Domain::getTable() . ' AS d' => [
'ON' => [
Domain_Item::getTable() => Domain::getForeignKeyField(),
'd' => 'id'
]
]
]
]);
foreach ($iterator as $row) {
$addresses[] = sprintf('%s.%s', $item_name, $row['name']);
}
}
return $addresses;
}
/**
* Get agent URLs
*
* @return array
*/
public function getAgentURLs(): array
{
$addresses = $this->guessAddresses();
$protocols = ['http', 'https'];
$port = (int)$this->fields['port'];
if ($port === 0) {
$port = self::DEFAULT_PORT;
}
$urls = [];
foreach ($protocols as $protocol) {
foreach ($addresses as $address) {
$urls[] = sprintf(
'%s://%s:%s',
$protocol,
$address,
$port
);
}
}
return $urls;
}
/**
* Send agent an HTTP request
*
* @param string $endpoint Endpoint to reach
*
* @return Response
*/
public function requestAgent($endpoint): Response
{
global $CFG_GLPI;
if (self::$found_address !== false) {
$addresses = [self::$found_address];
} else {
$addresses = $this->getAgentURLs();
}
$exception = null;
$response = null;
foreach ($addresses as $address) {
$options = [
'base_uri' => $address,
'connect_timeout' => self::TIMEOUT,
];
// add proxy string if configured in glpi
if (!empty($CFG_GLPI["proxy_name"])) {
$proxy_creds = !empty($CFG_GLPI["proxy_user"])
? $CFG_GLPI["proxy_user"] . ":" . (new GLPIKey())->decrypt($CFG_GLPI["proxy_passwd"]) . "@"
: "";
$proxy_string = "http://{$proxy_creds}" . $CFG_GLPI['proxy_name'] . ":" . $CFG_GLPI['proxy_port'];
$options['proxy'] = $proxy_string;
}
// init guzzle client with base options
$httpClient = new Guzzle_Client($options);
try {
$response = $httpClient->request('GET', $endpoint, []);
self::$found_address = $address;
break;
} catch (\GuzzleHttp\Exception\RequestException $exception) {
// got an error response, we don't need to try other addresses
break;
} catch (\Throwable $exception) {
// many addresses will be incorrect
}
}
if ($response === null && $exception !== null) {
// throw last exception on no response
throw $exception;
}
return $response;
}
/**
* Request status from agent
*
* @return array
*/
public function requestStatus()
{
// must return json
try {
$response = $this->requestAgent('status');
return $this->handleAgentResponse($response, self::ACTION_STATUS);
} catch (\GuzzleHttp\Exception\ClientException $e) {
ErrorHandler::getInstance()->handleException($e);
// not authorized
return ['answer' => __('Not allowed')];
} catch (\Throwable $e) {
// no response
return ['answer' => __('Unknown')];
}
}
/**
* Request inventory from agent
*
* @return array
*/
public function requestInventory()
{
// must return json
try {
$this->requestAgent('now');
return $this->handleAgentResponse(new Response(), self::ACTION_INVENTORY);
} catch (\GuzzleHttp\Exception\ClientException $e) {
ErrorHandler::getInstance()->handleException($e);
// not authorized
return ['answer' => __('Not allowed')];
} catch (\Throwable $e) {
// no response
return ['answer' => __('Unknown')];
}
}
/**
* Handle agent response and returns an array to be serialized as json
*
* @param Response $response Response
* @param string $request Request type (either status or now)
*
* @return array
*/
private function handleAgentResponse(Response $response, $request): array
{
$data = [];
$raw_content = (string)$response->getBody();
switch ($request) {
case self::ACTION_STATUS:
$data['answer'] = Sanitizer::encodeHtmlSpecialChars(preg_replace('/status: /', '', $raw_content));
break;
case self::ACTION_INVENTORY:
$now = new DateTime();
$data['answer'] = sprintf(
__('Requested at %s'),
$now->format(__('Y-m-d H:i:s'))
);
break;
default:
throw new \RuntimeException(sprintf('Unknown request type %s', $request));
}
return $data;
}
public static function getIcon()
{
return "ti ti-robot";
}
/**
* Cron task: clean and do other defined actions when agent not have been contacted
* the server since xx days
*
* @global object $DB, $PLUGIN_HOOKS
* @param object $task
* @return int
*
* @copyright 2010-2022 by the FusionInventory Development Team.
*/
public static function cronCleanoldagents($task = null)
{
global $DB, $PLUGIN_HOOKS;
$config = \Config::getConfigurationValues('inventory');
$retention_time = $config['stale_agents_delay'] ?? 0;
if ($retention_time <= 0) {
return 0;
}
$total = 0;
$errors = 0;
$iterator = $DB->request([
'SELECT' => ['id'],
'FROM' => self::getTable(),
'WHERE' => [
'last_contact' => ['<', new QueryExpression("date_add(now(), interval -" . $retention_time . " day)")]
]
]);
foreach ($iterator as $data) {
$agent = new self();
if (!$agent->getFromDB($data['id'])) {
$errors++;
continue;
}
$item = is_a($agent->fields['itemtype'], CommonDBTM::class, true) ? new $agent->fields['itemtype']() : null;
if (
$item !== null
&& (
$item->getFromDB($agent->fields['items_id']) === false
|| $item->fields['is_dynamic'] != 1
)
) {
$item = null;
}
$actions = importArrayFromDB($config['stale_agents_action']);
foreach ($actions as $action) {
switch ($action) {
case Conf::STALE_AGENT_ACTION_CLEAN:
//delete agents
if ($agent->delete($data)) {
$task->addVolume(1);
$total++;
} else {
$errors++;
}
break;
case Conf::STALE_AGENT_ACTION_STATUS:
if (isset($config['stale_agents_status']) && $item !== null) {
//change status of agents linked assets
$input = [
'id' => $item->fields['id'],
'states_id' => $config['stale_agents_status'],
'is_dynamic' => 1
];
if ($item->update($input)) {
$task->addVolume(1);
$total++;
} else {
$errors++;
}
}
break;
case Conf::STALE_AGENT_ACTION_TRASHBIN:
//put linked assets in trashbin
if ($item !== null) {
if ($item->delete(['id' => $item->fields['id']])) {
$task->addVolume(1);
$total++;
} else {
$errors++;
}
}
break;
}
}
$plugin_actions = $PLUGIN_HOOKS[Hooks::STALE_AGENT_CONFIG] ?? [];
/**
* @var string $plugin
* @phpstan-var array{label: string, item_action: boolean, render_callback: callable, action_callback: callable}[] $actions
*/
foreach ($plugin_actions as $plugin => $actions) {
if (is_array($actions) && Plugin::isPluginActive($plugin)) {
foreach ($actions as $action) {
if (!is_callable($action['action_callback'] ?? null)) {
trigger_error(
sprintf('Invalid plugin "%s" action callback for "%s" hook.', $plugin, Hooks::STALE_AGENT_CONFIG),
E_USER_WARNING
);
continue;
}
// Run the action
if ($action['action_callback']($agent, $config, $item)) {
$task->addVolume(1);
$total++;
} else {
$errors++;
}
}
}
}
}
return $errors > 0 ? -1 : ($total > 0 ? 1 : 0);
}
}