3465 lines
110 KiB
PHP
3465 lines
110 KiB
PHP
<?php
|
|
/**
|
|
* Observium
|
|
*
|
|
* This file is part of Observium.
|
|
*
|
|
* @package observium
|
|
* @subpackage functions
|
|
* @copyright (C) 2006-2013 Adam Armstrong, (C) 2013-2021 Observium Limited
|
|
*
|
|
*/
|
|
|
|
// Observium Includes
|
|
|
|
require_once($config['install_dir'] . "/includes/common.inc.php"); // already included in sql-config.inc.php before definitions
|
|
include_once($config['install_dir'] . "/includes/encrypt.inc.php");
|
|
include_once($config['install_dir'] . "/includes/rrdtool.inc.php");
|
|
include_once($config['install_dir'] . "/includes/influx.inc.php");
|
|
include_once($config['install_dir'] . "/includes/syslog.inc.php");
|
|
include_once($config['install_dir'] . "/includes/rewrites.inc.php");
|
|
include_once($config['install_dir'] . "/includes/templates.inc.php");
|
|
include_once($config['install_dir'] . "/includes/snmp.inc.php");
|
|
include_once($config['install_dir'] . "/includes/services.inc.php");
|
|
include_once($config['install_dir'] . "/includes/entities.inc.php");
|
|
include_once($config['install_dir'] . "/includes/geolocation.inc.php");
|
|
|
|
include_once($config['install_dir'] . "/includes/alerts.inc.php");
|
|
|
|
//if (OBSERVIUM_EDITION != 'community') // OBSERVIUM_EDITION - not defined here..
|
|
//{
|
|
$fincludes = [
|
|
'groups', 'billing', // Not exist in community edition
|
|
'distributed', // Not exist in community edition, distributed poller functions
|
|
'community', // community edition specific
|
|
'custom', // custom functions, i.e. short_hostname
|
|
];
|
|
foreach ($fincludes as $entry) {
|
|
$file = $config['install_dir'] . '/includes/' . $entry . '.inc.php';
|
|
if (is_file($file)) { include_once($file); }
|
|
}
|
|
unset($fincludes);
|
|
|
|
// DOCME needs phpdoc block
|
|
// Send to AMQP via UDP-based python proxy.
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/common.inc.php
|
|
function messagebus_send($message)
|
|
{
|
|
global $config;
|
|
|
|
if ($socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP))
|
|
{
|
|
$message = json_encode($message);
|
|
print_debug('Sending JSON via AMQP: ' . $message);
|
|
socket_sendto($socket, $message, strlen($message), 0, $config['amqp']['proxy']['host'], $config['amqp']['proxy']['port']);
|
|
socket_close($socket);
|
|
return TRUE;
|
|
} else {
|
|
print_error("Failed to create UDP socket towards AMQP proxy.");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
function get_var_true($var, $true = NULL) {
|
|
return $var === '1' || $var === 1 ||
|
|
$var === 'on' || $var === 'yes' ||
|
|
$var === TRUE ||
|
|
// allow extra param for true, ie confirm
|
|
(!empty($true) && $var === $true);
|
|
}
|
|
|
|
function get_var_false($var, $false = NULL) {
|
|
return $var === '0' || $var === 0 ||
|
|
$var === 'off' || $var === 'no' ||
|
|
$var === FALSE || $var === NULL ||
|
|
// allow extra param for false, ie confirm
|
|
(!empty($false) && $var === $false);
|
|
}
|
|
|
|
/**
|
|
* Transforms a given string using an array of different transformations, in order.
|
|
*
|
|
* @param string $string Original string to be transformed
|
|
* @param array $transformations Transformation array
|
|
*
|
|
* Available transformations:
|
|
* 'action' => 'prepend' Prepend static 'string'
|
|
* 'action' => 'append' Append static 'string'
|
|
* 'action' => 'trim' Trim 'characters' from both sides of the string
|
|
* 'action' => 'ltrim' Trim 'characters' from the left of the string
|
|
* 'action' => 'rtrim' Trim 'characters' from the right of the string
|
|
* 'action' => 'upper' Call strtoupper()
|
|
* 'action' => 'lower' Call strtolower()
|
|
* 'action' => 'nicecase' Call nicecase()
|
|
* 'action' => 'replace' Case-sensitively replace 'from' string by 'to'; 'from' can be an array of strings
|
|
* 'action' => 'ireplace' Case-insensitively replace 'from' string by 'to'; 'from' can be an array of strings
|
|
* 'action' => 'regex_replace'/'preg_replace' Replace 'from' with 'to'.
|
|
* 'action' => 'timeticks' Convert standart Timeticks to seconds
|
|
* 'action' => 'age'/'uptime' Convert any human readable age/uptime to seconds (also support timeticks)
|
|
* 'action' => 'explode' Explode string by 'delimiter' (default ' ') and fetch array element (first (default), second, last or number)
|
|
* 'action' => 'map' Map string by key -> value, where key-value pairs passed by array 'map'
|
|
* 'action' => 'map_match' Map string by pattern -> value, where pattern-value pairs passed by array 'map'
|
|
* 'action' => 'units' Convert byte/bit string with units to bytes/bits
|
|
* 'action' => 'asdot' Call bgp_asdot_to_asplain()
|
|
* 'action' => 'entity_name' Call rewrite_entity_name()
|
|
* 'action' => 'urlencode' Call rawurlencode()
|
|
* 'action' => 'urldecode' Call rawurldecode()
|
|
* 'action' => 'escape' Call escape_html()
|
|
*
|
|
* @return string|array|null Transformed string
|
|
*/
|
|
function string_transform($string, $transformations) {
|
|
if (!is_array($transformations) || empty($transformations)) {
|
|
// Bail out if no transformations are given
|
|
return $string;
|
|
}
|
|
|
|
// Simplify single action definition with less array nesting
|
|
if (isset($transformations['action'])) {
|
|
$transformations = array($transformations);
|
|
}
|
|
|
|
foreach ($transformations as $transformation) {
|
|
$msg = " String '$string' transformed by action [".$transformation['action']."] to: ";
|
|
switch ($transformation['action']) {
|
|
case 'prepend':
|
|
$string = $transformation['string'] . $string;
|
|
break;
|
|
|
|
case 'append':
|
|
$string .= $transformation['string'];
|
|
break;
|
|
|
|
case 'strtoupper':
|
|
case 'upper':
|
|
$string = strtoupper($string);
|
|
break;
|
|
|
|
case 'strtolower':
|
|
case 'lower':
|
|
$string = strtolower($string);
|
|
break;
|
|
|
|
case 'nicecase':
|
|
$string = nicecase($string);
|
|
break;
|
|
|
|
case 'trim':
|
|
case 'ltrim':
|
|
case 'rtrim':
|
|
if (isset($transformation['chars']) && !isset($transformation['characters'])) {
|
|
// Just simple for brain memory key
|
|
$transformation['characters'] = $transformation['chars'];
|
|
}
|
|
if (!isset($transformation['characters'])) {
|
|
$transformation['characters'] = " \t\n\r\0\x0B";
|
|
}
|
|
|
|
if ($transformation['action'] === 'rtrim') {
|
|
$string = rtrim($string, $transformation['characters']);
|
|
} elseif ($transformation['action'] === 'ltrim') {
|
|
$string = ltrim($string, $transformation['characters']);
|
|
} else {
|
|
$string = trim($string, $transformation['characters']);
|
|
}
|
|
break;
|
|
|
|
case 'replace':
|
|
$string = str_replace($transformation['from'], $transformation['to'], $string);
|
|
break;
|
|
|
|
case 'ireplace':
|
|
$string = str_ireplace($transformation['from'], $transformation['to'], $string);
|
|
break;
|
|
|
|
case 'regex_replace':
|
|
case 'preg_replace':
|
|
$to_string = preg_replace($transformation['from'], $transformation['to'], $string);
|
|
$preg_last_error = preg_last_error();
|
|
//print_vars(array_flip(get_defined_constants(true)['pcre'])[$preg_last_error]);
|
|
if ($preg_last_error === PREG_INTERNAL_ERROR ||
|
|
(PHP_VERSION_ID < 70000 && $preg_last_error === PREG_NO_ERROR && $to_string === NULL)) { // php5.6 return NULL instead error
|
|
// Dear Saint Patrick, we passed "from" without delimiter
|
|
$transformation['from'] = !str_contains($transformation['from'], '/') ? '/' . $transformation['from'] . '/' : '!' . $transformation['from'] . '!';
|
|
$to_string = preg_replace($transformation['from'], $transformation['to'], $string);
|
|
$preg_last_error = preg_last_error();
|
|
}
|
|
if ($preg_last_error === PREG_NO_ERROR) {
|
|
$string = $to_string;
|
|
}
|
|
break;
|
|
|
|
case 'regex_match':
|
|
case 'preg_match':
|
|
if (preg_match($transformation['from'], $string, $matches)) {
|
|
$string = array_tag_replace($matches, $transformation['to']);
|
|
}
|
|
break;
|
|
|
|
case 'map':
|
|
// Map string by key -> value
|
|
if (is_array($transformation['map']) && isset($transformation['map'][$string])) {
|
|
$string = $transformation['map'][$string];
|
|
}
|
|
break;
|
|
|
|
case 'map_match':
|
|
if (isset($transformation['map_match'])) {
|
|
$transformation['map'] = $transformation['map_match'];
|
|
}
|
|
// Map string by pattern -> value
|
|
if (is_array($transformation['map'])) {
|
|
foreach ($transformation['map'] as $pattern => $to_string) {
|
|
if (preg_match($pattern, $string)) {
|
|
$string = $to_string;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'timeticks':
|
|
// Timeticks: (2542831) 7:03:48.31
|
|
$string = timeticks_to_sec($string);
|
|
break;
|
|
|
|
case 'age':
|
|
case 'uptime':
|
|
// Any human readable age/uptime to seconds (also support timeticks)
|
|
$string = uptime_to_seconds($string);
|
|
break;
|
|
|
|
case 'asdot':
|
|
// BGP 32bit ASN from asdot to plain
|
|
$string = bgp_asdot_to_asplain($string);
|
|
break;
|
|
|
|
case 'ip_uncompress':
|
|
case 'ip-uncompress':
|
|
// IPv4/6 Uncompress
|
|
$string = ip_uncompress($string);
|
|
break;
|
|
|
|
case 'ip_compress':
|
|
case 'ip-compress':
|
|
// IPv4/6 Compress
|
|
$string = ip_compress($string);
|
|
break;
|
|
|
|
case 'mac':
|
|
// MAC address formatting
|
|
$string = format_mac($string);
|
|
break;
|
|
|
|
case 'units':
|
|
// 200kbps -> 200000, 50M -> 52428800
|
|
$string = unit_string_to_numeric($string);
|
|
break;
|
|
|
|
case 'entity_name':
|
|
$string = rewrite_entity_name($string);
|
|
break;
|
|
|
|
case 'explode':
|
|
case 'split':
|
|
// String delimiter (default is single space " ")
|
|
if (isset($transformation['delimiter']) && strlen($transformation['delimiter'])) {
|
|
$delimiter = $transformation['delimiter'];
|
|
} else {
|
|
$delimiter = ' ';
|
|
}
|
|
$array = explode($delimiter, $string);
|
|
// Get array index (default is first)
|
|
if (!isset($transformation['index'])) {
|
|
$transformation['index'] = 'first';
|
|
}
|
|
switch ((string)$transformation['index']) {
|
|
case 'all':
|
|
case 'array':
|
|
// return array instead single string
|
|
$string = $array;
|
|
break;
|
|
case 'first':
|
|
case 'begin':
|
|
$string = array_shift($array);
|
|
break;
|
|
case 'second':
|
|
case 'secondary':
|
|
case 'two':
|
|
array_shift($array);
|
|
$string = array_shift($array);
|
|
break;
|
|
case 'last':
|
|
case 'end':
|
|
$string = array_pop($array);
|
|
break;
|
|
default:
|
|
if (strlen($array[$transformation['index']])) {
|
|
$string = $array[$transformation['index']];
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'urlencode':
|
|
case 'rawurlencode':
|
|
$string = rawurlencode($string);
|
|
break;
|
|
|
|
case 'urldecode':
|
|
case 'rawurldecode':
|
|
$string = rawurldecode($string);
|
|
break;
|
|
|
|
case 'escape':
|
|
$string = escape_html($string);
|
|
break;
|
|
|
|
default:
|
|
// FIXME echo HALP, unknown transformation!
|
|
break;
|
|
}
|
|
print_debug($msg . "'$string'");
|
|
}
|
|
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Sorts an $array by a passed field.
|
|
*
|
|
* @param array $array
|
|
* @param string|int $on
|
|
* @param string $order
|
|
*
|
|
* @return array
|
|
*/
|
|
function array_sort($array, $on, $order = 'SORT_ASC') {
|
|
$new_array = array();
|
|
$sortable_array = array();
|
|
|
|
if (safe_count($array) > 0) {
|
|
foreach ($array as $k => $v) {
|
|
if (is_array($v)) {
|
|
foreach ($v as $k2 => $v2) {
|
|
if ($k2 == $on) {
|
|
$sortable_array[$k] = $v2;
|
|
}
|
|
}
|
|
} else {
|
|
$sortable_array[$k] = $v;
|
|
}
|
|
}
|
|
|
|
switch ($order) {
|
|
case 'SORT_ASC':
|
|
asort($sortable_array);
|
|
break;
|
|
case 'SORT_DESC':
|
|
arsort($sortable_array);
|
|
break;
|
|
}
|
|
|
|
foreach ($sortable_array as $k => $v) {
|
|
$new_array[$k] = $array[$k];
|
|
}
|
|
}
|
|
|
|
return $new_array;
|
|
}
|
|
|
|
/**
|
|
* Another sort array function.
|
|
* http://php.net/manual/en/function.array-multisort.php#100534
|
|
*
|
|
* @return array
|
|
*/
|
|
function array_sort_by() {
|
|
$args = func_get_args();
|
|
$data = array_shift($args);
|
|
foreach ($args as $n => $field) {
|
|
if (is_string($field)) {
|
|
$tmp = array();
|
|
foreach ($data as $key => $row) {
|
|
$tmp[$key] = $row[$field];
|
|
}
|
|
$args[$n] = $tmp;
|
|
}
|
|
}
|
|
$args[] = &$data;
|
|
array_multisort(...$args);
|
|
return array_pop($args);
|
|
}
|
|
|
|
/** hex2float
|
|
* (Convert 8 digit hexadecimal value to float (single-precision 32bits)
|
|
* Accepts 8 digit hexadecimal values in a string
|
|
* @usage:
|
|
* hex2float("429241f0"); returns -> "73.128784179688"
|
|
* @param numeric $number
|
|
* @return float
|
|
**/
|
|
function hex2float($number) {
|
|
$binfinal = sprintf("%032b", hexdec($number));
|
|
$sign = $binfinal[0];
|
|
$exp = substr($binfinal, 1, 8);
|
|
$mantissa = "1".substr($binfinal, 9);
|
|
$mantissa = str_split($mantissa);
|
|
$exp = bindec($exp) - 127;
|
|
$significand = 0;
|
|
for ($i = 0; $i < 24; $i++) {
|
|
$significand += (1 / (2 ** $i)) * $mantissa[$i];
|
|
}
|
|
|
|
return $significand * (2 ** $exp) * ($sign * -2 + 1);
|
|
}
|
|
|
|
// A function to process numerical values according to a $scale value
|
|
// Functionised to allow us to have "magic" scales which do special things
|
|
// Initially used for dec>hex>float values used by accuview
|
|
function scale_value($value, $scale) {
|
|
|
|
// Scale when not zero (0, 0.0, '0', '0.0') or one (1, 1.0, '1', '1.0')
|
|
if ($scale != 0 && $scale != 1 &&
|
|
is_numeric($scale) && is_numeric($value)) {
|
|
return $value * $scale;
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Given two arrays, the function diff will return an array of the changes.
|
|
*
|
|
* @param array $old First array
|
|
* @param array $new Second array
|
|
* @return array Array with diffs and same elements
|
|
*/
|
|
function diff($old, $new)
|
|
{
|
|
|
|
$matrix = array();
|
|
$maxlen = 0;
|
|
foreach ($old as $oindex => $ovalue)
|
|
{
|
|
$nkeys = array_keys($new, $ovalue);
|
|
foreach ($nkeys as $nindex)
|
|
{
|
|
$matrix[$oindex][$nindex] = isset($matrix[$oindex - 1][$nindex - 1]) ? $matrix[$oindex - 1][$nindex - 1] + 1 : 1;
|
|
if ($matrix[$oindex][$nindex] > $maxlen)
|
|
{
|
|
$maxlen = $matrix[$oindex][$nindex];
|
|
$omax = $oindex + 1 - $maxlen;
|
|
$nmax = $nindex + 1 - $maxlen;
|
|
}
|
|
}
|
|
}
|
|
if ($maxlen == 0)
|
|
{
|
|
return array(array('d'=>$old, 'i'=>$new));
|
|
}
|
|
|
|
return array_merge(
|
|
diff(array_slice($old, 0, $omax), array_slice($new, 0, $nmax)),
|
|
array_slice($new, $nmax, $maxlen),
|
|
diff(array_slice($old, $omax + $maxlen), array_slice($new, $nmax + $maxlen)));
|
|
}
|
|
|
|
/**
|
|
* Return similar part of two strings (or empty)
|
|
*
|
|
* @param string $old First string
|
|
* @param string $new Second string
|
|
* @return string Similar part of two strings
|
|
*/
|
|
function str_similar($old, $new)
|
|
{
|
|
|
|
$ret = array();
|
|
$diff = diff(preg_split("/[\s]+/u", $old), preg_split("/[\s]+/u", $new));
|
|
foreach ($diff as $k)
|
|
{
|
|
if (!is_array($k))
|
|
{
|
|
$ret[] = $k;
|
|
}
|
|
}
|
|
return implode(' ', $ret);
|
|
}
|
|
|
|
/**
|
|
* Return sets of all similar strings from passed array.
|
|
*
|
|
* @param array $array Array with strings for find similar
|
|
* @param boolean $return_flip If TRUE return pairs String -> Similar part,
|
|
* instead vice versa by default return set of arrays Similar part -> Strings
|
|
* @param integer $similarity Percent of similarity compared string, mostly common is 90%
|
|
* @return array Array with sets of similar strings
|
|
*/
|
|
function find_similar($array, $return_flip = FALSE, $similarity = 89) {
|
|
if (!is_array($array)) { return []; }
|
|
|
|
natsort($array);
|
|
//var_dump($array);
|
|
$array2 = $array;
|
|
$same_array = array();
|
|
$same_array_flip = array();
|
|
|
|
// $i = 0; // DEBUG
|
|
foreach ($array as $k => $old)
|
|
{
|
|
foreach ($array2 as $k2 => $new)
|
|
{
|
|
if ($k === $k2) { continue; } // Skip same array elements
|
|
|
|
// Detect string similarity
|
|
similar_text($old, $new, $perc);
|
|
|
|
// $i++; echo "$i ($perc %): '$old' <> '$new' (".str_similar($old, $new).")\n"; // DEBUG
|
|
|
|
if ($perc > $similarity)
|
|
{
|
|
if (isset($same_array_flip[$old]))
|
|
{
|
|
// This is found already similar string by previous round(s)
|
|
$same = $same_array_flip[$old];
|
|
$same_array_flip[$new] = $same;
|
|
}
|
|
else if (isset($same_array_flip[$new]))
|
|
{
|
|
// This is found already similar string by previous round(s)
|
|
$same = $same_array_flip[$new];
|
|
$same_array_flip[$old] = $same;
|
|
} else {
|
|
// New similarity, get similar string part
|
|
$same = str_similar($old, $new);
|
|
|
|
// Return array pairs as:
|
|
// String -> Similar part
|
|
$same_array_flip[$old] = $same;
|
|
$same_array_flip[$new] = $same;
|
|
}
|
|
|
|
// Return array elements as:
|
|
// Similar part -> Strings
|
|
if (!isset($same_array[$same]) || !in_array($old, $same_array[$same])) {
|
|
$same_array[$same][] = $old;
|
|
}
|
|
$same_array[$same][] = $new;
|
|
|
|
unset($array2[$k]); // Remove array element if similar found
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (!isset($same_array_flip[$old]))
|
|
{
|
|
// Similarity not found, just add as single string
|
|
$same_array_flip[$old] = $old;
|
|
$same_array[$old][] = $old;
|
|
}
|
|
}
|
|
|
|
if ($return_flip)
|
|
{
|
|
// Return array pairs as:
|
|
// String -> Similar part
|
|
return $same_array_flip;
|
|
} else {
|
|
// Return array elements as:
|
|
// Similar part -> Strings
|
|
return $same_array;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Includes filename with global config variable
|
|
*
|
|
* @param string $filename Filename for include
|
|
*
|
|
* @return boolean Status of include
|
|
*/
|
|
function include_wrapper($filename)
|
|
{
|
|
global $config;
|
|
|
|
$status = include($filename);
|
|
|
|
return (boolean)$status;
|
|
}
|
|
|
|
/**
|
|
* Compares Numeric OID with $needle. Return TRUE if match.
|
|
*
|
|
* @param string $oid Numeric OID for compare
|
|
* @param string|array $needle Compare with this
|
|
* @return bool TRUE if match, otherwise FALSE
|
|
*/
|
|
function match_oid_num($oid, $needle)
|
|
{
|
|
if (is_array($needle)) {
|
|
foreach ($needle as $entry) {
|
|
//print_debug("OID $oid compare to $entry = ");
|
|
if (match_oid_num($oid, $entry)) {
|
|
//print_debug("match\n");
|
|
return TRUE;
|
|
}
|
|
//print_debug("NOT match\n");
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
# validate OID
|
|
$oid = trim($oid);
|
|
if (!preg_match('/^(?:(?<start>\.?)(?:\d+(?:\.\d+)+)|\.\d+)$/', $oid, $matches)) {
|
|
print_debug("Incorrect OID passed to match_oid_num('$oid', '$needle').");
|
|
return FALSE;
|
|
}
|
|
// append leading point if missing (1.3.6 -> .1.3.6)
|
|
if (isset($matches['start']) && $matches['start'] === '') {
|
|
$oid = '.'.$oid;
|
|
}
|
|
|
|
# validate needle (in other cases use regex)
|
|
$needle = trim($needle);
|
|
if (!preg_match('/^(?:(?<start>\.?)(?:\d+(?:\.\d+)+)|\.\d+)(?<end>\.)?$/', $needle, $matches)) {
|
|
|
|
// Try simple regex matches, ie .1.*.1., .1.3.(4|5|9), .1.3.4[56].*
|
|
if (preg_match('/^(?<start>\.?)\d+(?:\.(\d+|[\d\[\]\-]+|[\d\(\)\|]+|[\d\*]+))*(?<end>\.)?$/', $needle, $matches)) {
|
|
// append leading point if missing (1.3.6 -> .1.3.6)
|
|
if (isset($matches['start']) && $matches['start'] === '') {
|
|
$needle = '.'.$needle;
|
|
}
|
|
|
|
$needle_pattern = str_replace([ '.', '*' ], [ '\.', '.*?' ], $needle);
|
|
if (isset($matches['end']) && $matches['end'] === '.') {
|
|
$needle_pattern .= '\d+(\.\d+)*';
|
|
} else {
|
|
$needle_pattern .= '(\.\d+)*';
|
|
}
|
|
|
|
//print_message("/^$needle_pattern$/");
|
|
return (bool)preg_match('/^' . $needle_pattern . '$/', $oid);
|
|
}
|
|
|
|
print_debug("Incorrect Needle passed to match_oid_num('$oid', '$needle').");
|
|
return FALSE;
|
|
}
|
|
// append leading point if missing (1.3.6 -> .1.3.6)
|
|
if (isset($matches['start']) && $matches['start'] === '') {
|
|
$needle = '.'.$needle;
|
|
}
|
|
|
|
// Use wildcard compare if sysObjectID definition have '.' at end, ie:
|
|
// .1.3.6.1.4.1.2011.1.
|
|
if (isset($matches['end']) && $matches['end'] === '.') {
|
|
return str_starts($oid, $needle);
|
|
}
|
|
|
|
// Use exact match sysObjectID definition or wildcard compare with '.' at end, ie:
|
|
// .1.3.6.1.4.1.2011.2.27
|
|
return $oid === $needle || str_starts($oid, $needle.'.');
|
|
}
|
|
|
|
/**
|
|
* Compares complex sysObjectID/sysDescr and any other MIB::Oid combination with definition.
|
|
* Can check some device params (os, os_group, vendor, hardware, version)
|
|
* Return TRUE if match.
|
|
*
|
|
* @param array $device Device array
|
|
* @param array $needle Compare with this definition array
|
|
* @param string $sysObjectID Walked sysObjectID from device
|
|
* @param string $sysDescr Walked sysDescr from device
|
|
*
|
|
* @return boolean TRUE if match, otherwise FALSE
|
|
*/
|
|
function match_discovery_oids($device, $needle, $sysObjectID = NULL, $sysDescr = NULL)
|
|
{
|
|
global $table_rows;
|
|
|
|
// Count required conditions
|
|
$needle_oids = array_keys($needle);
|
|
$needle_count = count($needle_oids);
|
|
|
|
// Match sysObjectID and sysDescr always first!
|
|
$needle_oids_order = array_merge(array('sysObjectID', 'sysDescr'), $needle_oids);
|
|
$needle_oids_order = array_unique($needle_oids_order);
|
|
$needle_oids_order = array_intersect($needle_oids_order, $needle_oids);
|
|
|
|
$matched_defs = [];
|
|
|
|
// By first detect device os and os_group params match with "or" condition
|
|
// Note, when os/os_group not defined, $os_match also TRUE
|
|
$os_match = match_discovery_os_group($device, $needle, $os_params, $matched_defs);
|
|
|
|
// Check if any of device param matched
|
|
if (count($os_params))
|
|
{
|
|
if ($os_match)
|
|
{
|
|
// Remove device params from later Oids checks
|
|
$needle_oids_order = array_diff($needle_oids_order, $os_params);
|
|
// Reduce needle count by device params count
|
|
$needle_count -= count($os_params);
|
|
} else {
|
|
// No any device param matched, stop all other checks
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Now do Oids matching
|
|
foreach ($needle_oids_order as $oid)
|
|
{
|
|
$match = FALSE;
|
|
switch ($oid)
|
|
{
|
|
case 'type':
|
|
foreach ((array)$needle[$oid] as $def)
|
|
{
|
|
if ($device[$oid] == $def)
|
|
{
|
|
$matched_defs[] = [ 'device ' . $oid, $def, $device[$oid] ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'hardware':
|
|
case 'version':
|
|
case 'vendor':
|
|
case 'distro':
|
|
case 'distro_ver':
|
|
case 'kernel':
|
|
case 'arch':
|
|
foreach ((array)$needle[$oid] as $def)
|
|
{
|
|
if (preg_match($def, $device[$oid]))
|
|
{
|
|
$matched_defs[] = [ 'device ' . $oid, $def, $device[$oid] ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'sysObjectID':
|
|
foreach ((array)$needle[$oid] as $def)
|
|
{
|
|
//var_dump($def);
|
|
//var_dump($sysObjectID);
|
|
//var_dump(match_oid_num($sysObjectID, $def));
|
|
if (match_oid_num($sysObjectID, $def))
|
|
{
|
|
$matched_defs[] = [ $oid, $def, $sysObjectID ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'sysDescr':
|
|
case 'sysName':
|
|
// Common SNMPv2-MIB Oids
|
|
if ($oid == 'sysDescr')
|
|
{
|
|
$value = $sysDescr;
|
|
$value_ok = TRUE;
|
|
} else {
|
|
$value = snmp_fix_string(snmp_cache_oid($device, $oid . '.0', 'SNMPv2-MIB'));
|
|
$value_ok = $GLOBALS['snmp_status'] || $GLOBALS['snmp_error_code'] === OBS_SNMP_ERROR_EMPTY_RESPONSE; // Allow empty response
|
|
}
|
|
|
|
foreach ((array)$needle[$oid] as $def)
|
|
{
|
|
//print_vars($def);
|
|
//print_vars($value);
|
|
//print_vars(preg_match($def, $value));
|
|
if ($value_ok && preg_match($def, $value))
|
|
{
|
|
$matched_defs[] = [ $oid, $def, $value ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'package':
|
|
case 'hrSWInstalledName':
|
|
case 'HOST-RESOURCES-MIB::hrSWInstalledName':
|
|
$defs = (array)$needle[$oid];
|
|
$oid = 'hrSWInstalledName';
|
|
foreach (snmp_cache_table($device, $oid, [], 'HOST-RESOURCES-MIB') as $entry) {
|
|
$value = $entry[$oid];
|
|
foreach ($defs as $def) {
|
|
if (preg_match($def, $value)) {
|
|
$matched_defs[] = [ $oid, $def, $value ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// All other oids,
|
|
// fetch by first, than compare with pattern
|
|
$value = snmp_fix_string(snmp_cache_oid($device, $oid));
|
|
$value_ok = $GLOBALS['snmp_status'] || $GLOBALS['snmp_error_code'] === OBS_SNMP_ERROR_EMPTY_RESPONSE; // Allow empty response
|
|
|
|
foreach ((array)$needle[$oid] as $def)
|
|
{
|
|
// print_vars($def);
|
|
// print_vars($value);
|
|
// print_vars(preg_match($def, $value));
|
|
if ($value_ok && preg_match($def, $value))
|
|
{
|
|
$matched_defs[] = [ $oid, $def, $value ];
|
|
$needle_count--;
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Stop all other checks, last oid not match with any..
|
|
if (!$match) { return FALSE; }
|
|
}
|
|
|
|
// Match only if all oids found and matched
|
|
$match = $needle_count === 0;
|
|
|
|
// Store detailed info
|
|
if ($match)
|
|
{
|
|
foreach ($matched_defs as $entry)
|
|
{
|
|
$table_rows[] = $entry;
|
|
}
|
|
}
|
|
|
|
return $match;
|
|
}
|
|
|
|
/**
|
|
* Compares base device os/os_group params with definition by OR condition.
|
|
* Return TRUE if match.
|
|
* Note, if os params not exist in definition, return TRUE!
|
|
*
|
|
* @param array $device Device array
|
|
* @param array $needle Compare with this definition array
|
|
* @param array $os_params (optional) Callback list of defined os params
|
|
* @param array $match (optional) Callback array with matched param/value
|
|
*
|
|
* @return boolean TRUE if match, otherwise FALSE
|
|
*/
|
|
function match_discovery_os_group($device, $needle, &$os_params = [], &$match = [])
|
|
{
|
|
$needle_params = ['os', 'os_group']; // list required match os params
|
|
|
|
$needle_keys = array_keys($needle);
|
|
$os_params = array_intersect($needle_keys, $needle_params);
|
|
|
|
// If os params not defined, just return TRUE
|
|
if (empty($os_params))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
foreach ($needle_params as $param)
|
|
{
|
|
if (!in_array($param, $needle_keys)) { continue; }
|
|
|
|
foreach ((array)$needle[$param] as $def)
|
|
{
|
|
if ($device[$param] == $def)
|
|
{
|
|
$match[] = [ 'device ' . $param, $def, $device[$param] ];
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
function cache_discovery_definitions()
|
|
{
|
|
global $config, $cache;
|
|
|
|
// Cache/organize discovery definitions
|
|
if (!isset($cache['discovery_os']))
|
|
{
|
|
foreach (array_keys($config['os']) as $cos)
|
|
{
|
|
// Generate full array with sysObjectID from definitions
|
|
foreach ($config['os'][$cos]['sysObjectID'] as $oid)
|
|
{
|
|
$oid = trim($oid);
|
|
if ($oid[0] != '.') { $oid = '.' . $oid; } // Add first point if not already added
|
|
|
|
if (isset($cache['discovery_os']['sysObjectID'][$oid]) && strpos($cache['discovery_os']['sysObjectID'][$oid], 'test_') !== 0)
|
|
{
|
|
print_error("Duplicate sysObjectID '$oid' in definitions for OSes: ".$cache['discovery_os']['sysObjectID'][$oid]." and $cos!");
|
|
continue;
|
|
}
|
|
// sysObjectID -> os
|
|
$cache['discovery_os']['sysObjectID'][$oid] = $cos;
|
|
$cache['discovery_os']['sysObjectID_cos'][$oid][] = $cos; // Collect how many same sysObjectID known by definitions
|
|
//$sysObjectID_def[$oid] = $cos;
|
|
}
|
|
|
|
// Generate full array with sysDescr from definitions
|
|
if (isset($config['os'][$cos]['sysDescr']))
|
|
{
|
|
// os -> sysDescr (list)
|
|
$cache['discovery_os']['sysDescr'][$cos] = $config['os'][$cos]['sysDescr'];
|
|
}
|
|
|
|
// Complex match with combinations of sysDescr / sysObjectID and any other
|
|
foreach ($config['os'][$cos]['discovery'] as $discovery)
|
|
{
|
|
$oids = array_keys($discovery);
|
|
if (!in_array('sysObjectID', $oids))
|
|
{
|
|
// Check if definition have additional "networked" OIDs (without sysObjectID checks)
|
|
$def_name = 'discovery_network';
|
|
} else {
|
|
$def_name = 'discovery';
|
|
}
|
|
|
|
if (count($oids) === 1)
|
|
{
|
|
// single oids convert to old array format
|
|
switch (array_shift($oids))
|
|
{
|
|
case 'sysObjectID':
|
|
foreach ((array)$discovery['sysObjectID'] as $oid)
|
|
{
|
|
$oid = trim($oid);
|
|
if ($oid[0] != '.') { $oid = '.' . $oid; } // Add first point if not already added
|
|
|
|
if (isset($cache['discovery_os']['sysObjectID'][$oid]) && strpos($cache['discovery_os']['sysObjectID'][$oid], 'test_') !== 0)
|
|
{
|
|
print_error("Duplicate sysObjectID '$oid' in definitions for OSes: ".$cache['discovery_os']['sysObjectID'][$oid]." and $cos!");
|
|
continue;
|
|
}
|
|
// sysObjectID -> os
|
|
$cache['discovery_os']['sysObjectID'][$oid] = $cos;
|
|
$cache['discovery_os']['sysObjectID_cos'][$oid][] = $cos; // Collect how many same sysObjectID known by definitions
|
|
}
|
|
break;
|
|
case 'sysDescr':
|
|
// os -> sysDescr (list)
|
|
if (isset($cache['discovery_os']['sysDescr'][$cos]))
|
|
{
|
|
$cache['discovery_os']['sysDescr'][$cos] = array_unique(array_merge((array)$cache['discovery_os']['sysDescr'][$cos], (array)$discovery['sysDescr']));
|
|
} else {
|
|
$cache['discovery_os']['sysDescr'][$cos] = (array)$discovery['sysDescr'];
|
|
}
|
|
break;
|
|
case 'file':
|
|
$cache['discovery_os']['file'][$cos] = $discovery['file'];
|
|
break;
|
|
default:
|
|
// All other leave as is
|
|
$cache['discovery_os'][$def_name][$cos][] = $discovery;
|
|
}
|
|
} else {
|
|
if ($def_name == 'discovery') // This have sysObjectID
|
|
{
|
|
$new_oids = array();
|
|
foreach ((array)$discovery['sysObjectID'] as $oid)
|
|
{
|
|
$oid = trim($oid);
|
|
if ($oid[0] != '.') { $oid = '.' . $oid; } // Add first point if not already added
|
|
$new_oids[] = $oid;
|
|
$cache['discovery_os']['sysObjectID_cos'][$oid][] = $cos; // Collect how many same sysObjectID known by definitions
|
|
}
|
|
$discovery['sysObjectID'] = $new_oids; // Override sysObjectIDs with normalized
|
|
}
|
|
// Leave complex definitions as is
|
|
$cache['discovery_os'][$def_name][$cos][] = $discovery;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Currently too hard for detect if same sysObjectID used in multiple OSes, and how get best OS
|
|
// Best os should match by max params
|
|
// Remove all single sysObjectIDs count
|
|
foreach ($cache['discovery_os']['sysObjectID_cos'] as $oid => $oses)
|
|
{
|
|
$oses = array_unique($oses);
|
|
if (count($oses) < 2)
|
|
{
|
|
// Single sysObjectID, no additional matches needed
|
|
unset($cache['discovery_os']['sysObjectID_cos'][$oid]);
|
|
} else {
|
|
/*
|
|
if (isset($cache['discovery_os']['sysObjectID'][$oid]))
|
|
{
|
|
// Move simple check to complex
|
|
$cos = $cache['discovery_os']['sysObjectID'][$oid];
|
|
///$cache['discovery_os']['discovery'][$cos][] = array('sysObjectID' => $oid);
|
|
//unset($cache['discovery_os']['sysObjectID'][$oid]);
|
|
}
|
|
*/
|
|
$cache['discovery_os']['sysObjectID_cos'][$oid] = $oses;
|
|
}
|
|
}
|
|
|
|
// Resort sysObjectID array by oids with from high to low order!
|
|
if (isset($cache['discovery_os']['sysObjectID'])) {
|
|
//krsort($cache['discovery_os']['sysObjectID']);
|
|
uksort($cache['discovery_os']['sysObjectID'], 'compare_numeric_oids_reverse');
|
|
}
|
|
|
|
//print_vars($cache['discovery_os']['sysObjectID_cos']);
|
|
//print_vars($cache['discovery_os']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compare two numeric oids and return -1, 0, 1
|
|
* ie: .1.2.1. vs 1.2.2
|
|
*/
|
|
function compare_numeric_oids($oid1, $oid2) {
|
|
$oid1_array = explode('.', ltrim($oid1, '.'));
|
|
$oid2_array = explode('.', ltrim($oid2, '.'));
|
|
|
|
$count1 = count($oid1_array);
|
|
$count2 = count($oid2_array);
|
|
|
|
for ($i = 0; $i <= min($count1, $count2) - 1; $i++)
|
|
{
|
|
$int1 = (int)$oid1_array[$i];
|
|
$int2 = (int)$oid2_array[$i];
|
|
if ($int1 > $int2) { return 1; }
|
|
if ($int1 < $int2) { return -1; }
|
|
}
|
|
if ($count1 > $count2) { return 1; }
|
|
if ($count1 < $count2) { return -1; }
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Compare two numeric oids and return -1, 0, 1
|
|
* here reverse order
|
|
* ie: .1.2.1. vs 1.2.2
|
|
*/
|
|
function compare_numeric_oids_reverse($oid1, $oid2) {
|
|
return compare_numeric_oids($oid2, $oid1);
|
|
}
|
|
|
|
function set_value_param_definition($param, $def, $entry)
|
|
{
|
|
$value = NULL;
|
|
$oid = $def['oid_' . $param];
|
|
if (isset($entry[$oid]))
|
|
{
|
|
$value = $entry[$oid];
|
|
}
|
|
elseif (isset($def[$param]))
|
|
{
|
|
$value = array_tag_replace($entry, $def[$param]);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
// Rename a device
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
function renamehost($id, $new, $source = 'console', $options = array()) {
|
|
global $config;
|
|
|
|
$new = strtolower(trim($new));
|
|
|
|
// Test if new host exists in database
|
|
//if (dbFetchCell('SELECT COUNT(`device_id`) FROM `devices` WHERE `hostname` = ?', array($new)) == 0)
|
|
if (!dbExist('devices', '`hostname` = ?', array($new))) {
|
|
$flags = OBS_DNS_ALL;
|
|
$transport = strtolower(dbFetchCell("SELECT `snmp_transport` FROM `devices` WHERE `device_id` = ?", array($id)));
|
|
|
|
// Try detect if hostname is IP
|
|
switch (get_ip_version($new)) {
|
|
case 6:
|
|
case 4:
|
|
if ($config['require_hostname']) {
|
|
print_error("Hostname should be a valid resolvable FQDN name. Or set config option \$config['require_hostname'] as FALSE.");
|
|
return FALSE;
|
|
}
|
|
$ip = ip_compress($new); // Always use compressed IPv6 name
|
|
break;
|
|
default:
|
|
if ($transport === 'udp6' || $transport === 'tcp6') { // Exclude IPv4 if used transport 'udp6' or 'tcp6'
|
|
$flags ^= OBS_DNS_A; // exclude A
|
|
}
|
|
// Test DNS lookup.
|
|
$ip = gethostbyname6($new, $flags);
|
|
}
|
|
|
|
if ($ip) {
|
|
$options['ping_skip'] = (isset($options['ping_skip']) && $options['ping_skip']) || get_entity_attrib('device', $id, 'ping_skip');
|
|
if ($options['ping_skip']) {
|
|
// Skip ping checks
|
|
$flags |= OBS_PING_SKIP;
|
|
}
|
|
|
|
// Test reachability
|
|
if (is_pingable($new, $flags)) {
|
|
// Test directory mess in /rrd/
|
|
if (!file_exists($config['rrd_dir'].'/'.$new)) {
|
|
$host = dbFetchCell("SELECT `hostname` FROM `devices` WHERE `device_id` = ?", array($id));
|
|
if (!file_exists($config['rrd_dir'].'/'.$host)) {
|
|
print_warning("Old RRD directory does not exist, rename skipped.");
|
|
} elseif (!rename($config['rrd_dir'].'/'.$host, $config['rrd_dir'].'/'.$new)) {
|
|
print_error("NOT renamed. Error while renaming RRD directory.");
|
|
return FALSE;
|
|
}
|
|
$return = dbUpdate(array('hostname' => $new), 'devices', '`device_id` = ?', array($id));
|
|
if ($options['ping_skip']) {
|
|
set_entity_attrib('device', $id, 'ping_skip', 1);
|
|
}
|
|
log_event("Device hostname changed: $host -> $new", $id, 'device', $id, 5); // severity 5, for logging user/console info
|
|
return TRUE;
|
|
}
|
|
// directory already exists
|
|
print_error("NOT renamed. Directory rrd/$new already exists");
|
|
} else {
|
|
// failed Reachability
|
|
print_error("NOT renamed. Could not ping $new");
|
|
}
|
|
} else {
|
|
// Failed DNS lookup
|
|
print_error("NOT renamed. Could not resolve $new");
|
|
}
|
|
} else {
|
|
// found in database
|
|
print_error("NOT renamed. Already got host $new");
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Compare two devices by specified Oids (default: sysObjectID, sysDescr, sysContact, sysLocation, sysUpTime)
|
|
*
|
|
* @param array $device1 First device to compare (which we add)
|
|
* @param array $device2 Second device to compare (which we already have)
|
|
* @param array $oids List of oids for compare, default is common system Oids
|
|
* @param boolean $use_db Prefer known Oids from db (also actually for down devices)
|
|
*
|
|
* @return bool TRUE if all Oids return same values
|
|
*/
|
|
function compare_devices_oids($device1, $device2, $oids = [], $use_db = TRUE) {
|
|
if (empty($oids)) {
|
|
// Compare IP addresses at last if all other Oids still same
|
|
// Note: IF-MIB::ifPhysAddress checks only when IP-MIB::ipAdEntAddr unavailable from devices
|
|
$oids = [ 'sysObjectID', 'sysDescr', 'sysContact', 'sysLocation', 'sysUpTime',
|
|
'IP-MIB::ipAdEntAddr', 'IF-MIB::ifPhysAddress' ];
|
|
}
|
|
|
|
// First device must be "new" not in db, secondary from db, check if swapped
|
|
if (!$device2['device_id']) {
|
|
list($device1, $device2) = [ $device2, $device1 ];
|
|
}
|
|
// Re-fetch secondary device array
|
|
$device2 = device_by_id_cache($device2['device_id'], TRUE);
|
|
|
|
// Disable snmp bulk and increase for new device while testing
|
|
$flags1 = OBS_SNMP_ALL_MULTILINE; // Default
|
|
if (safe_empty($device1['os']) || $device1['os'] === 'generic') {
|
|
// Disable snmp bulk for second device
|
|
$device1['snmp_nobulk'] = TRUE;
|
|
// Add no snmp increase flag for unknown devices, while can be troubles for adding device
|
|
$flags1 |= OBS_SNMP_NOINCREASE;
|
|
} elseif (isset($GLOBALS['config']['os'][$device1['os']]['snmpcheck'])) {
|
|
// See Hikvision os
|
|
foreach ((array)$GLOBALS['config']['os'][$device1['os']]['snmpcheck'] as $oid) {
|
|
if (str_contains($oid, '::')) {
|
|
// See ICT Power
|
|
list($mib1) = explode('::', $oid, 2);
|
|
if (!is_device_mib($device1, $mib1, FALSE)) { continue; }
|
|
}
|
|
$oids[] = $oid;
|
|
}
|
|
//$oids = array_merge($oids, (array)$GLOBALS['config']['os'][$device1['os']]['snmpcheck']);
|
|
print_debug_vars($oids);
|
|
} elseif (isset($GLOBALS['config']['os'][$device2['os']]['snmpcheck'])) {
|
|
// In other cases use check Oids by second device.
|
|
foreach ((array)$GLOBALS['config']['os'][$device2['os']]['snmpcheck'] as $oid) {
|
|
if (str_contains($oid, '::')) {
|
|
// See ICT Power
|
|
list($mib2) = explode('::', $oid, 2);
|
|
if (!is_device_mib($device2, $mib2, FALSE)) { continue; }
|
|
}
|
|
$oids[] = $oid;
|
|
}
|
|
//$oids = array_merge($oids, (array)$GLOBALS['config']['os'][$device2['os']]['snmpcheck']);
|
|
print_debug_vars($oids);
|
|
} else {
|
|
// compare by mib specific serials
|
|
foreach (get_device_mibs_permitted($device2) as $mib2) {
|
|
foreach ($GLOBALS['config']['mibs'][$mib2]['serial'] as $entry) {
|
|
if (isset($entry['oid'])) {
|
|
$oids[] = $mib2 . '::' . $entry['oid'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$same = FALSE;
|
|
$skip_ifPhysAddress = FALSE;
|
|
$oids_compare = [];
|
|
foreach ($oids as $full_oid) {
|
|
if (!str_contains($full_oid, '::')) {
|
|
$full_oid = 'SNMPv2-MIB::' . $full_oid;
|
|
}
|
|
list($mib, $oid) = explode('::', $full_oid);
|
|
|
|
switch ($full_oid) {
|
|
case 'SNMPv2-MIB::sysObjectID':
|
|
// Do not compare when not support standard MIB
|
|
if (!is_device_mib($device2, 'SNMPv2-MIB')) {
|
|
break;
|
|
}
|
|
|
|
$value1 = snmp_cache_sysObjectID($device1);
|
|
if ($use_db) {
|
|
$value2 = $device2['sysObjectID'];
|
|
} else {
|
|
$value2 = snmp_cache_sysObjectID($device2);
|
|
}
|
|
|
|
// Do not compare if both values empty
|
|
if ($value1 === '' && $value2 === '') { break; }
|
|
|
|
$same = $value1 == $value2;
|
|
if (!$same) {
|
|
// Not same, break foreach
|
|
if (OBS_DEBUG) {
|
|
// print_warning("The compared oid differs on devices:");
|
|
// print_cli_table([ [ $device1['hostname'], $value1 ],
|
|
// [ $device2['hostname'], $value2 ] ], [ 'Device', $full_oid ]);
|
|
$oids_compare[] = [ '%r'.$full_oid.'%n', $value1, $value2 ];
|
|
}
|
|
break 2;
|
|
}
|
|
if (OBS_DEBUG) {
|
|
$oids_compare[] = [ $full_oid, $value1, $value2 ];
|
|
}
|
|
break;
|
|
|
|
case 'SNMPv2-MIB::sysUpTime':
|
|
// Do not compare uptime when
|
|
if ($device2['status'] == 0 || // secondary device is down
|
|
!is_device_mib($device2, 'SNMPv2-MIB')) { // not support standard MIB
|
|
break;
|
|
}
|
|
|
|
$oid .= '.0';
|
|
$time1 = microtime(TRUE);
|
|
|
|
// sysUpTime always compare not cached values
|
|
$value1 = snmp_get_oid($device1, $oid, $mib);
|
|
$status1 = snmp_status();
|
|
$value2 = snmp_get_oid($device2, $oid, $mib);
|
|
$status2 = snmp_status();
|
|
|
|
$time_diff = round(microtime(TRUE) - $time1, 0, PHP_ROUND_HALF_UP);
|
|
|
|
if ($status1 && $status2) {
|
|
// Do not compare if both values empty
|
|
if ($value1 === '' && $value2 === '') { break; }
|
|
|
|
$same = (timeticks_to_sec($value2) - timeticks_to_sec($value1)) <= $time_diff;
|
|
if (!$same) {
|
|
// Not same, break foreach
|
|
if (OBS_DEBUG) {
|
|
// print_warning("The compared oid differs on devices:");
|
|
// print_cli_table([ [ $device1['hostname'], $value1 ],
|
|
// [ $device2['hostname'], $value2 ] ], [ 'Device', $full_oid ]);
|
|
$oids_compare[] = [ '%r'.$full_oid.'%n', $value1, $value2 ];
|
|
}
|
|
break 2;
|
|
}
|
|
if (OBS_DEBUG) {
|
|
$oids_compare[] = [ $full_oid, $value1, $value2 ];
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'IP-MIB::ipAdEntAddr':
|
|
// Do not compare when not support standard MIB
|
|
if (!is_device_mib($device2, 'IP-MIB')) {
|
|
break;
|
|
}
|
|
|
|
$value1 = snmp_cache_table($device1, $oid, [], $mib, NULL, $flags1);
|
|
$status1 = snmp_status();
|
|
if ($use_db) {
|
|
if (safe_count($value1)) {
|
|
$value1 = array_values($value1); // Remove indexes for compare by db
|
|
sort($value1);
|
|
}
|
|
if ($value2 = dbFetchColumn('SELECT `ipv4_address` FROM `ipv4_addresses` WHERE `device_id` = ?', [ $device2['device_id'] ])) {
|
|
sort($value2);
|
|
}
|
|
$status2 = TRUE;
|
|
} elseif (!$device2['status']) {
|
|
// Secondary down, do not compare
|
|
break;
|
|
} else {
|
|
$value2 = snmp_cache_table($device2, $oid, [], $mib);
|
|
$status2 = snmp_status();
|
|
}
|
|
|
|
if ($status1 && $status2) {
|
|
// Skip IF-MIB::ifPhysAddress check when IP-MIB::ipAdEntAddr available
|
|
$skip_ifPhysAddress = TRUE;
|
|
|
|
$same = safe_count(array_diff((array)$value1, (array)$value2)) === 0;
|
|
if (!$same) {
|
|
// Not same, break foreach
|
|
if (OBS_DEBUG) {
|
|
// print_warning("The compared oid differs on devices:");
|
|
// print_cli_table([ [ $device1['hostname'], implode(', ', $value1) ],
|
|
// [ $device2['hostname'], implode(', ', $value2) ] ], [ 'Device', $full_oid ]);
|
|
$oids_compare[] = [ '%r'.$full_oid.'%n', implode(', ', $value1), implode(', ', $value2) ];
|
|
}
|
|
break 2;
|
|
}
|
|
if (OBS_DEBUG) {
|
|
$oids_compare[] = [ $full_oid, implode(', ', $value1), implode(', ', $value2) ];
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'IF-MIB::ifPhysAddress':
|
|
// Do not compare mac addresses if already checked IP addresses
|
|
if ($skip_ifPhysAddress) { break; }
|
|
// Do not compare when not support standard MIB
|
|
if (!is_device_mib($device2, 'IF-MIB')) {
|
|
break;
|
|
}
|
|
|
|
// For ports ifPhysAddress, by first simple check total ports count (IF-MIB::ifNumber.0)
|
|
$value1 = snmp_cache_oid($device1, 'ifNumber.0', 'IF-MIB');
|
|
$status1 = snmp_status();
|
|
if ($use_db) {
|
|
$ifPhysAddress2 = dbFetchRows('SELECT `ifIndex`, `ifPhysAddress` FROM `ports` WHERE `device_id` = ? AND `deleted` = ?', [ $device2['device_id'], 0 ]);
|
|
print_debug_vars($ifPhysAddress2);
|
|
$value2 = safe_count($ifPhysAddress2);
|
|
if ($value2 < $value1 && $value2 > 0) {
|
|
// Since we can ignore ports, in DB can be same or less ports!
|
|
// Then compare only by mac values
|
|
$value2 = $value1;
|
|
}
|
|
$status2 = TRUE;
|
|
} elseif (!$device2['status']) {
|
|
// Secondary down, do not compare
|
|
break;
|
|
} else {
|
|
$value2 = snmp_cache_oid($device2, 'ifNumber.0', 'IF-MIB');
|
|
$status2 = snmp_status();
|
|
}
|
|
|
|
if ($status1 && $status2 && ($value1 > 0) && $value1 == $value2) {
|
|
// Ports count same, now check phys mac addresses
|
|
$value1 = snmp_cache_table($device1, $oid, [], $mib, NULL, $flags1);
|
|
$status1 = snmp_status();
|
|
|
|
if ($use_db && $status1) {
|
|
// Compare mac addresses by db entries
|
|
$mac_same = TRUE;
|
|
foreach ($ifPhysAddress2 as $entry) {
|
|
$ifIndex = $entry['ifIndex'];
|
|
// When ifIndex not exist on device - devices not same
|
|
if (!isset($value1[$ifIndex])) {
|
|
$same = FALSE;
|
|
break 2;
|
|
}
|
|
// do not compare empty mac addresses
|
|
if (safe_empty($entry['ifPhysAddress']) || $entry['ifPhysAddress'] === '000000000000') { continue; }
|
|
// There need compare all mac on device
|
|
$mac_same = $mac_same && $entry['ifPhysAddress'] === mac_zeropad($value1[$ifIndex]['ifPhysAddress']);
|
|
//print_debug("");
|
|
}
|
|
$same = $mac_same;
|
|
// exit case
|
|
break;
|
|
}
|
|
|
|
// Or compare by snmp request
|
|
$value2 = snmp_cache_table($device2, $oid, [], $mib);
|
|
$status2 = snmp_status();
|
|
|
|
if ($status1 && $status2) {
|
|
$same = safe_count(array_diff($value1, $value2)) === 0;
|
|
if (!$same) {
|
|
// Not same, break foreach
|
|
if (OBS_DEBUG) {
|
|
// print_warning("The compared oid differs on devices:");
|
|
// print_cli_table([ [ $device1['hostname'], implode(', ', $value1) ],
|
|
// [ $device2['hostname'], implode(', ', $value2) ] ], [ 'Device', $oid ]);
|
|
$oids_compare[] = [ '%r'.$full_oid.'%n', implode(', ', $value1), implode(', ', $value2) ];
|
|
}
|
|
break 2;
|
|
}
|
|
if (OBS_DEBUG) {
|
|
$oids_compare[] = [ $full_oid, implode(', ', $value1), implode(', ', $value2) ];
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if ($device2['status'] == 0 || // secondary device is down
|
|
!is_device_mib($device2, $mib)) { // not support MIB
|
|
print_debug("Check Oid ($full_oid) skipped, because second device is down or MIB ($mib) not defined.");
|
|
break;
|
|
}
|
|
|
|
// When Oid not indexed, append default index
|
|
if (!str_contains($oid, '.')) {
|
|
$oid .= '.0';
|
|
}
|
|
|
|
$value1 = snmp_cache_oid($device1, $oid, $mib);
|
|
$status1 = snmp_status();
|
|
$value2 = snmp_cache_oid($device2, $oid, $mib);
|
|
$status2 = snmp_status();
|
|
if ($status1 && $status2) {
|
|
// Do not compare if both values empty
|
|
if ($value1 === '' && $value2 === '') { break; }
|
|
|
|
$same = $value1 == $value2;
|
|
if (!$same) {
|
|
// Not same, break foreach
|
|
if (OBS_DEBUG) {
|
|
// print_warning("The compared oid differs on devices:");
|
|
// print_cli_table([ [ $device1['hostname'], $value1 ],
|
|
// [ $device2['hostname'], $value2 ] ], [ 'Device', $full_oid ]);
|
|
$oids_compare[] = [ '%r'.$full_oid.'%n', $value1, $value2 ];
|
|
}
|
|
break 2;
|
|
}
|
|
if (OBS_DEBUG) {
|
|
$oids_compare[] = [ $full_oid, $value1, $value2 ];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($same && OBS_DEBUG) {
|
|
// If anyway device detect as same, just resolve hostnames for debug
|
|
if (!get_ip_version($device1['hostname'])) {
|
|
$ip1 = gethostbyname6($device1['hostname']);
|
|
} else {
|
|
$ip1 = $device1['hostname'];
|
|
}
|
|
if (!get_ip_version($device2['hostname'])) {
|
|
$ip2 = gethostbyname6($device2['hostname']);
|
|
} else {
|
|
$ip2 = $device2['hostname'];
|
|
}
|
|
|
|
array_unshift($oids_compare, [ '---', '---', '---' ]);
|
|
array_unshift($oids_compare, [ 'Resolved IPs:', $ip1, $ip2 ]);
|
|
}
|
|
|
|
if (safe_count($oids_compare)) {
|
|
print_warning("The compared oids on devices:");
|
|
print_cli_table($oids_compare, [ 'Oid', $device1['hostname'] . ' (%gnew%n)', $device2['hostname'] . ' ('.$device2['device_id'].')' ]);
|
|
}
|
|
|
|
return $same;
|
|
}
|
|
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/common.inc.php
|
|
function scan_port($host, $port, $proto = 'udp', $timeout = 1.0) {
|
|
if (is_float($timeout)) {
|
|
$msec = fmod($timeout, 1) * 1000;
|
|
} else {
|
|
$msec = 0;
|
|
}
|
|
if (!(get_ip_version($host) || is_valid_hostname($host))) {
|
|
// not valid hostname/ip
|
|
print_error("Invalid host $host passed.");
|
|
return 0;
|
|
}
|
|
if (!str_istarts($proto, 'tcp')) {
|
|
// default scan udp
|
|
$host = 'udp://'.$host;
|
|
}
|
|
if (!is_valid_param($port, 'port')) {
|
|
print_error("Invalid port $port passed.");
|
|
return 0;
|
|
}
|
|
if ($handle = fsockopen($host, $port, $errno, $errstr, (float)$timeout)) {
|
|
stream_set_timeout($handle, (int)$timeout, (int)$msec);
|
|
$write = fwrite($handle, "\x00");
|
|
if (!$write) {
|
|
return 0;
|
|
}
|
|
|
|
$startTime = time();
|
|
$header = fread($handle, 1);
|
|
$endTime = time();
|
|
$timeDiff = $endTime - $startTime;
|
|
|
|
fclose($handle);
|
|
if ($timeDiff >= $timeout) {
|
|
return $timeDiff;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function scanUDP($host, $port, $timeout) {
|
|
return scan_port($host, $port, 'udp', $timeout);
|
|
}
|
|
|
|
/**
|
|
* Checks device availability by snmp query common oids
|
|
*
|
|
* @param array $device Device array
|
|
* @return float SNMP query runtime in milliseconds
|
|
*/
|
|
// TESTME needs unit testing
|
|
function isSNMPable($device) {
|
|
// device cached dns ip
|
|
if (isset_status_var('dns_ip') &&
|
|
$device['ip'] !== get_status_var('dns_ip')) {
|
|
// Temporary override cached device IP (right after is_pingable() when IP changed)
|
|
$device['ip'] = get_status_var('dns_ip');
|
|
}
|
|
|
|
if (isset($device['os'][0]) && isset($GLOBALS['config']['os'][$device['os']]['snmpable']) && $device['os'] !== 'generic') {
|
|
// Known device os, and defined custom snmpable OIDs
|
|
$pos = snmp_get_multi_oid($device, $GLOBALS['config']['os'][$device['os']]['snmpable'], array(), 'SNMPv2-MIB', NULL, OBS_SNMP_ALL_NUMERIC);
|
|
//$err = snmp_error_code();
|
|
$count = safe_count($pos);
|
|
} else {
|
|
// Normal checks by sysObjectID and sysUpTime
|
|
$pos = snmp_get_multi_oid($device, '.1.3.6.1.2.1.1.2.0 .1.3.6.1.2.1.1.3.0', [], 'SNMPv2-MIB', NULL, OBS_SNMP_ALL_NUMERIC);
|
|
//print_vars($pos);
|
|
$count = safe_count($pos);
|
|
/*
|
|
$pos = snmp_get_multi_oid($device, 'sysObjectID.0 sysUpTime.0', array(), 'SNMPv2-MIB');
|
|
$count = safe_count($pos[0]);
|
|
*/
|
|
$err = snmp_error_code();
|
|
|
|
if ($count === 0 &&
|
|
$err !== OBS_SNMP_ERROR_AUTHENTICATION_FAILURE && $err !== OBS_SNMP_ERROR_UNSUPPORTED_ALGO && // skip on incorrect auth
|
|
(empty($device['os']) || !isset($GLOBALS['config']['os'][$device['os']]))) {
|
|
// New device (or os changed) try to all snmpable OIDs
|
|
foreach (array_chunk($GLOBALS['config']['os']['generic']['snmpable'], 3) as $snmpable) {
|
|
$pos = snmp_get_multi_oid($device, $snmpable, array(), 'SNMPv2-MIB', NULL, OBS_SNMP_ALL_NUMERIC);
|
|
if ($count = safe_count($pos)) { break; } // stop foreach on first oids set
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($GLOBALS['snmp_status'] && $count > 0) {
|
|
// SNMP response time in milliseconds.
|
|
$time_snmp = $GLOBALS['exec_status']['runtime'] * 1000;
|
|
$time_snmp = number_format($time_snmp, 2, '.', '');
|
|
return $time_snmp;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Checks device availability by icmp echo response
|
|
* If flag OBS_PING_SKIP passed, pings skipped and returns 0.001 (1ms)
|
|
*
|
|
* @param string|array $hostname Device hostname or IP address or device array
|
|
* @param int Flags. Supported OBS_DNS_A, OBS_DNS_AAAA and OBS_PING_SKIP
|
|
* @return float Average response time for used retries count (default retries is 3)
|
|
*/
|
|
function is_pingable($hostname, $flags = OBS_DNS_ALL) {
|
|
global $config;
|
|
|
|
// Compat with $device array
|
|
if (is_array($hostname)) {
|
|
if (isset($hostname['hostname'])) {
|
|
$device = $hostname;
|
|
$hostname = $device['hostname'];
|
|
}
|
|
} else {
|
|
$device = [ 'hostname' => $hostname ];
|
|
}
|
|
|
|
$ping_debug = isset($config['ping']['debug']) && $config['ping']['debug'];
|
|
$try_a = is_flag_set(OBS_DNS_A, $flags);
|
|
|
|
set_status_var('ping_dns', 'ok'); // Set initially dns status as ok
|
|
set_status_var('dns_ip', ''); // reset
|
|
|
|
if ($ip_version = get_ip_version($hostname)) {
|
|
// Cache IP address
|
|
set_status_var('dns_ip', ip_compress($hostname));
|
|
|
|
// Ping by IP
|
|
if ($ip_version === 6) {
|
|
$tags = [ 'fping' => $config['fping6'], 'host' => $hostname ];
|
|
//$cmd = $config['fping6'] . " -t $timeout -c 1 -q $hostname 2>&1";
|
|
} else {
|
|
if (!$try_a) {
|
|
if ($ping_debug) { logfile('debug.log', __FUNCTION__ . "() | DEVICE: $hostname | Passed IPv4 address but device use IPv6 transport"); }
|
|
print_debug('Into function ' . __FUNCTION__ . '() passed IPv4 address ('.$hostname.'but device use IPv6 transport');
|
|
set_status_var('ping_dns', 'incorrect'); // Incorrect
|
|
return 0;
|
|
}
|
|
|
|
// Forced check for actual IPv4 address
|
|
$tags = [ 'fping' => $config['fping'], 'host' => $hostname ];
|
|
//$cmd = $config['fping'] . " -t $timeout -c 1 -q $hostname 2>&1";
|
|
}
|
|
} else {
|
|
// First try IPv4
|
|
$ip = $try_a ? gethostbyname6($hostname, OBS_DNS_A) : FALSE; // Do not check IPv4 if transport IPv6
|
|
if ($ip && $ip != $hostname) {
|
|
$ip = ip_compress($ip);
|
|
|
|
// Cache IP address
|
|
set_status_var('dns_ip', $ip);
|
|
|
|
$tags = [ 'fping' => $config['fping'], 'host' => $ip ];
|
|
//$cmd = $config['fping'] . " -t $timeout -c 1 -q $ip 2>&1";
|
|
} else {
|
|
$ip = gethostbyname6($hostname, OBS_DNS_AAAA);
|
|
// Second try IPv6
|
|
if ($ip) {
|
|
$ip = ip_compress($ip);
|
|
|
|
// Cache IP address
|
|
set_status_var('dns_ip', $ip);
|
|
|
|
$tags = [ 'fping' => $config['fping6'], 'host' => $ip ];
|
|
//$cmd = $config['fping6'] . " -t $timeout -c 1 -q $ip 2>&1";
|
|
} else {
|
|
// No DNS records
|
|
if ($ping_debug) { logfile('debug.log', __FUNCTION__ . "() | DEVICE: $hostname | NO DNS record found"); }
|
|
set_status_var('ping_dns', 'alert');
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (is_flag_set(OBS_PING_SKIP, $flags)) {
|
|
return 0.001; // Ping is skipped, just return 1ms
|
|
}
|
|
|
|
// Timeout, default is 500ms (as in fping)
|
|
$timeout = isset($config['ping']['timeout']) ? (int)$config['ping']['timeout'] : 500;
|
|
if ($timeout < 50) { $timeout = 50; }
|
|
elseif ($timeout > 2000) { $timeout = 2000; }
|
|
$tags['timeout'] = $timeout;
|
|
|
|
// Retries, default is 3
|
|
$retries = isset($config['ping']['retries']) ? (int)$config['ping']['retries'] : 3;
|
|
if ($retries < 1) { $retries = 3; }
|
|
elseif ($retries > 10) { $retries = 10; }
|
|
|
|
// Fping always requested by IP address
|
|
$cmd = array_tag_replace($tags, '%fping% -t %timeout% -c 1 -q %host% 2>&1');
|
|
|
|
// Sleep interval between retries, max 1 sec, min 333ms (1s/3),
|
|
// next retry will increase interval by 1.5 Backoff factor (see fping -B option)
|
|
// We not use fping native retries, because fping waiting for all responses, but we wait only first OK
|
|
$sleep = floor(1000000 / $retries);
|
|
if ($sleep < 333000) { $sleep = 333000; }
|
|
|
|
$ping = 0; // Init false
|
|
for ($i=1; $i <= $retries; $i++) {
|
|
$output = external_exec($cmd);
|
|
if ($GLOBALS['exec_status']['exitcode'] === 0) {
|
|
// normal $output = '8.8.8.8 : xmt/rcv/%loss = 1/1/0%, min/avg/max = 1.21/1.21/1.21'
|
|
list(,,,,,,, $ping) = explode('/', $output);
|
|
//$ping = $tmp[7]; // Avg
|
|
if (!$ping) { $ping = 0.001; } // Protection from zero (exclude false status)
|
|
}
|
|
if ($ping) { break; }
|
|
|
|
if ($ping_debug) {
|
|
$ping_times = format_unixtime($GLOBALS['exec_status']['endtime'] - $GLOBALS['exec_status']['runtime'], 'H:i:s.v') . ', ' . round($GLOBALS['exec_status']['runtime'], 3) . 's';
|
|
logfile('debug.log', __FUNCTION__ . "() | DEVICE: $hostname | $ping_times | FPING OUT ($i): " . $output);
|
|
//log_event(__FUNCTION__ . "() | DEVICE: $hostname | FPING OUT ($i): " . $output, $device_id, 'device', $device_id, 7); // severity 7, debug
|
|
// WARNING, this is very long operation, increase polling time up to 10s
|
|
if ($i == $retries && is_executable($config['mtr'])) {
|
|
$mtr = $config['mtr'] . " -r -n -c 3 $ip";
|
|
logfile('debug.log', __FUNCTION__ . "() | DEVICE: $hostname | MTR OUT:\n" . external_exec($mtr));
|
|
}
|
|
}
|
|
|
|
if ($i < $retries) {
|
|
// Sleep and increase next sleep interval
|
|
usleep($sleep);
|
|
$sleep *= 1.5; // Backoff factor 1.5
|
|
}
|
|
}
|
|
|
|
return $ping;
|
|
}
|
|
|
|
/**
|
|
* Allows overwriting elements of an array of OIDs with replacement values from a private MIB.
|
|
* Currently, used by ports to replace OIDs with private ports tables.
|
|
*
|
|
* @param array $device
|
|
* @param string $entity_type
|
|
* @param string $mib
|
|
* @param array $entity_stats
|
|
* @param array|null $limit_oids
|
|
*
|
|
* @return array
|
|
*/
|
|
function merge_private_mib(&$device, $entity_type, $mib, &$entity_stats, $limit_oids = NULL) {
|
|
global $config;
|
|
|
|
$oids_limited = safe_count($limit_oids);
|
|
|
|
$include_stats = [];
|
|
|
|
foreach ($config['mibs'][$mib][$entity_type] as $table => $def) {
|
|
|
|
// Skip unknown definitions..
|
|
if (!isset($def['oids']) || !is_array($def['oids'])) { continue; }
|
|
|
|
print_cli_data_field($mib);
|
|
echo $table . ' ';
|
|
|
|
$inc_start = microtime(TRUE); // MIB timing start
|
|
$walked = array();
|
|
|
|
// Walk to $entity_tmp, link to $entity_stats if we're not rewriting
|
|
if (isset($def['map'])) {
|
|
$entity_tmp = array();
|
|
if (isset($def['map']['oid'])) {
|
|
echo $def['map']['oid'] . ' ';
|
|
$entity_tmp = snmpwalk_cache_oid($device, $def['map']['oid'], $entity_tmp, $mib);
|
|
|
|
// Skip next Oids walk if no response
|
|
if (!snmp_status()) { continue; }
|
|
|
|
$walked[] = $def['map']['oid'];
|
|
}
|
|
foreach ((array)$def['map']['oid_extra'] as $oid) {
|
|
echo $oid . ' ';
|
|
$entity_tmp = snmpwalk_cache_oid($device, $oid, $entity_tmp, $mib);
|
|
$walked[] = $oid;
|
|
}
|
|
} else {
|
|
$entity_tmp = &$entity_stats;
|
|
}
|
|
|
|
// Populated $entity_tmp
|
|
foreach ($def['oids'] as $oid => $entry) {
|
|
// Skip if there's an OID list and we're not on it.
|
|
if ($oids_limited && !in_array($oid, (array)$limit_oids, TRUE)) { continue; }
|
|
|
|
// If this OID is being used twice, don't walk it again.
|
|
if (!isset($entry['oid']) || in_array($entry['oid'], $walked, TRUE)) { continue; }
|
|
|
|
echo $entry['oid'] . ' ';
|
|
$flags = isset($entry['snmp_flags']) ? $entry['snmp_flags'] : OBS_SNMP_ALL;
|
|
$entity_tmp = snmpwalk_cache_oid($device, $entry['oid'], $entity_tmp, $mib, NULL, $flags);
|
|
|
|
// Skip next Oids walk if no response
|
|
if (!snmp_status() && $oid === array_key_first($def['oids'])) { continue 2; }
|
|
|
|
$walked[] = $entry['oid'];
|
|
}
|
|
print_debug_vars($entity_tmp);
|
|
|
|
// Rewrite indexes using map from $entity_tmp to $entity_stats
|
|
if (isset($def['map'])) {
|
|
$entity_new = array();
|
|
$map_tmp = array();
|
|
$map_array = [];
|
|
// Mapping ports by different entity field (ie ifDescr)
|
|
if (isset($def['map']['map']) && $def['map']['map'] !== 'ifIndex') {
|
|
$map_field = $def['map']['map'];
|
|
foreach ($entity_stats as $idx => $entry) {
|
|
if (isset($entry[$map_field])) {
|
|
$map_array[$entry[$map_field]] = $idx;
|
|
}
|
|
}
|
|
print_debug_vars($map_array);
|
|
}
|
|
// Generate mapping list
|
|
if (isset($def['map']['index'])) {
|
|
// Index by tags
|
|
foreach ($entity_tmp as $index => $entry) {
|
|
$entry['index'] = $index;
|
|
foreach (explode('.', $index) as $k => $idx) {
|
|
$entry['index'.$k] = $idx;
|
|
}
|
|
$map_index = array_tag_replace($entry, $def['map']['index']);
|
|
$map_tmp[$index] = $map_index;
|
|
}
|
|
} else {
|
|
// Mapping by Oid
|
|
$map_oid = $def['map']['oid'];
|
|
foreach ($entity_tmp as $index => $entry) {
|
|
if (isset($entry[$map_oid])) {
|
|
$value = $entry[$map_oid];
|
|
$map_tmp[$index] = isset($map_array[$value]) ? $map_array[$value] : $entry[$map_oid];
|
|
}
|
|
}
|
|
}
|
|
print_debug_vars($map_tmp);
|
|
|
|
foreach ($entity_tmp as $index => $entry) {
|
|
if (isset($map_tmp[$index])) {
|
|
foreach ($entry as $oid => $value) {
|
|
$entity_new[$map_tmp[$index]][$oid] = $value;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$entity_new = $entity_tmp;
|
|
}
|
|
|
|
echo '['; // start change list
|
|
|
|
foreach ($entity_new as $index => $port) {
|
|
foreach ($def['oids'] as $oid => $entry) {
|
|
// Skip if there's an OID list and we're not on it.
|
|
if ($oids_limited && !in_array($oid, (array)$limit_oids, TRUE)) {
|
|
continue;
|
|
}
|
|
|
|
$mib_oid = $entry['oid'];
|
|
if (isset($entry['oid']) && isset($port[$entry['oid']])) {
|
|
|
|
if (isset($entry['transform'])) {
|
|
$entry['transformations'] = $entry['transform'];
|
|
}
|
|
if (isset($entry['transformations'])) {
|
|
// Translate to standard IF-MIB values
|
|
$port[$entry['oid']] = string_transform($port[$entry['oid']], $entry['transformations']);
|
|
echo 'T';
|
|
}
|
|
|
|
if (isset($entry['unit']) && str_ends($entry['unit'], 'ps')) { // bps, pps
|
|
// Set suffixied Oid instead main
|
|
// Currently used for Rate Oids, see SPECTRA-LOGIC-STRATA-MIB definition
|
|
$entity_stats[$index][$oid.'_rate'] = $port[$entry['oid']];
|
|
} else {
|
|
$entity_stats[$index][$oid] = $port[$entry['oid']];
|
|
}
|
|
echo '.';
|
|
} elseif (isset($entry['value'])) {
|
|
// Set fixed value
|
|
$entity_stats[$index][$oid] = $entry['value'];
|
|
} else {
|
|
echo '!';
|
|
}
|
|
}
|
|
}
|
|
//print_debug_vars($entity_stats);
|
|
|
|
$include_stats[$mib] += microtime(TRUE) - $inc_start; // MIB timing
|
|
|
|
echo ']'; // end change list
|
|
echo PHP_EOL; // end CLI DATA FIELD
|
|
}
|
|
|
|
return $include_stats;
|
|
}
|
|
|
|
/**
|
|
* Convert SNMP hex string to binary map, mostly used for VLANs discovery
|
|
*
|
|
* Examples:
|
|
* "00 40" => "0000000001000000"
|
|
*
|
|
* @param string $hex HEX encoded string
|
|
* @return string Binary string
|
|
*/
|
|
function hex2binmap($hex)
|
|
{
|
|
$hex = str_replace(array(' ', "\n"), '', $hex);
|
|
|
|
$binary = '';
|
|
$length = strlen($hex);
|
|
for ($i = 0; $i < $length; $i++)
|
|
{
|
|
$char = $hex[$i];
|
|
$binary .= zeropad(base_convert($char, 16, 2), 4);
|
|
}
|
|
|
|
return $binary;
|
|
}
|
|
|
|
function log_event_process(&$text, &$device = NULL, &$type = NULL, &$reference = NULL, &$severity = 6) {
|
|
if (is_null($device) && is_null($type)) {
|
|
// Without device and type - is global events
|
|
$type = 'global';
|
|
} else {
|
|
$type = strtolower($type);
|
|
}
|
|
$entity_id = $reference;
|
|
|
|
// Global events not have device_id
|
|
if (!in_array($type, [ 'global', 'info' ], TRUE)) {
|
|
if (!is_array($device) && is_intnum($device)) {
|
|
$device = device_by_id_cache($device);
|
|
}
|
|
// Do not log events if device id not found
|
|
if (!is_array($device)) {
|
|
return FALSE;
|
|
}
|
|
// Do not log events if device ignored
|
|
if ($device['ignore'] && $type !== 'device') {
|
|
return FALSE;
|
|
}
|
|
// Ignore defined events for specific oses, see:
|
|
// https://jira.observium.org/browse/OBS-3584
|
|
if (isset($GLOBALS['config']['os'][$device['os']]['eventlog_ignore']) &&
|
|
preg_match($GLOBALS['config']['os'][$device['os']]['eventlog_ignore'], $text)) {
|
|
return FALSE;
|
|
}
|
|
|
|
// Type is valid entity
|
|
if (isset($GLOBALS['config']['entities'][$type])) {
|
|
$translate = entity_type_translate_array($type);
|
|
if (is_array($reference)) {
|
|
$entity = $reference;
|
|
$entity_id = $entity[$translate['id_field']];
|
|
//$reference = $entity[$translate['id_field']];
|
|
} else {
|
|
$entity = get_entity_by_id_cache($type, $reference);
|
|
}
|
|
// Do not log events if entity ignored
|
|
if (isset($translate['ignore_field']) && $entity[$translate['ignore_field']]) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
$severity = priority_string_to_numeric($severity); // Convert named severities to numeric
|
|
if (($type === 'device' && $severity == 5) || isset($_SESSION['username'])) // Severity "Notification" additional log info about username or cli
|
|
{
|
|
$severity = ($severity == 6 ? 5 : $severity); // If severity default, change to notification
|
|
if (isset($_SESSION['username'])) {
|
|
$text .= ' (by user: ' . $_SESSION['username'] . ')';
|
|
} elseif (is_cli()) {
|
|
if (is_cron()) {
|
|
$text .= ' (by cron)';
|
|
} else {
|
|
$text .= ' (by console, user ' . get_localuser() . ')';
|
|
}
|
|
}
|
|
}
|
|
|
|
return [
|
|
'message' => $text,
|
|
'device_id' => $device['device_id'],
|
|
'entity_id' => $entity_id,
|
|
'entity_type' => $type,
|
|
'severity' => $severity
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Use this function to write to the eventlog table
|
|
*
|
|
* @param string $text Message text
|
|
* @param int|array $device Device array or device id
|
|
* @param string $type Entity type (ie port, device, global)
|
|
* @param int|array $reference Reference ID to current entity type
|
|
* @param int $severity Event severity (0 - 8)
|
|
* @return int Event DB id
|
|
*/
|
|
// TESTME needs unit testing
|
|
function log_event($text, $device = NULL, $type = NULL, $reference = NULL, $severity = 6) {
|
|
|
|
$event = log_event_process($text, $device, $type, $reference, $severity);
|
|
if (!is_array($event)) { return $event; }
|
|
|
|
$insert = [
|
|
'device_id' => ($event['device_id'] ?: 0), // Currently db schema not allow NULL value for device_id
|
|
'entity_id' => (is_numeric($event['entity_id']) ? $event['entity_id'] : [ 'NULL' ]),
|
|
'entity_type' => ($event['entity_type'] ?: [ 'NULL' ]),
|
|
'timestamp' => [ "NOW()" ],
|
|
'severity' => $event['severity'],
|
|
'message' => $event['message']
|
|
];
|
|
|
|
return dbInsert($insert, 'eventlog');
|
|
}
|
|
|
|
/**
|
|
* Use this function to write to the eventlog table.
|
|
* Unlike the function log_event() this write events to cache and pull to db at end of process.
|
|
* Also many of the same log entries are combined into one with repeated counter.
|
|
*
|
|
* @param string $text Message text
|
|
* @param int|array $device Device array or device id
|
|
* @param string $type Entity type (ie port, device, global)
|
|
* @param int|array $reference Reference ID to current entity type
|
|
* @param int $severity Event severity (0 - 8)
|
|
* @return int Event DB id
|
|
*/
|
|
function log_event_cache($text, $device = NULL, $type = NULL, $reference = NULL, $severity = 6) {
|
|
global $cache;
|
|
|
|
// Magic key for write/pull all cached events
|
|
if ($text === TRUE || in_array(strtolower($text), [ 'write', 'pull' ])) {
|
|
$insert = [];
|
|
foreach ($cache['log_events'] as $log_type => $e1) {
|
|
foreach ($e1 as $log_message => $e2) {
|
|
|
|
if ($log_type === 'global') {
|
|
$message = $e2['count'] > 1 ? $log_message . " (repeated ".$e2['count']." times)" : $log_message;
|
|
|
|
$insert[] = [
|
|
'device_id' => 0, // Currently db schema not allow NULL value for device_id
|
|
'entity_id' => [ 'NULL' ],
|
|
'entity_type' => $log_type,
|
|
'timestamp' => [ "NOW()" ],
|
|
'severity' => $e2['severity'],
|
|
'message' => $message
|
|
];
|
|
} else {
|
|
foreach ($e2 as $device_id => $e3) {
|
|
$message = $e3['count'] > 1 ? $log_message . " (repeated ".$e3['count']." times)" : $log_message;
|
|
|
|
$insert[] = [
|
|
'device_id' => ($device_id ?: 0), // Currently db schema not allow NULL value for device_id
|
|
'entity_id' => (is_numeric($e3['entity_id']) ? $e3['entity_id'] : [ 'NULL' ]),
|
|
'entity_type' => ($log_type ?: [ 'NULL' ]),
|
|
'timestamp' => [ "NOW()" ],
|
|
'severity' => $e3['severity'],
|
|
'message' => $message
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
print_debug_vars($insert);
|
|
// pull events to db
|
|
dbInsertMulti($insert, 'eventlog');
|
|
|
|
// clear cache after pull
|
|
unset($cache['log_events']);
|
|
return TRUE;
|
|
}
|
|
|
|
// Register shutdown function for write cached event logs (on first log_event_cache() call)
|
|
if (!isset($cache['log_events'])) {
|
|
register_shutdown_function('log_event_cache', TRUE); // log_event_cache(TRUE) writes cached logs to db
|
|
}
|
|
|
|
// Process log entries
|
|
$event = log_event_process($text, $device, $type, $reference, $severity);
|
|
if (!is_array($event)) { return $event; }
|
|
|
|
// Cache log entries
|
|
if ($type === 'global') {
|
|
if (!isset($cache['log_events'][$type][$text])) {
|
|
$cache['log_events'][$type][$text] = [
|
|
'count' => 0,
|
|
'severity' => $severity
|
|
];
|
|
}
|
|
$cache['log_events'][$type][$text]['count']++;
|
|
$cache['log_events'][$type][$text]['severity'] = min($cache['log_events'][$type][$text]['severity'], $severity);
|
|
|
|
return $cache['log_events'][$type][$text];
|
|
} else {
|
|
$device_id = $event['device_id'] ?: 0;
|
|
if (!isset($cache['log_events'][$type][$text][$device_id])) {
|
|
$cache['log_events'][$type][$text][$device_id] = [
|
|
'count' => 0,
|
|
'severity' => $severity,
|
|
'entity_id' => $reference
|
|
];
|
|
}
|
|
$cache['log_events'][$type][$text][$device_id]['count']++;
|
|
$cache['log_events'][$type][$text][$device_id]['severity'] = min($cache['log_events'][$type][$text][$device_id]['severity'], $severity);
|
|
|
|
return $cache['log_events'][$type][$text][$device_id];
|
|
}
|
|
}
|
|
|
|
// Parse string with emails. Return array with email (as key) and name (as value)
|
|
// DOCME needs phpdoc block
|
|
// MOVEME to includes/common.inc.php
|
|
function parse_email($emails)
|
|
{
|
|
$result = array();
|
|
|
|
if (is_string($emails))
|
|
{
|
|
$emails = preg_split('/[,;]\s{0,}/', $emails);
|
|
foreach ($emails as $email)
|
|
{
|
|
$email = trim($email);
|
|
if (preg_match('/^\s*' . OBS_PATTERN_EMAIL_LONG . '\s*$/iu', $email, $matches))
|
|
{
|
|
$email = trim($matches['email']);
|
|
$name = trim($matches['name'], " \t\n'\"");
|
|
$result[$email] = (!empty($name) ? $name : NULL);
|
|
}
|
|
else if (strpos($email, "@") && !preg_match('/\s/', $email))
|
|
{
|
|
$result[$email] = NULL;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
} else {
|
|
// Return FALSE if input not string
|
|
return FALSE;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Converting string to hex
|
|
*
|
|
* By Greg Winiarski of ditio.net
|
|
* http://ditio.net/2008/11/04/php-string-to-hex-and-hex-to-string-functions/
|
|
* We claim no copyright over this function and assume that it is free to use.
|
|
*
|
|
* @param string $string
|
|
*
|
|
* @return string
|
|
*/
|
|
// MOVEME to includes/common.inc.php
|
|
function str2hex($string) {
|
|
$hex = '';
|
|
$len = strlen($string);
|
|
for ($i = 0; $i < $len; $i++) {
|
|
$char = dechex(ord($string[$i]));
|
|
if (strlen($char) === 1) {
|
|
$char = '0'.$char;
|
|
}
|
|
$hex .= $char;
|
|
}
|
|
|
|
return $hex;
|
|
}
|
|
|
|
/**
|
|
* Converting hex to string
|
|
*
|
|
* By Greg Winiarski of ditio.net
|
|
* http://ditio.net/2008/11/04/php-string-to-hex-and-hex-to-string-functions/
|
|
* We claim no copyright over this function and assume that it is free to use.
|
|
*
|
|
* @param string $hex HEX string
|
|
* @param string $eol EOL char, default is \n
|
|
*
|
|
* @return string
|
|
*/
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/common.inc.php
|
|
function hex2str($hex, $eol = "\n")
|
|
{
|
|
$string='';
|
|
|
|
$hex = str_replace(' ', '', $hex);
|
|
for ($i = 0; $i < strlen($hex) - 1; $i += 2)
|
|
{
|
|
$hex_chr = $hex[$i].$hex[$i+1];
|
|
if ($hex_chr == '00')
|
|
{
|
|
// 00 is EOL
|
|
$string .= $eol;
|
|
} else {
|
|
$string .= chr(hexdec($hex_chr));
|
|
}
|
|
}
|
|
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Converting hex/dec coded ascii char to UTF-8 char
|
|
*
|
|
* Used together with snmp_fix_string()
|
|
*
|
|
* @param string $hex
|
|
*
|
|
* @return string
|
|
*/
|
|
function convert_ord_char($ord)
|
|
{
|
|
if (is_array($ord))
|
|
{
|
|
$ord = array_shift($ord);
|
|
}
|
|
if (preg_match('/^(?:<|x)([0-9a-f]+)>?$/i', $ord, $match))
|
|
{
|
|
$ord = hexdec($match[1]);
|
|
}
|
|
elseif (is_numeric($ord))
|
|
{
|
|
$ord = intval($ord);
|
|
}
|
|
elseif (preg_match('/^[\p{L}]+$/u', $ord))
|
|
{
|
|
// Unicode chars
|
|
return $ord;
|
|
} else {
|
|
// Non-printable chars
|
|
$ord = ord($ord);
|
|
}
|
|
|
|
$no_bytes = 0;
|
|
$byte = array();
|
|
|
|
if ($ord < 128)
|
|
{
|
|
return chr($ord);
|
|
}
|
|
elseif ($ord < 2048)
|
|
{
|
|
$no_bytes = 2;
|
|
}
|
|
elseif ($ord < 65536)
|
|
{
|
|
$no_bytes = 3;
|
|
}
|
|
elseif ($ord < 1114112)
|
|
{
|
|
$no_bytes = 4;
|
|
} else {
|
|
return;
|
|
}
|
|
switch($no_bytes)
|
|
{
|
|
case 2:
|
|
$prefix = array(31, 192);
|
|
break;
|
|
case 3:
|
|
$prefix = array(15, 224);
|
|
break;
|
|
case 4:
|
|
$prefix = array(7, 240);
|
|
break;
|
|
}
|
|
|
|
for ($i = 0; $i < $no_bytes; $i++)
|
|
{
|
|
$byte[$no_bytes - $i - 1] = (($ord & (63 * pow(2, 6 * $i))) / pow(2, 6 * $i)) & 63 | 128;
|
|
}
|
|
|
|
$byte[0] = ($byte[0] & $prefix[0]) | $prefix[1];
|
|
|
|
$ret = '';
|
|
for ($i = 0; $i < $no_bytes; $i++)
|
|
{
|
|
$ret .= chr($byte[$i]);
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
// Check if the supplied string is a hex string
|
|
// FIXME This is test for SNMP hex string, for just hex string use ctype_xdigit()
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/snmp.inc.php
|
|
function isHexString($str)
|
|
{
|
|
return (bool) preg_match('/^' . OBS_PATTERN_SNMP_HEX . '$/is', $str);
|
|
}
|
|
|
|
// Include all .inc.php files in $dir
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/common.inc.php
|
|
function include_dir($dir, $regex = "")
|
|
{
|
|
global $device, $config, $valid;
|
|
|
|
if ($regex == "")
|
|
{
|
|
$regex = "/\.inc\.php$/";
|
|
}
|
|
|
|
if ($handle = opendir($config['install_dir'] . '/' . $dir))
|
|
{
|
|
while (false !== ($file = readdir($handle)))
|
|
{
|
|
if (filetype($config['install_dir'] . '/' . $dir . '/' . $file) == 'file' && preg_match($regex, $file))
|
|
{
|
|
print_debug("Including: " . $config['install_dir'] . '/' . $dir . '/' . $file);
|
|
|
|
include($config['install_dir'] . '/' . $dir . '/' . $file);
|
|
}
|
|
}
|
|
|
|
closedir($handle);
|
|
}
|
|
}
|
|
|
|
# Parse CSV files with or without header, and return a multidimensional array
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
// MOVEME to includes/common.inc.php
|
|
function parse_csv($content, $has_header = 1, $separator = ",")
|
|
{
|
|
$lines = explode("\n", $content);
|
|
$result = array();
|
|
|
|
# If the CSV file has a header, load up the titles into $headers
|
|
if ($has_header)
|
|
{
|
|
$headcount = 1;
|
|
$header = array_shift($lines);
|
|
foreach (explode($separator,$header) as $heading)
|
|
{
|
|
if (trim($heading) != "")
|
|
{
|
|
$headers[$headcount] = trim($heading);
|
|
$headcount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
# Process every line
|
|
foreach ($lines as $line)
|
|
{
|
|
if ($line != "")
|
|
{
|
|
$entrycount = 1;
|
|
foreach (explode($separator,$line) as $entry)
|
|
{
|
|
# If we use header, place the value inside the named array entry
|
|
# Otherwise, just stuff it in numbered fields in the array
|
|
if (trim($entry) != "")
|
|
{
|
|
if ($has_header)
|
|
{
|
|
$line_array[$headers[$entrycount]] = trim($entry);
|
|
} else {
|
|
$line_array[] = trim($entry);
|
|
}
|
|
}
|
|
$entrycount++;
|
|
}
|
|
|
|
# Add resulting line array to final result
|
|
$result[] = $line_array; unset($line_array);
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
function get_defined_settings($key = NULL) {
|
|
$config = [];
|
|
include($GLOBALS['config']['install_dir'] . "/config.php");
|
|
|
|
if ($key) {
|
|
// return specific setting if defined
|
|
return array_get_nested($config, $key);
|
|
}
|
|
|
|
// never store this option(s) in memory! Use get_defined_settings($key)
|
|
foreach ($GLOBALS['config']['hide_config'] as $opt) {
|
|
if (array_get_nested($config, $opt)) { unset($config[$opt]); }
|
|
}
|
|
|
|
return $config;
|
|
}
|
|
|
|
function get_default_settings($key = NULL) {
|
|
$config = [];
|
|
include($GLOBALS['config']['install_dir'] . "/includes/defaults.inc.php");
|
|
|
|
if ($key) {
|
|
// return specific setting if defined
|
|
return array_get_nested($config, $key);
|
|
}
|
|
|
|
return $config;
|
|
}
|
|
|
|
function get_config_json($filter = NULL, $print = TRUE) {
|
|
global $config;
|
|
|
|
if (safe_empty($filter)) {
|
|
if ($print) {
|
|
echo safe_json_encode($config);
|
|
return;
|
|
}
|
|
return safe_json_encode($config);
|
|
}
|
|
|
|
if (!is_array($filter)) {
|
|
$filter = explode(',', $filter);
|
|
}
|
|
$json_config = [];
|
|
foreach ($filter as $key) {
|
|
if (array_key_exists($key, $config)) {
|
|
$json_config[$key] = $config[$key];
|
|
}
|
|
}
|
|
|
|
if ($print) {
|
|
echo safe_json_encode($json_config);
|
|
} else {
|
|
return safe_json_encode($json_config);
|
|
}
|
|
}
|
|
|
|
// Load configuration from SQL into supplied variable (pass by reference!)
|
|
function load_sqlconfig(&$config) {
|
|
$config_defined = get_defined_settings(); // defined in config.php
|
|
|
|
// Override some whitelisted definitions from config.php
|
|
foreach ($config_defined as $key => $definition) {
|
|
//if (is_null($config['definitions_whitelist'])) { print_error("NULL on $key"); } else { print_warning("ARRAY on $key"); }
|
|
if (in_array($key, $GLOBALS['config']['definitions_whitelist']) && // Always use global config here!
|
|
is_array($definition) && is_array($config[$key]))
|
|
{
|
|
/* Fix mib definitions for dumb users, who copied old defaults.php
|
|
where mibs was just MIB => 1,
|
|
This definition should be array */
|
|
// Fetch first element and validate that this is array
|
|
if ($key === 'mibs' && !is_array(array_shift(array_values($definition)))) { continue; }
|
|
|
|
$config[$key] = array_replace_recursive($config[$key], $definition);
|
|
}
|
|
}
|
|
|
|
foreach (dbFetchRows("SELECT * FROM `config`") as $item)
|
|
{
|
|
// Convert boo|bee|baa config value into $config['boo']['bee']['baa']
|
|
$tree = explode('|', $item['config_key']);
|
|
|
|
//if (array_key_exists($tree[0], $config_defined)) { continue; } // This complete skip option if first level key defined in $config
|
|
|
|
// Unfortunately, I don't know of a better way to do this...
|
|
// Perhaps using array_map() ? Unclear... hacky. :[
|
|
// FIXME use a loop with references! (cf. nested location menu)
|
|
switch (count($tree))
|
|
{
|
|
case 1:
|
|
//if (isset($config_defined[$tree[0]])) { continue; } // Note, false for null values
|
|
if (array_key_exists($tree[0], $config_defined)) { break; }
|
|
$config[$tree[0]] = safe_unserialize($item['config_value']);
|
|
break;
|
|
case 2:
|
|
if (isset($config_defined[$tree[0]][$tree[1]])) { break; } // Note, false for null values
|
|
$config[$tree[0]][$tree[1]] = safe_unserialize($item['config_value']);
|
|
break;
|
|
case 3:
|
|
if (isset($config_defined[$tree[0]][$tree[1]][$tree[2]])) { break; } // Note, false for null values
|
|
$config[$tree[0]][$tree[1]][$tree[2]] = safe_unserialize($item['config_value']);
|
|
break;
|
|
case 4:
|
|
if (isset($config_defined[$tree[0]][$tree[1]][$tree[2]][$tree[3]])) { break; } // Note, false for null values
|
|
$config[$tree[0]][$tree[1]][$tree[2]][$tree[3]] = safe_unserialize($item['config_value']);
|
|
break;
|
|
case 5:
|
|
if (isset($config_defined[$tree[0]][$tree[1]][$tree[2]][$tree[3]][$tree[4]])) { break; } // Note, false for null values
|
|
$config[$tree[0]][$tree[1]][$tree[2]][$tree[3]][$tree[4]] = safe_unserialize($item['config_value']);
|
|
break;
|
|
default:
|
|
print_error("Too many array levels for SQL configuration parser!");
|
|
}
|
|
}
|
|
}
|
|
|
|
function isset_array_key($key, &$array, $split = '|')
|
|
{
|
|
// Convert boo|bee|baa key into $array['boo']['bee']['baa']
|
|
$tree = explode($split, $key);
|
|
|
|
switch (count($tree))
|
|
{
|
|
case 1:
|
|
//if (isset($array[$tree[0]])) { continue; } // Note, false for null values
|
|
return array_key_exists($tree[0], $array);
|
|
break;
|
|
case 2:
|
|
//if (isset($array[$tree[0]][$tree[1]])) { continue; } // Note, false for null values
|
|
return isset($array[$tree[0]]) && array_key_exists($tree[1], $array[$tree[0]]);
|
|
break;
|
|
case 3:
|
|
//if (isset($array[$tree[0]][$tree[1]][$tree[2]])) { continue; } // Note, false for null values
|
|
return isset($array[$tree[0]][$tree[1]]) && array_key_exists($tree[2], $array[$tree[0]][$tree[1]]);
|
|
break;
|
|
case 4:
|
|
//if (isset($array[$tree[0]][$tree[1]][$tree[2]][$tree[3]])) { continue; } // Note, false for null values
|
|
return isset($array[$tree[0]][$tree[1]][$tree[2]]) && array_key_exists($tree[3], $array[$tree[0]][$tree[1]][$tree[2]]);
|
|
break;
|
|
case 5:
|
|
//if (isset($array[$tree[0]][$tree[1]][$tree[2]][$tree[3]][$tree[4]])) { continue; } // Note, false for null values
|
|
return isset($array[$tree[0]][$tree[1]][$tree[2]][$tree[3]]) && array_key_exists($tree[4], $array[$tree[0]][$tree[1]][$tree[2]][$tree[3]]);
|
|
break;
|
|
default:
|
|
print_error("Too many array levels for array");
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
function set_sql_config($key, $value, $force = TRUE)
|
|
{
|
|
|
|
if (!$force && // Currently configuration store forced also if not exist in defaults
|
|
!isset_array_key($key, $GLOBALS['config']))
|
|
{
|
|
print_error("Not exist config key ($key).");
|
|
return FALSE;
|
|
}
|
|
|
|
$s_value = serialize($value); // in db we store serialized config value
|
|
|
|
$sql = 'SELECT * FROM `config` WHERE `config_key` = ? LIMIT 1';
|
|
if ($in_db = dbFetchRow($sql, [$key]))
|
|
{
|
|
// Exist, compare? and update
|
|
if ($s_value != $in_db[$key])
|
|
{
|
|
dbUpdate(['config_value' => $s_value], 'config', '`config_key` = ?', [$key]);
|
|
}
|
|
}
|
|
else {
|
|
// Insert new
|
|
dbInsert(array('config_key' => $key, 'config_value' => $s_value), 'config');
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
function del_sql_config($key)
|
|
{
|
|
if (dbExist('config', '`config_key` = ?', [$key]))
|
|
{
|
|
dbDelete('config', '`config_key` = ?', [$key]);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// MOVEME to includes/common.inc.php
|
|
/**
|
|
* Convert SI scales to scalar scale.
|
|
* Example return:
|
|
* si_to_scale('milli'); // return 0.001
|
|
* si_to_scale('femto', 8); // return 1.0E-23
|
|
* si_to_scale('-2'); // return 0.01
|
|
*
|
|
* @param $si
|
|
* @param $precision
|
|
*
|
|
* @return float
|
|
*/
|
|
function si_to_scale($si = 'units', $precision = NULL) {
|
|
// See all scales here: http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&typeName=SensorDataScale
|
|
$si = strtolower($si);
|
|
$si_array = [
|
|
'yocto' => -24, 'zepto' => -21, 'atto' => -18,
|
|
'femto' => -15, 'pico' => -12, 'nano' => -9,
|
|
'micro' => -6, 'milli' => -3, 'centi' => -2,
|
|
'deci' => -1, 'units' => 0, 'deca' => 1,
|
|
'hecto' => 2, 'kilo' => 3, 'mega' => 6,
|
|
'giga' => 9, 'tera' => 12, 'peta' => 15,
|
|
'exa' => 18, 'zetta' => 21, 'yotta' => 24
|
|
];
|
|
|
|
$exp = 0;
|
|
if (isset($si_array[$si])) {
|
|
$exp = $si_array[$si];
|
|
} elseif (is_numeric($si)) {
|
|
$exp = (int)$si;
|
|
}
|
|
|
|
if (is_numeric($precision) && $precision > 0) {
|
|
/**
|
|
* NOTES. For EntitySensorPrecision:
|
|
* If an object of this type contains a value in the range 1 to 9, it represents the number of decimal places in the
|
|
* fractional part of an associated EntitySensorValue fixed-point number.
|
|
* If an object of this type contains a value in the range -8 to -1, it represents the number of accurate digits in the
|
|
* associated EntitySensorValue fixed-point number.
|
|
*/
|
|
$exp -= (int)$precision;
|
|
}
|
|
|
|
return 10 ** $exp;
|
|
}
|
|
|
|
/**
|
|
* Compare variables considering epsilon for float numbers
|
|
* returns: 0 - variables same, 1 - $a greater than $b, -1 - $a less than $b
|
|
*
|
|
* @param mixed $a First compare number
|
|
* @param mixed $b Second compare number
|
|
* @param float|int $epsilon
|
|
*
|
|
* @return integer $compare
|
|
*/
|
|
function float_cmp($a, $b, $epsilon = NULL) {
|
|
$epsilon = (is_numeric($epsilon) ? abs((float)$epsilon) : 0.00001); // Default epsilon for float compare
|
|
$compare = FALSE;
|
|
$both = 0;
|
|
// Convert to float if possible
|
|
if (is_numeric($a)) { $a = (float)$a; $both++; }
|
|
if (is_numeric($b)) { $b = (float)$b; $both++; }
|
|
|
|
if ($both === 2) {
|
|
// Compare numeric variables as float numbers
|
|
// Based on compare logic from http://floating-point-gui.de/errors/comparison/
|
|
if ($a === $b) {
|
|
$compare = 0; // Variables same
|
|
$test = 0;
|
|
} else {
|
|
$diff = abs($a - $b);
|
|
//$pow_epsilon = pow($epsilon, 2);
|
|
if ($a == 0 || $b == 0) {
|
|
// Around zero
|
|
$test = $diff;
|
|
$epsilon = $epsilon ** 2;
|
|
if ($test < $epsilon) { $compare = 0; }
|
|
} else {
|
|
// Note, still exist issue with numbers around zero (ie: -0.00000001, 0.00000002)
|
|
$test = $diff / min(abs($a) + abs($b), PHP_INT_MAX);
|
|
if ($test < $epsilon) { $compare = 0; }
|
|
}
|
|
}
|
|
|
|
if (OBS_DEBUG > 1) {
|
|
print_message('Compare float numbers: "'.$a.'" with "'.$b.'", epsilon: "'.$epsilon.'", comparison: "'.$test.' < '.$epsilon.'", numbers: '.($compare === 0 ? 'SAME' : 'DIFFERENT'));
|
|
}
|
|
} elseif ($a === $b) {
|
|
// All other compare as usual
|
|
$compare = 0; // Variables same
|
|
}
|
|
|
|
if ($compare === FALSE) {
|
|
// Compare if variables not same
|
|
if ($a > $b) {
|
|
$compare = 1; // $a greater than $b
|
|
} else {
|
|
$compare = -1; // $a less than $b
|
|
}
|
|
}
|
|
|
|
return $compare;
|
|
}
|
|
|
|
function float_div($a, $b) {
|
|
/*
|
|
switch (OBS_MATH) {
|
|
// case 'gmp':
|
|
// // Convert values to string
|
|
// $a = gmp_init_float($a);
|
|
// $b = gmp_init_float($b);
|
|
// $sub = gmp_sub($a, $b);
|
|
// $sub = gmp_strval($sub); // Convert GMP number to string
|
|
// print_debug("GMP SUB: $a - $b = $sub");
|
|
// break;
|
|
case 'bc':
|
|
// Convert values to string
|
|
$a = (string)$a;
|
|
$b = (string)$b;
|
|
$div = bcdiv($a, $b, 0);
|
|
print_debug("BC SUB: $a - $b = $div");
|
|
break;
|
|
default:
|
|
// Fallback to php math
|
|
$div = fdiv($a, $b);
|
|
if (!is_finite($div)) {
|
|
$div = 0;
|
|
}
|
|
print_debug("PHP DIV: $a / $b = $div");
|
|
}
|
|
*/
|
|
|
|
$div = fdiv($a, $b);
|
|
if (!is_finite($div)) {
|
|
$div = 0;
|
|
}
|
|
|
|
return $div;
|
|
}
|
|
|
|
/**
|
|
* Add integer numbers.
|
|
* This function better to use with big Counter64 numbers
|
|
*
|
|
* @param int|string $a The first number
|
|
* @param int|string $b The second number
|
|
* @return string A number representing the sum of the arguments.
|
|
*/
|
|
function int_add($a, $b) {
|
|
switch (OBS_MATH) {
|
|
case 'gmp':
|
|
// Convert values to string
|
|
$a = gmp_init_float($a);
|
|
$b = gmp_init_float($b);
|
|
// Better to use GMP extension, for more correct operations with big numbers
|
|
// $a = "18446742978492891134"; $b = "0"; $sum = gmp_add($a, $b); echo gmp_strval($sum) . "\n"; // Result: 18446742978492891134
|
|
// $a = "18446742978492891134"; $b = "0"; $sum = $a + $b; printf("%.0f\n", $sum); // Result: 18446742978492891136
|
|
$sum = gmp_add($a, $b);
|
|
$sum = gmp_strval($sum); // Convert GMP number to string
|
|
print_debug("GMP ADD: $a + $b = $sum");
|
|
break;
|
|
case 'bc':
|
|
// Convert values to string
|
|
$a = (string)$a;
|
|
$b = (string)$b;
|
|
$sum = bcadd($a, $b);
|
|
print_debug("BC ADD: $a + $b = $sum");
|
|
break;
|
|
default:
|
|
// Fallback to php math
|
|
$sum = $a + $b;
|
|
// Convert this values to int string, for prevent rrd update error with big Counter64 numbers,
|
|
// see: http://jira.observium.org/browse/OBSERVIUM-1749
|
|
$sum = sprintf("%.0f", $sum);
|
|
print_debug("PHP ADD: $a + $b = $sum");
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
/**
|
|
* Subtract integer numbers.
|
|
* This function better to use with big Counter64 numbers
|
|
*
|
|
* @param int|string $a The first number
|
|
* @param int|string $b The second number
|
|
* @return string A number representing the subtract of the arguments.
|
|
*/
|
|
function int_sub($a, $b) {
|
|
switch (OBS_MATH) {
|
|
case 'gmp':
|
|
// Convert values to string
|
|
$a = gmp_init_float($a);
|
|
$b = gmp_init_float($b);
|
|
$sub = gmp_sub($a, $b);
|
|
$sub = gmp_strval($sub); // Convert GMP number to string
|
|
print_debug("GMP SUB: $a - $b = $sub");
|
|
break;
|
|
case 'bc':
|
|
// Convert values to string
|
|
$a = (string)$a;
|
|
$b = (string)$b;
|
|
$sub = bcsub($a, $b);
|
|
print_debug("BC SUB: $a - $b = $sub");
|
|
break;
|
|
default:
|
|
// Fallback to php math
|
|
$sub = $a - $b;
|
|
// Convert this values to int string, for prevent rrd update error with big Counter64 numbers,
|
|
// see: http://jira.observium.org/browse/OBSERVIUM-1749
|
|
$sub = sprintf("%.0f", $sub);
|
|
print_debug("PHP SUB: $a - $b = $sub");
|
|
}
|
|
|
|
return $sub;
|
|
}
|
|
|
|
/**
|
|
* GMP have troubles with float number math
|
|
*
|
|
* php > $sum = 1111111111111111111111111.1; echo sprintf("%.0f", $sum)."\n"; echo sprintf("%d", $sum)."\n"; echo strval($sum)."\n"; echo $sum;
|
|
1111111111111111092469760
|
|
8375319363669983232
|
|
1.1111111111111E+24
|
|
1.1111111111111E+24
|
|
php > $sum = "1111111111111111111111111.1"; echo sprintf("%.0f", $sum)."\n"; echo sprintf("%d", $sum)."\n"; echo strval($sum)."\n"; echo $sum;
|
|
1111111111111111092469760
|
|
9223372036854775807
|
|
1111111111111111111111111.1
|
|
1111111111111111111111111.1
|
|
*/
|
|
function gmp_init_float($value) {
|
|
if (is_intnum($value)) {
|
|
return $value;
|
|
}
|
|
if (is_float($value)) {
|
|
return sprintf("%.0f", $value);
|
|
}
|
|
if (str_contains($value, '.')) {
|
|
// Return int part of string
|
|
list($value) = explode('.', $value);
|
|
//return $value;
|
|
}
|
|
if (safe_empty($value)) {
|
|
return 0;
|
|
}
|
|
|
|
return (string)$value;
|
|
}
|
|
|
|
// Translate syslog priorities from string to numbers
|
|
// ie: ('emerg','alert','crit','err','warning','notice') >> ('0', '1', '2', '3', '4', '5')
|
|
// Note, this is safe function, for unknown data return 15
|
|
// DOCME needs phpdoc block
|
|
function priority_string_to_numeric($value) {
|
|
$priority = 15; // Default priority for unknown data
|
|
if (!is_numeric($value)) {
|
|
foreach ($GLOBALS['config']['syslog']['priorities'] as $pri => $entry) {
|
|
if (is_string($value) && str_istarts($entry['name'], substr($value, 0, 3))) {
|
|
$priority = $pri;
|
|
break;
|
|
}
|
|
}
|
|
} elseif ($value == (int)$value && $value >= 0 && $value < 16) {
|
|
$priority = (int)$value;
|
|
}
|
|
|
|
return $priority;
|
|
}
|
|
|
|
/**
|
|
* Translate syslog facilities from string to numeric
|
|
*
|
|
*/
|
|
function facility_string_to_numeric($facility)
|
|
{
|
|
if (!is_numeric($facility))
|
|
{
|
|
foreach ($GLOBALS['config']['syslog']['facilities'] as $f => $entry)
|
|
{
|
|
if ($entry['name'] == $facility)
|
|
{
|
|
$facility = $f;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if ($facility == (int)$facility && $facility >= 0 && $facility <= 23)
|
|
{
|
|
$facility = (int)$facility;
|
|
}
|
|
|
|
return $facility;
|
|
}
|
|
|
|
function array_merge_indexed(&$array1, &$array2)
|
|
{
|
|
$merged = $array1;
|
|
//print_vars($merged);
|
|
|
|
foreach ($array2 as $key => &$value)
|
|
{
|
|
if (is_array($value) && isset($merged[$key]) && is_array($merged[$key]))
|
|
{
|
|
$merged[$key] = array_merge_indexed($merged[$key], $value);
|
|
} else {
|
|
$merged[$key] = $value;
|
|
}
|
|
}
|
|
|
|
//print_vars($merged);
|
|
return $merged;
|
|
}
|
|
|
|
// Merge 2 arrays by their index, ie:
|
|
// Array( [1] => [TestCase] = '1' ) + Array( [1] => [Bananas] = 'Yes )
|
|
// becomes
|
|
// Array( [1] => [TestCase] = '1', [Bananas] = 'Yes' )
|
|
//
|
|
// array_merge_recursive() only works for string keys, not numeric as we get from snmp functions.
|
|
//
|
|
// Accepts infinite parameters.
|
|
//
|
|
// Currently not used. Does not cope well with multilevel arrays.
|
|
// DOCME needs phpdoc block
|
|
// MOVEME to includes/common.inc.php
|
|
/*
|
|
function array_merge_indexed()
|
|
{
|
|
$array = array();
|
|
|
|
foreach (func_get_args() as $array2)
|
|
{
|
|
if (count($array2) == 0) continue; // Skip for loop for empty array, infinite loop ahead.
|
|
for ($i = 0; $i <= count($array2); $i++)
|
|
{
|
|
foreach (array_keys($array2[$i]) as $key)
|
|
{
|
|
$array[$i][$key] = $array2[$i][$key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $array;
|
|
}
|
|
*/
|
|
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
function print_cli_heading($contents, $level = 2)
|
|
{
|
|
if (OBS_QUIET || !is_cli()) { return; } // Silent exit if not cli or quiet
|
|
|
|
// $tl = html_entity_decode('╔', ENT_NOQUOTES, 'UTF-8'); // top left corner
|
|
// $tr = html_entity_decode('╗', ENT_NOQUOTES, 'UTF-8'); // top right corner
|
|
// $bl = html_entity_decode('╚', ENT_NOQUOTES, 'UTF-8'); // bottom left corner
|
|
// $br = html_entity_decode('╝', ENT_NOQUOTES, 'UTF-8'); // bottom right corner
|
|
// $v = html_entity_decode('║', ENT_NOQUOTES, 'UTF-8'); // vertical wall
|
|
// $h = html_entity_decode('═', ENT_NOQUOTES, 'UTF-8'); // horizontal wall
|
|
|
|
// print_message($tl . str_repeat($h, strlen($contents)+2) . $tr . "\n" .
|
|
// $v . ' '.$contents.' ' . $v . "\n" .
|
|
// $bl . str_repeat($h, strlen($contents)+2) . $br . "\n", 'color');
|
|
|
|
$level_colours = array('0' => '%W', '1' => '%g', '2' => '%c' , '3' => '%p');
|
|
|
|
//print_message(str_repeat(" ", $level). $level_colours[$level]."##### %W". $contents ."%n\n", 'color');
|
|
print_message($level_colours[$level]."##### %W". $contents .$level_colours[$level]." #####%n\n", 'color');
|
|
}
|
|
|
|
/**
|
|
* @param $field
|
|
* @param null $data
|
|
* @param int $level
|
|
*/
|
|
// TESTME needs unit testing
|
|
function print_cli_data($field, $data = NULL, $level = 2)
|
|
{
|
|
if (OBS_QUIET || !is_cli()) { return; } // Silent exit if not cli or quiet
|
|
|
|
//$level_colours = array('0' => '%W', '1' => '%g', '2' => '%c' , '3' => '%p');
|
|
|
|
//print_cli(str_repeat(" ", $level) . $level_colours[$level]." o %W".str_pad($field, 20). "%n ");
|
|
//print_cli($level_colours[$level]." o %W".str_pad($field, 20). "%n "); // strlen == 24
|
|
print_cli_data_field($field, $level);
|
|
|
|
$field_len = 0;
|
|
$max_len = 110;
|
|
|
|
$lines = explode("\n", $data);
|
|
|
|
foreach ($lines as $line)
|
|
{
|
|
$len = strlen($line) + 24;
|
|
if ($len > $max_len)
|
|
{
|
|
$len = $field_len;
|
|
$data = explode(" ", $line);
|
|
foreach ($data as $datum)
|
|
{
|
|
$len = $len + strlen($datum);
|
|
if ($len > $max_len)
|
|
{
|
|
$len = strlen($datum);
|
|
//$datum = "\n". str_repeat(" ", 26+($level * 2)). $datum;
|
|
$datum = "\n". str_repeat(" ", 24). $datum;
|
|
} else {
|
|
$datum .= ' ';
|
|
}
|
|
print_cli($datum);
|
|
}
|
|
} else {
|
|
$datum = str_repeat(" ", $field_len). $line;
|
|
print_cli($datum);
|
|
}
|
|
$field_len = 24;
|
|
print_cli(PHP_EOL);
|
|
}
|
|
}
|
|
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
function print_cli_data_field($field, $level = 2)
|
|
{
|
|
if (OBS_QUIET || !is_cli()) { return; } // Silent exit if not cli or quiet
|
|
|
|
$level_colours = array('0' => '%W', '1' => '%g', '2' => '%c' , '3' => '%p', '4' => '%y');
|
|
|
|
// print_cli(str_repeat(" ", $level) . $level_colours[$level]." o %W".str_pad($field, 20). "%n ");
|
|
print_cli($level_colours[$level]." o %W".str_pad($field, 20). "%n ");
|
|
}
|
|
|
|
/**
|
|
* @param array $table_rows
|
|
* @param array $table_header
|
|
* @param string|null $descr
|
|
* @param array $options
|
|
*/
|
|
// TESTME needs unit testing
|
|
function print_cli_table($table_rows, $table_header = array(), $descr = NULL, $options = array())
|
|
{
|
|
// FIXME, probably need ability to view this tables in WUI?!
|
|
if (OBS_QUIET || !is_cli()) { return; } // Silent exit if not cli or quiet
|
|
|
|
if (!is_array($table_rows)) { print_debug("print_cli_table() argument $table_rows should be an array. Please report this error to developers."); return; }
|
|
|
|
if (!cli_is_piped() || OBS_DEBUG)
|
|
{
|
|
$count_rows = count($table_rows);
|
|
if ($count_rows == 0) { return; }
|
|
|
|
if (strlen($descr))
|
|
{
|
|
print_cli_data($descr, '', 3);
|
|
}
|
|
|
|
// Init table and renderer
|
|
$table = new \cli\Table();
|
|
cli\Colors::enable(TRUE);
|
|
|
|
// Set default maximum width globally
|
|
if (!isset($options['max-table-width']))
|
|
{
|
|
$options['max-table-width'] = 240;
|
|
//$options['max-table-width'] = TRUE;
|
|
}
|
|
// WARNING, min-column-width not worked in cli Class, I wait when issue will fixed
|
|
//$options['min-column-width'] = 30;
|
|
if (!empty($options))
|
|
{
|
|
$renderer = new cli\Table\Ascii;
|
|
if (isset($options['max-table-width']))
|
|
{
|
|
if ($options['max-table-width'] === TRUE)
|
|
{
|
|
// Set maximum table width as available columns in terminal
|
|
$options['max-table-width'] = cli\Shell::columns();
|
|
}
|
|
if (is_numeric($options['max-table-width']))
|
|
{
|
|
$renderer->setConstraintWidth($options['max-table-width']);
|
|
}
|
|
}
|
|
if (isset($options['min-column-width']))
|
|
{
|
|
$cols = array();
|
|
foreach (current($table_rows) as $col)
|
|
{
|
|
$cols[] = $options['min-column-width'];
|
|
}
|
|
//var_dump($cols);
|
|
$renderer->setWidths($cols);
|
|
}
|
|
$table->setRenderer($renderer);
|
|
}
|
|
|
|
$count_header = count($table_header);
|
|
if ($count_header)
|
|
{
|
|
$table->setHeaders($table_header);
|
|
}
|
|
$table->setRows($table_rows);
|
|
$table->display();
|
|
echo(PHP_EOL);
|
|
} else {
|
|
print_cli_data("Notice", "Table output suppressed due to piped output.".PHP_EOL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints Observium banner containing ASCII logo and version information for use in CLI utilities.
|
|
*/
|
|
function print_cli_banner()
|
|
{
|
|
if (OBS_QUIET || !is_cli()) { return; } // Silent exit if not cli or quiet
|
|
|
|
print_message("%W
|
|
___ _ _
|
|
/ _ \ | |__ ___ ___ _ __ __ __(_) _ _ _ __ ___
|
|
| | | || '_ \ / __| / _ \| '__|\ \ / /| || | | || '_ ` _ \
|
|
| |_| || |_) |\__ \| __/| | \ V / | || |_| || | | | | |
|
|
\___/ |_.__/ |___/ \___||_| \_/ |_| \__,_||_| |_| |_|%c
|
|
".
|
|
str_pad(OBSERVIUM_PRODUCT_LONG." ".OBSERVIUM_VERSION, 59, " ", STR_PAD_LEFT)."\n".
|
|
str_pad(OBSERVIUM_URL , 59, " ", STR_PAD_LEFT)."%N\n", 'color');
|
|
|
|
// One time alert about deprecated (eol) php version
|
|
if (version_compare(PHP_VERSION, OBS_MIN_PHP_VERSION, '<'))
|
|
{
|
|
$php_version = PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION . '.' . PHP_RELEASE_VERSION;
|
|
print_message("
|
|
|
|
+---------------------------------------------------------+
|
|
| |
|
|
| %rDANGER! ACHTUNG! BHUMAHUE!%n |
|
|
| |
|
|
".
|
|
str_pad("| %WYour PHP version is too old (%r".$php_version."%W),", 64, ' ')."%n|
|
|
| %Wfunctionality may be broken. Please update your PHP!%n |
|
|
| %WCurrently recommended version(s): >%g7.2.x%n |
|
|
| |
|
|
| See additional information here: |
|
|
| %c".
|
|
str_pad(OBSERVIUM_DOCS_URL . '/software_requirements/' , 56, ' ')."%n|
|
|
| |
|
|
+---------------------------------------------------------+
|
|
", 'color');
|
|
}
|
|
}
|
|
|
|
// TESTME needs unit testing
|
|
/**
|
|
* Creates a list of php files available in the html/pages/front directory, to show in a
|
|
* dropdown on the web configuration page.
|
|
*
|
|
* @return array List of front page files available
|
|
*/
|
|
function config_get_front_page_files()
|
|
{
|
|
global $config;
|
|
|
|
$frontpages = array();
|
|
|
|
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($config['html_dir'] . '/pages/front')) as $file)
|
|
{
|
|
$filename = $file->getFileName();
|
|
if ($filename[0] != '.')
|
|
{
|
|
$frontpages["pages/front/$filename"] = nicecase(basename($filename,'.php'));
|
|
}
|
|
}
|
|
|
|
return $frontpages;
|
|
}
|
|
|
|
/**
|
|
* Creates a list of php files available in the html/includes/authentication directory, to show in a
|
|
* dropdown on the web configuration page.
|
|
*
|
|
* @return array List of authentication modules available
|
|
*/
|
|
function config_get_auth_modules()
|
|
{
|
|
global $config;
|
|
|
|
$authmodules = array();
|
|
|
|
foreach (get_recursive_directory_iterator($config['html_dir'] . '/includes/authentication') as $file => $info) {
|
|
if (str_ends($file, '.inc.php')) {
|
|
$auth = basename($file, '.inc.php');
|
|
$authmodules[$auth] = nicecase($auth);
|
|
}
|
|
}
|
|
|
|
return $authmodules;
|
|
}
|
|
|
|
/**
|
|
* Triggers a rediscovery of the given device at the following discovery -h new run.
|
|
*
|
|
* @param array $device Device array.
|
|
* @param array $modules Array with modules required for rediscovery, if empty rediscover device full
|
|
*
|
|
* @return mixed Status of added or not force device discovery
|
|
*/
|
|
// TESTME needs unit testing
|
|
function force_discovery($device, $modules = []) {
|
|
$return = FALSE;
|
|
|
|
if (safe_empty($modules)) {
|
|
// Modules not passed, just full rediscover device
|
|
return dbUpdate([ 'force_discovery' => 1 ], 'devices', '`device_id` = ?', array($device['device_id']));
|
|
}
|
|
|
|
// Modules passed, check if modules valid and enabled
|
|
$modules = (array)$modules;
|
|
$forced_modules = get_entity_attrib('device', $device['device_id'], 'force_discovery_modules');
|
|
if ($forced_modules) {
|
|
// Already forced modules exist, merge it with new
|
|
$modules = array_unique(array_merge($modules, safe_json_decode($forced_modules)));
|
|
}
|
|
|
|
$valid_modules = [];
|
|
foreach ($GLOBALS['config']['discovery_modules'] as $module => $ok) {
|
|
// Filter by valid and enabled modules
|
|
if ($ok && in_array($module, $modules)) {
|
|
$valid_modules[] = $module;
|
|
}
|
|
}
|
|
|
|
if (count($valid_modules)) {
|
|
$return = dbUpdate(array('force_discovery' => 1), 'devices', '`device_id` = ?', array($device['device_id']));
|
|
set_entity_attrib('device', $device['device_id'], 'force_discovery_modules', safe_json_encode($valid_modules));
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
// From http://stackoverflow.com/questions/9339619/php-checking-if-the-last-character-is-a-if-not-then-tack-it-on
|
|
// Assumed free to use :)
|
|
// DOCME needs phpdoc block
|
|
// TESTME needs unit testing
|
|
function fix_path_slash($p)
|
|
{
|
|
$p = str_replace('\\','/',trim($p));
|
|
return (substr($p,-1)!='/') ? $p.='/' : $p;
|
|
}
|
|
|
|
/**
|
|
* Calculates missing fields of a mempool based on supplied information and returns them all.
|
|
* This function also applies the scaling as requested.
|
|
* Also works for storage.
|
|
*
|
|
* @param numeric $scale Scaling to apply to the supplied values.
|
|
* @param numeric $used Used value of mempool, before scaling, or NULL.
|
|
* @param numeric $total Total value of mempool, before scaling, or NULL.
|
|
* @param numeric $free Free value of mempool, before scaling, or NULL.
|
|
* @param numeric $perc Used percentage value of mempool, or NULL.
|
|
* @param array $options Additional options, ie separate scales for used/total/free
|
|
*
|
|
* @return array Array consisting of 'used', 'total', 'free' and 'perc' fields
|
|
*/
|
|
function calculate_mempool_properties($scale, $used, $total, $free, $perc = NULL, $options = []) {
|
|
// Scale, before maths!
|
|
if ($scale == 0) { $scale = 1; }
|
|
|
|
$numeric = [];
|
|
foreach ([ 'total', 'used', 'free', 'perc' ] as $param) {
|
|
$numeric[$param] = is_numeric($$param);
|
|
if ($numeric[$param]) {
|
|
if (isset($options['scale_'.$param])) {
|
|
// Separate scale for current param
|
|
$$param *= $options['scale_'.$param];
|
|
} elseif ($scale != 1 && $param !== 'perc') {
|
|
// Common scale (do not use common scale for perc, ie NS-ROOT-MIB, AGENT-GENERAL-MIB)
|
|
$$param *= $scale;
|
|
}
|
|
}
|
|
}
|
|
print_debug_vars($numeric);
|
|
|
|
if ($numeric['total'] && $numeric['free']) {
|
|
$used = $total - $free;
|
|
$perc = round(float_div($used, $total) * 100, 2);
|
|
} elseif ($numeric['used'] && $numeric['free']) {
|
|
$total = $used + $free;
|
|
$perc = round(float_div($used, $total) * 100, 2);
|
|
} elseif ($numeric['total'] && $numeric['perc']) {
|
|
$used = $total * $perc / 100;
|
|
$free = $total - $used;
|
|
} elseif ($numeric['total'] && $numeric['used']) {
|
|
$free = $total - $used;
|
|
$perc = round(float_div($used, $total) * 100, 2);
|
|
} elseif ($numeric['perc']) {
|
|
$total = 100;
|
|
$used = $perc;
|
|
$free = 100 - $perc;
|
|
//$scale = 1; // Reset scale for percentage-only
|
|
}
|
|
|
|
if (OBS_DEBUG && ($perc < 0 || $perc > 100)) {
|
|
print_error('Incorrect scales or passed params to function ' . __FUNCTION__ . '()');
|
|
}
|
|
print_debug_vars([ 'used' => $used, 'total' => $total, 'free' => $free, 'perc' => $perc, 'units' => $scale, 'scale' => $scale ], 1);
|
|
|
|
return [ 'used' => $used, 'total' => $total, 'free' => $free, 'perc' => $perc, 'units' => $scale, 'scale' => $scale ];
|
|
}
|
|
|
|
function discovery_check_if_type_exist($entry, $entity_type, $entity = []) {
|
|
|
|
if (is_string($entry) || is_array_list($entry)) {
|
|
$skip_if_valid_exist = $entry;
|
|
} elseif (isset($entry['skip_if_valid_exist'])) {
|
|
$skip_if_valid_exist = $entry['skip_if_valid_exist'];
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
$valid = &$GLOBALS['valid'];
|
|
|
|
foreach ((array)$skip_if_valid_exist as $skip_entry) {
|
|
// use %index% tags
|
|
if (!empty($entity) && str_contains($skip_entry, '%')) {
|
|
$skip_entry = array_tag_replace($entity, $skip_entry);
|
|
}
|
|
// FIXME. Need switch to array_get_nested()
|
|
//array_get_nested($valid[$entity_type], $skip_entry);
|
|
$tree = explode('->', $skip_entry);
|
|
//print_vars($tree);
|
|
switch (count($tree)) {
|
|
case 1:
|
|
if (is_array($valid[$entity_type]) &&
|
|
array_key_exists($tree[0], $valid[$entity_type])) {
|
|
|
|
print_debug("Excluded by valid exist: " . $skip_entry);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
if (is_array($valid[$entity_type][$tree[0]]) &&
|
|
array_key_exists($tree[1], $valid[$entity_type][$tree[0]])) {
|
|
|
|
print_debug("Excluded by valid exist: " . $skip_entry);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
if (is_array($valid[$entity_type][$tree[0]][$tree[1]]) &&
|
|
array_key_exists($tree[2], $valid[$entity_type][$tree[0]][$tree[1]]))
|
|
{
|
|
print_debug("Excluded by valid exist: " . $skip_entry);
|
|
|
|
return TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
print_debug("Too many array levels for valid sensor!");
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
function discovery_check_requires_pre($device, $entry, $entity_type = NULL) {
|
|
|
|
if (isset($entry['test_pre']) && !isset($entry['pre_test'])) {
|
|
// DERP. I keep forgetting how to do it right.
|
|
$entry['pre_test'] = $entry['test_pre'];
|
|
unset($entry['test_pre']);
|
|
}
|
|
|
|
if (isset($entry['pre_test']) && is_array($entry['pre_test'])) {
|
|
// Convert single test condition to multi-level condition
|
|
if (isset($entry['pre_test']['operator'])) {
|
|
$entry['pre_test'] = array($entry['pre_test']);
|
|
}
|
|
|
|
foreach ($entry['pre_test'] as $test) {
|
|
if (isset($test['oid'])) {
|
|
// Fetch just the value eof the OID.
|
|
if (isset($entry['mib']) && !str_contains($test['oid'], '::')) {
|
|
$test['data'] = snmp_cache_oid($device, $test['oid'], $entry['mib'], NULL, OBS_SNMP_ALL);
|
|
$oid = $entry['mib'] . '::' . $test['oid'];
|
|
} else {
|
|
$test['data'] = snmp_cache_oid($device, $test['oid'], NULL, NULL, OBS_SNMP_ALL);
|
|
$oid = $test['oid'];
|
|
}
|
|
} elseif (isset($test['field'])) {
|
|
$test['data'] = $entry[$test['field']];
|
|
$oid = $test['field'];
|
|
} elseif (isset($test['device_field']) && array_key_iexists($test['device_field'], $device)) {
|
|
// compare by device field(s), ie: sysObjectId, sysName
|
|
if (isset($device[$test['device_field']])) {
|
|
$test['data'] = $device[$test['device_field']];
|
|
$oid = 'Device ' . $test['device_field'];
|
|
} else {
|
|
// case-insensitive
|
|
$test['device_field'] = strtolower($test['device_field']);
|
|
foreach ($device as $key => $value) {
|
|
if (strtolower($key) === $test['device_field']) {
|
|
$test['data'] = $value;
|
|
$oid = 'Device ' . $key;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
print_debug("Not correct Field (".$test['field'].") passed to discovery_check_requires(). Need add it to 'oid_extra' definition.");
|
|
return FALSE;
|
|
}
|
|
|
|
if (test_condition($test['data'], $test['operator'], $test['value']) === FALSE) {
|
|
print_debug("Excluded by not test condition: $oid [".$test['data']."] ".$test['operator']." [".implode(', ', (array)$test['value'])."]");
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
function discovery_check_requires($device, $entry, $array, $entity_type = NULL) {
|
|
if (isset($entry['test']) && is_array($entry['test'])) {
|
|
// Convert single test condition to multi-level condition
|
|
if (isset($entry['test']['operator'])) {
|
|
$entry['test'] = array($entry['test']);
|
|
}
|
|
|
|
$test_and = FALSE;
|
|
$test_count = count($entry['test']);
|
|
$debug_array = [];
|
|
|
|
//print_debug_vars($entry['test']);
|
|
//print_debug_vars($array);
|
|
foreach ($entry['test'] as $test) {
|
|
if (isset($test['oid'])) {
|
|
// Fetch just the value eof the OID.
|
|
if (isset($entry['mib']) && !str_contains($test['oid'], '::')) {
|
|
$test['data'] = snmp_cache_oid($device, $test['oid'], $entry['mib'], NULL, OBS_SNMP_ALL);
|
|
$oid = $entry['mib'] . '::' . $test['oid'];
|
|
} else {
|
|
$test['data'] = snmp_cache_oid($device, $test['oid'], NULL, NULL, OBS_SNMP_ALL);
|
|
$oid = $test['oid'];
|
|
}
|
|
} elseif (isset($test['field'])) {
|
|
$test['data'] = $array[$test['field']];
|
|
if (!isset($array[$test['field']]) && !str_contains($test['operator'], 'null')) {
|
|
// Show debug error (some time Oid fetched, but not exist for current index)
|
|
print_debug("Not correct Field (" . $test['field'] . ") passed to discovery_check_requires(). Need add it to 'oid_extra' definition.");
|
|
//return FALSE;
|
|
}
|
|
$oid = $test['field'];
|
|
}
|
|
|
|
// If 'and' is TRUE, check all conditions
|
|
if (isset($test['and'])) {
|
|
$test_and = $test_and || $test['and'];
|
|
}
|
|
|
|
$debug_array[] = "$oid [".$test['data']."] ".$test['operator']." [".implode(', ', (array)$test['value'])."]";
|
|
if (test_condition($test['data'], $test['operator'], $test['value']) === FALSE) {
|
|
if ($test_and) { continue; }
|
|
|
|
print_debug("Excluded by not test condition: $oid [".$test['data']."] ".$test['operator']." [".implode(', ', (array)$test['value'])."]");
|
|
return TRUE;
|
|
}
|
|
$test_count--;
|
|
}
|
|
}
|
|
|
|
if ($test_and && $test_count > 0) {
|
|
print_debug("Excluded by not all test conditions:\n " . implode("\n ", $debug_array));
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
function get_pollers() {
|
|
$poller_list = [];
|
|
$poller_list[0] = [ 'name' => 'Default Poller' ];
|
|
|
|
if (OBSERVIUM_EDITION === 'community') { return $poller_list; }
|
|
|
|
if ($GLOBALS['config']['poller_id'] != 0) {
|
|
$poller_list[0]['group'] = 'External';
|
|
}
|
|
foreach(dbFetchRows("SELECT * FROM `pollers`") as $poller) {
|
|
$poller_list[$poller['poller_id']] = [
|
|
'name' => $poller['poller_name'],
|
|
'subtext' => $poller['host_id']
|
|
//'subtext' => $poller['host_uname']
|
|
];
|
|
if ($GLOBALS['config']['poller_id'] != $poller['poller_id']) {
|
|
$poller_list[$poller['poller_id']]['group'] = 'External';
|
|
}
|
|
}
|
|
|
|
return $poller_list;
|
|
}
|
|
|
|
// EOF
|