1036 lines
32 KiB
PHP
1036 lines
32 KiB
PHP
<?php
|
|
|
|
/**
|
|
* PHP Server Monitor
|
|
* Monitor your servers and websites.
|
|
*
|
|
* This file is part of PHP Server Monitor.
|
|
* PHP Server Monitor is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* PHP Server Monitor is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with PHP Server Monitor. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* @package phpservermon
|
|
* @author Pepijn Over <pep@mailbox.org>
|
|
* @copyright Copyright (c) 2008-2017 Pepijn Over <pep@mailbox.org>
|
|
* @license http://www.gnu.org/licenses/gpl.txt GNU GPL v3
|
|
* @version Release: @package_version@
|
|
* @link http://www.phpservermonitor.org/
|
|
**/
|
|
|
|
namespace {
|
|
|
|
###############################################
|
|
#
|
|
# Language functions
|
|
#
|
|
###############################################
|
|
|
|
/**
|
|
* Retrieve language settings from the selected language file
|
|
* Return false if arg is not found
|
|
*
|
|
* @return string|bool
|
|
* @see psm_load_lang()
|
|
*/
|
|
function psm_get_lang()
|
|
{
|
|
$args = func_get_args();
|
|
|
|
if (empty($args)) {
|
|
return isset($GLOBALS['sm_lang']) ? $GLOBALS['sm_lang'] : $GLOBALS['sm_lang_default'];
|
|
}
|
|
|
|
if (isset($GLOBALS['sm_lang'])) {
|
|
$lang = $GLOBALS['sm_lang'];
|
|
$not_found = false;
|
|
foreach ($args as $translation) {
|
|
// if translation does not exist, use default translation
|
|
if (!isset($lang[$translation])) {
|
|
$not_found = true;
|
|
break;
|
|
}
|
|
$lang = $lang[$translation];
|
|
}
|
|
if (!$not_found) {
|
|
return $lang;
|
|
}
|
|
}
|
|
|
|
$lang = $GLOBALS['sm_lang_default'];
|
|
foreach ($args as $translation) {
|
|
$lang = $lang[$translation];
|
|
}
|
|
return $lang;
|
|
}
|
|
|
|
/**
|
|
* Load default language from the English (en_US) language file to the $GLOBALS['sm_lang_default'] variable
|
|
* Load language from the language file to the $GLOBALS['sm_lang'] variable if language is different from default
|
|
*
|
|
* @param string $lang language
|
|
* @see psm_get_lang()
|
|
*/
|
|
function psm_load_lang($lang)
|
|
{
|
|
// load default language - English (en_US)
|
|
// this will also fill in every part that is not translated in other translation files
|
|
$default_lang_file = PSM_PATH_LANG . 'en_US.lang.php';
|
|
|
|
file_exists($default_lang_file) ? require $default_lang_file :
|
|
trigger_error("English translation needs to be installed at all time!", E_USER_ERROR);
|
|
isset($sm_lang) ? $GLOBALS['sm_lang_default'] = $sm_lang :
|
|
trigger_error("\$sm_lang not found in English translation!", E_USER_ERROR);
|
|
unset($sm_lang);
|
|
// load translation is the selected language is not English (en_US)
|
|
if ($lang != "en_US") {
|
|
$lang_file = PSM_PATH_LANG . $lang . '.lang.php';
|
|
file_exists($lang_file) ? require $lang_file :
|
|
trigger_error("Translation file could not be found! Default language will be used.", E_USER_WARNING);
|
|
|
|
isset($sm_lang) ? $GLOBALS['sm_lang'] = $sm_lang :
|
|
trigger_error("\$sm_lang not found in translation file! Default language will be used.", E_USER_WARNING);
|
|
isset($sm_lang['locale']) ? setlocale(LC_TIME, $sm_lang['locale']) :
|
|
trigger_error("locale could not ben found in translation file.", E_USER_WARNING);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve a list with keys of the available languages
|
|
*
|
|
* @return array
|
|
* @see psm_load_lang()
|
|
*/
|
|
function psm_get_langs()
|
|
{
|
|
$fn_ext = '.lang.php';
|
|
$lang_files = glob(PSM_PATH_LANG . '*' . $fn_ext);
|
|
$langs = array();
|
|
|
|
foreach ($lang_files as $file) {
|
|
$key = str_replace($fn_ext, '', basename($file));
|
|
$sm_lang = array();
|
|
if (file_exists($file)) {
|
|
require $file;
|
|
}
|
|
if (isset($sm_lang['name'])) {
|
|
$name = $sm_lang['name'];
|
|
} else {
|
|
$name = $key;
|
|
}
|
|
$langs[$key] = $name;
|
|
unset($sm_lang);
|
|
}
|
|
ksort($langs);
|
|
return $langs;
|
|
}
|
|
|
|
/**
|
|
* Retrieve a list with available sms gateways
|
|
*
|
|
* @return array
|
|
*/
|
|
function psm_get_sms_gateways()
|
|
{
|
|
$sms_gateway_files = glob(PSM_PATH_SMS_GATEWAY . '*.php');
|
|
$sms_gateways = array();
|
|
|
|
foreach ($sms_gateway_files as $file) {
|
|
$name = basename($file, ".php");
|
|
// filter system files out
|
|
if ($name != "Core" && $name != "TxtmsgInterface") {
|
|
$sms_gateways[strtolower($name)] = $name;
|
|
}
|
|
}
|
|
|
|
ksort($sms_gateways);
|
|
return $sms_gateways;
|
|
}
|
|
|
|
/**
|
|
* Get a setting from the config.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $alt if not set, return this alternative
|
|
* @return string
|
|
* @see psm_load_conf()
|
|
*/
|
|
function psm_get_conf($key, $alt = null)
|
|
{
|
|
if (!isset($GLOBALS['sm_config'])) {
|
|
psm_load_conf();
|
|
}
|
|
$result = (isset($GLOBALS['sm_config'][$key])) ? $GLOBALS['sm_config'][$key] : $alt;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Load config from the database to the $GLOBALS['sm_config'] variable
|
|
*
|
|
* @global object $db
|
|
* @return boolean
|
|
* @see psm_get_conf()
|
|
*/
|
|
function psm_load_conf()
|
|
{
|
|
global $db;
|
|
|
|
$GLOBALS['sm_config'] = array();
|
|
|
|
if (!defined('PSM_DB_PREFIX') || !$db->status()) {
|
|
return false;
|
|
}
|
|
if (!$db->ifTableExists(PSM_DB_PREFIX . 'config')) {
|
|
return false;
|
|
}
|
|
$config_db = $db->select(PSM_DB_PREFIX . 'config', null, array('key', 'value'));
|
|
|
|
if (is_array($config_db) && !empty($config_db)) {
|
|
foreach ($config_db as $setting) {
|
|
$GLOBALS['sm_config'][$setting['key']] = $setting['value'];
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update a config setting.
|
|
*
|
|
* If the key does not exist yet it will be created.
|
|
* @global \psm\Service\Database $db
|
|
* @param string $key
|
|
* @param string $value
|
|
*/
|
|
function psm_update_conf($key, $value)
|
|
{
|
|
global $db;
|
|
|
|
// check if key exists
|
|
$exists = psm_get_conf($key, false);
|
|
if ($exists === false) {
|
|
// add new config record
|
|
$db->save(
|
|
PSM_DB_PREFIX . 'config',
|
|
array(
|
|
'key' => $key,
|
|
'value' => $value,
|
|
)
|
|
);
|
|
} else {
|
|
$db->save(
|
|
PSM_DB_PREFIX . 'config',
|
|
array('value' => $value),
|
|
array('key' => $key)
|
|
);
|
|
}
|
|
$GLOBALS['sm_config'][$key] = $value;
|
|
}
|
|
|
|
###############################################
|
|
#
|
|
# Miscellaneous functions
|
|
#
|
|
###############################################
|
|
|
|
/**
|
|
* This function merely adds the message to the log table. It does not perform any checks,
|
|
* everything should have been handled when calling this function
|
|
*
|
|
* @param string $server_id
|
|
* @param string $type
|
|
* @param string $message
|
|
*
|
|
* @return int log_id
|
|
*/
|
|
function psm_add_log($server_id, $type, $message)
|
|
{
|
|
global $db;
|
|
|
|
return $db->save(
|
|
PSM_DB_PREFIX . 'log',
|
|
array(
|
|
'server_id' => $server_id,
|
|
'type' => $type,
|
|
'message' => $message,
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* This function just adds a user to the log_users table.
|
|
*
|
|
* @param $log_id
|
|
* @param $user_id
|
|
*/
|
|
function psm_add_log_user($log_id, $user_id)
|
|
{
|
|
global $db;
|
|
|
|
$db->save(
|
|
PSM_DB_PREFIX . 'log_users',
|
|
array(
|
|
'log_id' => $log_id,
|
|
'user_id' => $user_id,
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* This function adds the result of a check to the uptime table for logging purposes.
|
|
*
|
|
* @param int $server_id
|
|
* @param int $status
|
|
* @param string $latency
|
|
*/
|
|
function psm_log_uptime($server_id, $status, $latency)
|
|
{
|
|
global $db;
|
|
|
|
$db->save(
|
|
PSM_DB_PREFIX . 'servers_uptime',
|
|
array(
|
|
'server_id' => $server_id,
|
|
'date' => date('Y-m-d H:i:s'),
|
|
'status' => $status,
|
|
'latency' => $latency,
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Converts an interval into a string
|
|
*
|
|
* @param DateInterval $interval
|
|
* @return string
|
|
*/
|
|
function psm_format_interval(DateInterval $interval)
|
|
{
|
|
$result = "";
|
|
|
|
if ($interval->y) {
|
|
$result .= $interval->format("%y ") . (($interval->y == 1) ?
|
|
psm_get_lang('system', 'year') : psm_get_lang('system', 'years')) . " ";
|
|
}
|
|
if ($interval->m) {
|
|
$result .= $interval->format("%m ") . (($interval->m == 1) ?
|
|
psm_get_lang('system', 'month') : psm_get_lang('system', 'months')) . " ";
|
|
}
|
|
if ($interval->d) {
|
|
$result .= $interval->format("%d ") . (($interval->d == 1) ?
|
|
psm_get_lang('system', 'day') : psm_get_lang('system', 'days')) . " ";
|
|
}
|
|
if ($interval->h) {
|
|
$result .= $interval->format("%h ") . (($interval->h == 1) ?
|
|
psm_get_lang('system', 'hour') : psm_get_lang('system', 'hours')) . " ";
|
|
}
|
|
if ($interval->i) {
|
|
$result .= $interval->format("%i ") . (($interval->i == 1) ?
|
|
psm_get_lang('system', 'minute') : psm_get_lang('system', 'minutes')) . " ";
|
|
}
|
|
if ($interval->s) {
|
|
$result .= $interval->format("%s ") . (($interval->s == 1) ?
|
|
psm_get_lang('system', 'second') : psm_get_lang('system', 'seconds')) . " ";
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Parses a string from the language file with the correct variables replaced in the message
|
|
*
|
|
* @param boolean|null $status
|
|
* @param string $type is either 'sms', 'email', 'pushover_title', 'pushover_message' or 'telegram_message'
|
|
* @param array $vars server information about the server which may be placed in a message:
|
|
* %KEY% will be replaced by your value
|
|
* @param boolean $combi parse other message if notifications need to be send combined
|
|
* @return string parsed message
|
|
*/
|
|
function psm_parse_msg($status, $type, $vars, $combi = false)
|
|
{
|
|
if (is_bool($status)) {
|
|
$status = ($status === true) ? 'on_' : 'off_';
|
|
}
|
|
|
|
$combi = ($combi === true) ? 'combi_' : '';
|
|
|
|
$message = psm_get_lang('notifications', $combi . $status . $type);
|
|
|
|
if (!$message) {
|
|
return $message;
|
|
}
|
|
$vars['date'] = date('Y-m-d H:i:s');
|
|
|
|
foreach ($vars as $k => $v) {
|
|
$message = str_replace('%' . strtoupper($k) . '%', $v, $message);
|
|
}
|
|
|
|
return $message;
|
|
}
|
|
|
|
/**
|
|
* Shortcut to curl_init(), curl_exec and curl_close()
|
|
*
|
|
* @param string $href
|
|
* @param boolean $header return headers?
|
|
* @param boolean $body return body?
|
|
* @param int|null $timeout connection timeout in seconds. defaults to PSM_CURL_TIMEOUT (10 secs).
|
|
* @param boolean $add_agent add user agent?
|
|
* @param string|bool $website_username Username website
|
|
* @param string|bool $website_password Password website
|
|
* @param string|null $request_method Request method like GET, POST etc.
|
|
* @param string|null $post_field POST data
|
|
* @return array cURL result
|
|
*/
|
|
function psm_curl_get(
|
|
$href,
|
|
$header = false,
|
|
$body = true,
|
|
$timeout = null,
|
|
$add_agent = true,
|
|
$website_username = false,
|
|
$website_password = false,
|
|
$request_method = null,
|
|
$post_field = null
|
|
) {
|
|
($timeout === null || $timeout > 0) ? PSM_CURL_TIMEOUT : intval($timeout);
|
|
|
|
$ch = curl_init();
|
|
if (defined('PSM_DEBUG') && PSM_DEBUG === true && psm_is_cli()) {
|
|
curl_setopt($ch, CURLOPT_VERBOSE, true);
|
|
}
|
|
curl_setopt($ch, CURLOPT_HEADER, $header);
|
|
curl_setopt($ch, CURLOPT_NOBODY, (!$body));
|
|
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
|
|
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
|
|
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
|
|
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
|
|
curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
|
|
curl_setopt($ch, CURLOPT_ENCODING, '');
|
|
curl_setopt($ch, CURLOPT_CERTINFO, 1);
|
|
|
|
if (!empty($request_method)) {
|
|
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $request_method);
|
|
}
|
|
|
|
if (!empty($post_field)) {
|
|
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_field);
|
|
}
|
|
|
|
if (
|
|
$website_username !== false &&
|
|
$website_password !== false &&
|
|
!empty($website_username) &&
|
|
!empty($website_password)
|
|
) {
|
|
curl_setopt($ch, CURLOPT_USERPWD, $website_username . ":" . $website_password);
|
|
}
|
|
|
|
$href = preg_replace('/(.*)(%cachebuster%)/', '$0' . time(), $href);
|
|
|
|
curl_setopt($ch, CURLOPT_URL, $href);
|
|
|
|
$proxy_url = psm_get_conf('proxy_url', '');
|
|
if (psm_get_conf('proxy', '0') === '1') {
|
|
curl_setopt($ch, CURLOPT_PROXY, $proxy_url);
|
|
$proxy_user = psm_get_conf('proxy_user', '');
|
|
$proxy_password = psm_get_conf('proxy_password', '');
|
|
if (!empty($proxy_user) && !empty($proxy_password)) {
|
|
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy_user . ':' . $proxy_password);
|
|
}
|
|
}
|
|
|
|
if ($add_agent) {
|
|
curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (compatible; phpservermon/' .
|
|
PSM_VERSION . '; +https://github.com/phpservermon/phpservermon)');
|
|
}
|
|
|
|
$result['exec'] = curl_exec($ch);
|
|
$result['info'] = curl_getinfo($ch);
|
|
|
|
curl_close($ch);
|
|
|
|
if (defined('PSM_DEBUG') && PSM_DEBUG === true && psm_is_cli()) {
|
|
echo PHP_EOL .
|
|
'==============cURL Result for: ' . $href . '===========================================' . PHP_EOL;
|
|
print_r($result);
|
|
echo PHP_EOL .
|
|
'==============END cURL Resul for: ' . $href . '===========================================' . PHP_EOL;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Get a "nice" timespan message
|
|
*
|
|
* Source: http://www.interactivetools.com/forum/forum-posts.php?postNum=2208966
|
|
* @param string $time
|
|
* @return string
|
|
*/
|
|
function psm_timespan($time)
|
|
{
|
|
if (empty($time) || $time == '0000-00-00 00:00:00') {
|
|
return psm_get_lang('system', 'never');
|
|
}
|
|
if ($time !== intval($time)) {
|
|
$time = strtotime($time);
|
|
}
|
|
if ($time < strtotime(date('Y-m-d 00:00:00')) - 60 * 60 * 24 * 3) {
|
|
$format = psm_get_lang('system', (date('Y') !== date('Y', $time)) ?
|
|
'long_day_format' : 'short_day_format');
|
|
// Check for Windows to find and replace the %e
|
|
// modifier correctly
|
|
if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
|
|
$format = preg_replace('#(?<!%)((?:%%)*)%e#', '\1%#d', $format);
|
|
}
|
|
return strftime($format, $time);
|
|
}
|
|
$d = time() - $time;
|
|
if ($d >= 60 * 60 * 24) {
|
|
$format = psm_get_lang('system', (date('l', time() - 60 * 60 * 24) == date('l', $time)) ?
|
|
'yesterday_format' : 'other_day_format');
|
|
return strftime($format, $time);
|
|
}
|
|
if ($d >= 60 * 60 * 2) {
|
|
return sprintf(psm_get_lang('system', 'hours_ago'), intval($d / (60 * 60)));
|
|
}
|
|
if ($d >= 60 * 60) {
|
|
return psm_get_lang('system', 'an_hour_ago');
|
|
}
|
|
if ($d >= 60 * 2) {
|
|
return sprintf(psm_get_lang('system', 'minutes_ago'), intval($d / 60));
|
|
}
|
|
if ($d >= 60) {
|
|
return psm_get_lang('system', 'a_minute_ago');
|
|
}
|
|
if ($d >= 2) {
|
|
return sprintf(psm_get_lang('system', 'seconds_ago'), intval($d));
|
|
}
|
|
|
|
return psm_get_lang('system', 'a_second_ago');
|
|
}
|
|
|
|
/**
|
|
* Get a localised date from MySQL date format
|
|
* @param string $time
|
|
* @return string
|
|
*/
|
|
function psm_date($time)
|
|
{
|
|
if (empty($time) || $time == '0000-00-00 00:00:00') {
|
|
return psm_get_lang('system', 'never');
|
|
}
|
|
return strftime('%x %X', strtotime($time));
|
|
}
|
|
|
|
/**
|
|
* Check if an update is available for PHP Server Monitor.
|
|
*
|
|
* Will only check for new version if user turned updates on in config.
|
|
* @return boolean
|
|
*/
|
|
function psm_update_available()
|
|
{
|
|
if (!psm_get_conf('show_update')) {
|
|
// user does not want updates, fair enough.
|
|
return false;
|
|
}
|
|
|
|
$last_update = psm_get_conf('last_update_check');
|
|
|
|
if ((time() - PSM_UPDATE_INTERVAL) > $last_update) {
|
|
// been more than a week since update, lets go
|
|
// update last check date
|
|
psm_update_conf('last_update_check', time());
|
|
$latest = psm_curl_get(PSM_UPDATE_URL);
|
|
if ($latest['info'] === false || (int)$latest['info']['http_code'] >= 300) {
|
|
// error
|
|
return false;
|
|
}
|
|
// extract latest version from Github.
|
|
$githubInfo = json_decode($latest['exec']);
|
|
if (property_exists($githubInfo, 'tag_name') === false) {
|
|
// version not found
|
|
return false;
|
|
}
|
|
$tagName = $githubInfo->tag_name;
|
|
$latestVersion = str_replace('v', '', $tagName);
|
|
// check from old version ... maybe has reason but I don't think so ...
|
|
if (empty($latestVersion) === true || strlen($latestVersion) >= 15) {
|
|
// weird version
|
|
return false;
|
|
}
|
|
// add latest version to database
|
|
psm_update_conf('version_update_check', $latestVersion);
|
|
} else {
|
|
$latestVersion = psm_get_conf('version_update_check');
|
|
}
|
|
|
|
$current = psm_get_conf('version');
|
|
return version_compare($latestVersion, $current, '>');
|
|
}
|
|
|
|
/**
|
|
* Prepare a new phpmailer instance.
|
|
*
|
|
* If the from name and email are left blank they will be prefilled from the config.
|
|
* @param string $from_name
|
|
* @param string $from_email
|
|
* @return \PHPMailer\PHPMailer\PHPMailer
|
|
*/
|
|
function psm_build_mail($from_name = null, $from_email = null)
|
|
{
|
|
$phpmailer = new \PHPMailer\PHPMailer\PHPMailer();
|
|
$phpmailer->Encoding = "base64";
|
|
$phpmailer->CharSet = 'UTF-8';
|
|
$phpmailer->SMTPDebug = 0;
|
|
|
|
if (psm_get_conf('email_smtp') == '1') {
|
|
$phpmailer->IsSMTP();
|
|
$phpmailer->Host = psm_get_conf('email_smtp_host');
|
|
$phpmailer->Port = (int) psm_get_conf('email_smtp_port');
|
|
$phpmailer->SMTPSecure = psm_get_conf('email_smtp_security');
|
|
|
|
$smtp_user = psm_get_conf('email_smtp_username');
|
|
$smtp_pass = psm_password_decrypt(
|
|
psm_get_conf('password_encrypt_key'),
|
|
psm_get_conf('email_smtp_password')
|
|
);
|
|
|
|
if ($smtp_user != '' && $smtp_pass != '') {
|
|
$phpmailer->SMTPAuth = true;
|
|
$phpmailer->Username = $smtp_user;
|
|
$phpmailer->Password = $smtp_pass;
|
|
}
|
|
} else {
|
|
$phpmailer->IsMail();
|
|
}
|
|
if ($from_name == null) {
|
|
$from_name = psm_get_conf('email_from_name');
|
|
}
|
|
if ($from_email == null) {
|
|
$from_email = psm_get_conf('email_from_email');
|
|
}
|
|
$phpmailer->SetFrom($from_email, $from_name);
|
|
|
|
return $phpmailer;
|
|
}
|
|
|
|
/**
|
|
* Prepare a new Pushover util.
|
|
*
|
|
* @return \Pushover
|
|
*/
|
|
function psm_build_pushover()
|
|
{
|
|
$pushover = new \Pushover();
|
|
$pushover->setToken(psm_get_conf('pushover_api_token'));
|
|
|
|
return $pushover;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return \Telegram
|
|
*/
|
|
function psm_build_telegram()
|
|
{
|
|
$telegram = new \Telegram();
|
|
$telegram->setToken(psm_get_conf('telegram_api_token'));
|
|
|
|
return $telegram;
|
|
}
|
|
|
|
/**
|
|
* Send message via XMPP.
|
|
*
|
|
* @param string $host
|
|
* @param string $username
|
|
* @param string $password
|
|
* @param array $receivers
|
|
* @param string $message
|
|
* @param int|null $port
|
|
* @param string|null $domain
|
|
*/
|
|
function psm_jabber_send_message($host, $username, $password, $receivers, $message, $port = null, $domain = null)
|
|
{
|
|
$options = [
|
|
'jid' => $username, // incl. gmail.com
|
|
'pass' => $password,
|
|
'domain' => $domain, // gmail.com or null
|
|
'host' => $host, // talk.google.com
|
|
'port' => $port, // talk.google.com needs to have 5223 ... 5222 - CN problem - gmail.com vs talk.google.com
|
|
'log_path' => __DIR__ . '/../../logs/jaxl.log', // own log
|
|
|
|
// force tls
|
|
'force_tls' => PSM_JABBER_FORCE_TLS,
|
|
// (required) perform X-OAUTH2
|
|
'auth_type' => PSM_JABBER_AUTH_TYPE, //'X-OAUTH2', // auth failure with this option :( so just PLAIN ...
|
|
|
|
'log_level' => PSM_JABBER_DEBUG_LEVEL
|
|
];
|
|
|
|
try {
|
|
$client = new JAXL($options);
|
|
|
|
// Add Callbacks
|
|
$client->add_cb('on_auth_success', function () use ($client, $receivers, $message) {
|
|
JAXLLogger::info('got on_auth_success cb');
|
|
foreach ($receivers as $receiver) {
|
|
$client->send_chat_msg($receiver, $message);
|
|
}
|
|
$client->send_end_stream();
|
|
});
|
|
$client->add_cb('on_auth_failure', function ($reason) use ($client) {
|
|
$client->send_end_stream();
|
|
JAXLLogger::info('got on_auth_failure cb with reason: ' . $reason);
|
|
});
|
|
$client->add_cb('on_disconnect', function () use ($client) {
|
|
JAXLLogger::info('got on_disconnect cb');
|
|
});
|
|
|
|
$client->start();
|
|
} catch (Exception $ex) {
|
|
JAXLLogger::error('Exception: ' . $ex->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepare a new SMS util.
|
|
*
|
|
* @return \psm\Txtmsg\TxtmsgInterface
|
|
*/
|
|
function psm_build_sms()
|
|
{
|
|
$sms = null;
|
|
|
|
// open the right class
|
|
// not making this any more dynamic, because perhaps some gateways need custom settings
|
|
switch (strtolower(psm_get_conf('sms_gateway'))) {
|
|
case 'mosms':
|
|
$sms = new \psm\Txtmsg\Mosms();
|
|
break;
|
|
case 'smsit':
|
|
$sms = new \psm\Txtmsg\Smsit();
|
|
break;
|
|
case 'inetworx':
|
|
$sms = new \psm\Txtmsg\Inetworx();
|
|
break;
|
|
case 'messagebird':
|
|
$sms = new \psm\Txtmsg\Messagebird();
|
|
break;
|
|
case 'spryng':
|
|
$sms = new \psm\Txtmsg\Spryng();
|
|
break;
|
|
case 'clickatell':
|
|
$sms = new \psm\Txtmsg\Clickatell();
|
|
break;
|
|
case 'textmarketer':
|
|
$sms = new \psm\Txtmsg\Textmarketer();
|
|
break;
|
|
case 'smsglobal':
|
|
$sms = new \psm\Txtmsg\Smsglobal();
|
|
break;
|
|
case 'freevoipdeal':
|
|
$sms = new \psm\Txtmsg\FreeVoipDeal();
|
|
break;
|
|
case 'nexmo':
|
|
$sms = new \psm\Txtmsg\Nexmo();
|
|
break;
|
|
case 'freemobilesms':
|
|
$sms = new \psm\Txtmsg\FreeMobileSMS();
|
|
break;
|
|
case 'clicksend':
|
|
$sms = new \psm\Txtmsg\ClickSend();
|
|
break;
|
|
case 'octopush':
|
|
$sms = new \psm\Txtmsg\Octopush();
|
|
break;
|
|
case 'smsgw':
|
|
$sms = new \psm\Txtmsg\Smsgw();
|
|
break;
|
|
case 'twilio':
|
|
$sms = new \psm\Txtmsg\Twilio();
|
|
break;
|
|
case 'cmbulksms':
|
|
$sms = new \psm\Txtmsg\CMBulkSMS();
|
|
break;
|
|
case 'gatewayapi':
|
|
$sms = new \psm\Txtmsg\GatewayAPI();
|
|
break;
|
|
case 'callr':
|
|
$sms = new \psm\Txtmsg\Callr();
|
|
break;
|
|
case 'plivo':
|
|
$sms = new \psm\Txtmsg\Plivo();
|
|
break;
|
|
case 'solutionsinfini':
|
|
$sms = new \psm\Txtmsg\SolutionsInfini();
|
|
break;
|
|
}
|
|
|
|
// copy login information from the config file
|
|
if ($sms) {
|
|
$sms->setLogin(psm_get_conf('sms_gateway_username'), psm_get_conf('sms_gateway_password'));
|
|
$sms->setOriginator(psm_get_conf('sms_from'));
|
|
}
|
|
|
|
return $sms;
|
|
}
|
|
|
|
/**
|
|
* Generate a new link to the current monitor
|
|
* @param array|string $params key value pairs or pre-formatted string
|
|
* @param boolean $urlencode urlencode all params?
|
|
* @param boolean $htmlentities use entities in url?
|
|
* @return string
|
|
*/
|
|
function psm_build_url($params = array(), $urlencode = true, $htmlentities = true)
|
|
{
|
|
if (defined('PSM_BASE_URL') && PSM_BASE_URL !== null) {
|
|
$url = PSM_BASE_URL;
|
|
} else {
|
|
$url = ((isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off') ||
|
|
$_SERVER['SERVER_PORT'] == 443 ? 'https' : 'http') . '://' . $_SERVER['HTTP_HOST'];
|
|
// on Windows, dirname() adds both back- and forward slashes (http://php.net/dirname).
|
|
// for urls, we only want the forward slashes.
|
|
$url .= dirname($_SERVER['SCRIPT_NAME']);
|
|
$url = str_replace('\\', '', $url);
|
|
}
|
|
$url = rtrim($url, '/') . '/';
|
|
|
|
if ($params != null) {
|
|
$url .= '?';
|
|
if (is_array($params)) {
|
|
$delim = ($htmlentities) ? '&' : '&';
|
|
|
|
foreach ($params as $k => $v) {
|
|
if ($urlencode) {
|
|
$v = urlencode($v);
|
|
}
|
|
$url .= $delim . $k . '=' . $v;
|
|
}
|
|
} else {
|
|
$url .= $params;
|
|
}
|
|
}
|
|
|
|
return $url;
|
|
}
|
|
|
|
/**
|
|
* Try existence of a GET var, if not return the alternative
|
|
* @param string $key
|
|
* @param string $alt
|
|
* @return mixed
|
|
*/
|
|
function psm_GET($key, $alt = null)
|
|
{
|
|
if (isset($_GET[$key])) {
|
|
return $_GET[$key];
|
|
} else {
|
|
return $alt;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Try existence of a POST var, if not return the alternative
|
|
* @param string $key
|
|
* @param string|array|bool $alt
|
|
* @return mixed
|
|
*/
|
|
function psm_POST($key, $alt = null)
|
|
{
|
|
if (isset($_POST[$key])) {
|
|
return $_POST[$key];
|
|
} else {
|
|
return $alt;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if we are in CLI mode
|
|
*
|
|
* Note, php_sapi cannot be used because cgi-fcgi returns both for web and cli.
|
|
* @return boolean
|
|
*/
|
|
function psm_is_cli()
|
|
{
|
|
return (!isset($_SERVER['SERVER_SOFTWARE']) || php_sapi_name() == 'cli');
|
|
}
|
|
|
|
###############################################
|
|
#
|
|
# Debug functions
|
|
#
|
|
###############################################
|
|
|
|
/**
|
|
* Only used for debugging and testing
|
|
*
|
|
* @param mixed $arr
|
|
*/
|
|
function pre($arr = null)
|
|
{
|
|
echo "<pre>";
|
|
if ($arr === null) {
|
|
debug_print_backtrace();
|
|
}
|
|
print_r($arr);
|
|
echo "</pre>";
|
|
}
|
|
|
|
/**
|
|
* Send headers to the browser to avoid caching
|
|
*/
|
|
function psm_no_cache()
|
|
{
|
|
header("Expires: Mon, 20 Dec 1998 01:00:00 GMT");
|
|
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
|
|
header("Cache-Control: no-cache, must-revalidate");
|
|
header("Pragma: no-cache");
|
|
}
|
|
|
|
/**
|
|
* Encrypts the password for storage in the database
|
|
*
|
|
* @param string $key
|
|
* @param string $password
|
|
* @return string
|
|
* @author Pavel Laupe Dvorak <pavel@pavel-dvorak.cz>
|
|
*/
|
|
function psm_password_encrypt($key, $password)
|
|
{
|
|
if (empty($password)) {
|
|
return '';
|
|
}
|
|
|
|
if (empty($key)) {
|
|
throw new \InvalidArgumentException('invalid_encryption_key');
|
|
}
|
|
|
|
// using open ssl
|
|
$cipher = "AES-256-CBC";
|
|
$ivlen = openssl_cipher_iv_length($cipher);
|
|
$iv = openssl_random_pseudo_bytes($ivlen);
|
|
$encrypted = base64_encode(
|
|
$iv .
|
|
openssl_encrypt(
|
|
$password,
|
|
$cipher,
|
|
hash('sha256', $key, true),
|
|
OPENSSL_RAW_DATA, // OPENSSL_ZERO_PADDING OPENSSL_RAW_DATA
|
|
$iv
|
|
)
|
|
);
|
|
|
|
return $encrypted;
|
|
}
|
|
|
|
/**
|
|
* Decrypts password stored in the database for future use
|
|
*
|
|
* @param string $key
|
|
* @param string $encryptedString
|
|
* @return string
|
|
* @author Pavel Laupe Dvorak <pavel@pavel-dvorak.cz>
|
|
*/
|
|
function psm_password_decrypt($key, $encryptedString)
|
|
{
|
|
if (empty($encryptedString)) {
|
|
return '';
|
|
}
|
|
|
|
if (empty($key)) {
|
|
throw new \InvalidArgumentException('invalid_encryption_key');
|
|
}
|
|
|
|
// using open ssl
|
|
$data = base64_decode($encryptedString);
|
|
$cipher = "AES-256-CBC";
|
|
$ivlen = openssl_cipher_iv_length($cipher);
|
|
$iv = substr($data, 0, $ivlen);
|
|
$decrypted = openssl_decrypt(
|
|
substr($data, $ivlen),
|
|
$cipher,
|
|
hash('sha256', $key, true),
|
|
OPENSSL_RAW_DATA,
|
|
$iv
|
|
);
|
|
|
|
return $decrypted;
|
|
}
|
|
|
|
/**
|
|
* Send notification to Telegram
|
|
*
|
|
* @return string
|
|
* @author Tim Zandbergen <tim@xervion.nl>
|
|
*/
|
|
class Telegram
|
|
{
|
|
private $token;
|
|
private $user;
|
|
private $message;
|
|
private $url;
|
|
|
|
public function setToken($token)
|
|
{
|
|
$this->token = (string) $token;
|
|
}
|
|
public function setUser($user)
|
|
{
|
|
$this->user = (string) $user;
|
|
}
|
|
public function setMessage($message)
|
|
{
|
|
$message = str_replace("<ul>", "", $message);
|
|
$message = str_replace("</ul>", "\n", $message);
|
|
$message = str_replace("<li>", "- ", $message);
|
|
$message = str_replace("</li>", "\n", $message);
|
|
$message = str_replace("<br>", "\n", $message);
|
|
$message = str_replace("<br/>", "\n", $message);
|
|
$this->message = (string) $message;
|
|
}
|
|
public function sendurl()
|
|
{
|
|
$con = curl_init($this->url);
|
|
curl_setopt($con, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($con, CURLOPT_CONNECTTIMEOUT, 5);
|
|
curl_setopt($con, CURLOPT_TIMEOUT, 60);
|
|
$response = curl_exec($con);
|
|
$response = json_decode($response, true);
|
|
return $response;
|
|
}
|
|
public function send()
|
|
{
|
|
if (!empty($this->token) && !empty($this->user) && !empty($this->message)) {
|
|
$this->url = 'https://api.telegram.org/bot' . urlencode($this->token) .
|
|
'/sendMessage?chat_id=' . urlencode($this->user) . '&text=' .
|
|
urlencode($this->message) . '&parse_mode=HTML&disable_web_page_preview=True';
|
|
}
|
|
return $this->sendurl();
|
|
}
|
|
// Get the bots username
|
|
public function getBotUsername()
|
|
{
|
|
if (!empty($this->token)) {
|
|
$this->url = 'https://api.telegram.org/bot' . urlencode($this->token) . '/getMe';
|
|
}
|
|
return $this->sendurl();
|
|
}
|
|
}
|
|
}
|