902 lines
25 KiB
PHP
902 lines
25 KiB
PHP
<?php
|
|
require 'config/application.php';
|
|
|
|
$session = null;
|
|
if (isset($_SERVER['REQUEST_URI'])) {
|
|
if (!isset($_COOKIE['_session']) || !file_exists('/tmp/apcontrol-sessions')) {
|
|
if (substr($_SERVER['REQUEST_URI'],0,5) === '/api/') {
|
|
http_response_code(403); die('<h3>403, API Forbidden</h3>');
|
|
}
|
|
header('Location: login.php'); die;
|
|
}
|
|
$session = trim($_COOKIE['_session']);
|
|
$ps_sess = explode('.', $session);
|
|
$sessions = explode("\n", trim(file_get_contents('/tmp/apcontrol-sessions')));
|
|
if (!in_array($session, $sessions) || !isset($GLOBALS['appconf']['users'][$ps_sess[0]])) {
|
|
if (substr($_SERVER['REQUEST_URI'],0,5) === '/api/') {
|
|
http_response_code(403); die('<h3>403, API Forbidden</h3>');
|
|
}
|
|
header('Location: login.php'); die;
|
|
}
|
|
unset($sessions);
|
|
unset($ps_sess);
|
|
}
|
|
|
|
function __session_delete($user) {
|
|
if (!file_exists('/tmp/apcontrol-sessions'))
|
|
return false;
|
|
$newsessions = [];
|
|
$sessions = explode("\n", trim(file_get_contents('/tmp/apcontrol-sessions')));
|
|
foreach ($sessions as $session) {
|
|
$ps = explode('.', $session);
|
|
if ($ps[0] !== $user)
|
|
$newsessions []= $session;
|
|
}
|
|
file_put_contents('/tmp/apcontrol-sessions', implode("\n", $newsessions));
|
|
return true;
|
|
}
|
|
|
|
if (!file_exists($GLOBALS['appconf']['data_dir']))
|
|
mkdir($GLOBALS['appconf']['data_dir']);
|
|
|
|
|
|
// global variables
|
|
$GLOBALS['_cache'] = [];
|
|
$GLOBALS['supported_ap_software'] = [
|
|
'mastodon',
|
|
];
|
|
|
|
// functions
|
|
function apiresult($data, $code=200) {
|
|
if (isset($GLOBALS['IS_PHP']) && $GLOBALS['IS_PHP']) {
|
|
$GLOBALS['api_data'] = $data;
|
|
return false;
|
|
}
|
|
if (isset($_SERVER['REQUEST_URI'])) {
|
|
if ($code !== 200) http_response_code($code);
|
|
header('Content-Type: application/json');
|
|
}
|
|
|
|
if (isset($GLOBALS['http_cache_config'])
|
|
&& gettype($data) !== 'string'
|
|
&& !isset($data['error'])
|
|
&& !isset($data['ok']))
|
|
content_cache__put($GLOBALS['http_cache_config']['key'],
|
|
'ondemand,'.$GLOBALS['http_cache_config']['seconds'], $data);
|
|
|
|
if (gettype($data) !== 'string')
|
|
echo json_encode($data);
|
|
else echo $data;
|
|
die;
|
|
}
|
|
|
|
function no_http() {
|
|
if (isset($_SERVER['REQUEST_URI']))
|
|
die('<h3>Forbidden, this method can only be called from shell</h3>');
|
|
}
|
|
|
|
function arg($arg, $default=null, $validator=null) {
|
|
$arg = trim($arg);
|
|
$type = null;
|
|
|
|
$require = false;
|
|
if (strpos($arg,'*') === 0) {
|
|
$require = true;
|
|
$arg = substr($arg, 1);
|
|
}
|
|
|
|
if (strpos($arg,'s:') === 0) {
|
|
$type = 'string';
|
|
$arg = substr($arg, 2);
|
|
} else if (strpos($arg,'i:') === 0) {
|
|
$type = 'integer';
|
|
$arg = substr($arg, 2);
|
|
} else if (strpos($arg,'d:') === 0) {
|
|
$type = 'double';
|
|
$arg = substr($arg, 2);
|
|
} else if (strpos($arg, 'b:') === 0) {
|
|
$type = 'boolean';
|
|
$arg = substr($arg, 2);
|
|
} else if (strpos($arg,'b64:') === 0) {
|
|
$type = 'base64';
|
|
$arg = substr($arg, 4);
|
|
} else if (strpos($arg,'set:') === 0) {
|
|
$type = 'exists';
|
|
$arg = substr($arg, 4);
|
|
}
|
|
|
|
$ps = explode('.', $arg);
|
|
$value = null;
|
|
$arr = null;
|
|
switch (strtolower($ps[0])) {
|
|
case 'get':
|
|
$arr = '_GET';
|
|
break;
|
|
case 'post':
|
|
$arr = '_POST';
|
|
break;
|
|
}
|
|
if ($arr === null)
|
|
$arr = $ps[0];
|
|
eval('$value = isset($'.$arr.'["'.$ps[1].'"]) ? $'.$arr.'["'.$ps[1].'"] : null;');
|
|
|
|
if ($type === 'exists')
|
|
return $value !== null;
|
|
if ($value === null)
|
|
return !$require ? $default : apiresult(['error' => '<'.$arg.'> parameter must be specified'], 400);
|
|
|
|
if (gettype($value) === 'string')
|
|
$value = trim($value);
|
|
if ($type === 'string')
|
|
$value = strval($value);
|
|
else if ($type === 'integer')
|
|
$value = intval($value);
|
|
else if ($type === 'double')
|
|
$value = doubleval($value);
|
|
else if ($type === 'boolean')
|
|
$value = in_array($value,[1,"1","yes","true"]) ? true : false;
|
|
else if ($type === 'base64')
|
|
$value = base64_decode($value);
|
|
|
|
if ($validator !== null) {
|
|
$bool = false;
|
|
eval('$bool = '.$validator.'($value);');
|
|
if (!$bool)
|
|
return apiresult(['error' => '<'.$arg.'> parameter validation has failed'], 400);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
function mod_php($module_name=null) {
|
|
$null_mod = false;
|
|
if ($module_name === null) {
|
|
$null_mod = true;
|
|
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
|
|
$fl = preg_replace('#^'.__DIR__.'#', '', $trace[0]['file']);
|
|
$fl = trim($fl, '/');
|
|
$module_name = substr($fl, 0, strrpos($fl,'/'));
|
|
}
|
|
|
|
$is_php_set = isset($GLOBALS['IS_PHP']) && $GLOBALS['IS_PHP'];
|
|
if (!$null_mod) {
|
|
$GLOBALS['IS_PHP'] = true;
|
|
unset($GLOBALS['api_data']);
|
|
}
|
|
if (!file_exists($module_name.'/mod.php'))
|
|
return 'does_not_exist';
|
|
require $module_name.'/mod.php';
|
|
if (!$null_mod) {
|
|
if (!$is_php_set)
|
|
unset($GLOBALS['IS_PHP']);
|
|
return $GLOBALS['api_data'];
|
|
}
|
|
}
|
|
|
|
function filedb_exists($ns, $file=''){ return file_exists(filedb_getdir($ns,$file)); }
|
|
function filedb_getdir($ns, $file='') {
|
|
$dir = $GLOBALS['appconf']['data_dir'];
|
|
$ns = trim($ns, '/');
|
|
$dir = realpath($dir.'/'.$ns);
|
|
if (strpos($dir, $GLOBALS['appconf']['data_dir']) === false)
|
|
return false;
|
|
return $dir.'/'.$file;
|
|
}
|
|
|
|
function filedb_put($ns, $file='', $content=null) {
|
|
$dir = $GLOBALS['appconf']['data_dir'];
|
|
$ns = trim($ns, '/');
|
|
foreach (explode('/', $ns) as $d) {
|
|
$dir .= '/'.$d;
|
|
if (!file_exists($dir))
|
|
mkdir($dir);
|
|
}
|
|
$dir = realpath($dir);
|
|
if (strpos($dir, $GLOBALS['appconf']['data_dir']) === false)
|
|
return false;
|
|
if ($file === '')
|
|
return true;
|
|
$content_file = $dir.'/'.$file;
|
|
if ($content === null)
|
|
return touch($content_file);
|
|
return file_put_contents($content_file, $content);
|
|
}
|
|
|
|
function filedb_del($ns, $file='') {
|
|
$file = filedb_getdir($ns, $file);
|
|
if ($file === false || !file_exists($file))
|
|
return false;
|
|
if (is_dir($file))
|
|
return rmdir($file);
|
|
return unlink($file);
|
|
}
|
|
|
|
function filedb_delall($ns) {
|
|
if (!filedb_exists($ns))
|
|
return false;
|
|
foreach (scandir(filedb_getdir($ns)) as $fil) {
|
|
if (in_array($fil, ['.','..']))
|
|
continue;
|
|
filedb_del($ns, $fil);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function filedb_get($ns, $file) {
|
|
$file = filedb_getdir($ns, $file);
|
|
if ($file === false)
|
|
return false;
|
|
if (!file_exists($file))
|
|
return null;
|
|
return file_get_contents($file);
|
|
}
|
|
|
|
function instance_config($software=null, $instance=null) {
|
|
if ($software === null) {
|
|
foreach ($GLOBALS['supported_ap_software'] as $sf) {
|
|
$result = instance_config($sf);
|
|
if ($result !== null)
|
|
return $result;
|
|
}
|
|
return null;
|
|
}
|
|
if (!in_array($software, $GLOBALS['supported_ap_software']))
|
|
return null;
|
|
|
|
if ($instance === null && isset($_GET['instance']))
|
|
$instance = trim($_GET['instance']);
|
|
|
|
if ($instance === null)
|
|
return apiresult(['error' => '<instance> GET argument must be provided'], 400);
|
|
|
|
$GLOBALS['ap_instance'] = $instance;
|
|
$GLOBALS['ap_software'] = $software;
|
|
if (isset($GLOBALS['_cache'][$software.$instance]))
|
|
return $GLOBALS['_cache'][$software.$instance];
|
|
|
|
mod_php('api/v1/config/get');
|
|
if (!isset($GLOBALS['api_data']))
|
|
return null;
|
|
|
|
|
|
$found = false;
|
|
foreach ($GLOBALS['api_data']['hosts'][$software] as $ins_cfg) {
|
|
if ($ins_cfg['instance'] === $instance) {
|
|
$found = $ins_cfg;
|
|
}
|
|
}
|
|
if ($found === false)
|
|
return null;
|
|
|
|
$config = [];
|
|
$config_raw = explode("\n", trim($found['config']));
|
|
foreach ($config_raw as $ln) {
|
|
$k = substr($ln, 0, strpos($ln,'='));
|
|
$v = substr($ln, strpos($ln,'=')+1);
|
|
$config[$k] = $v;
|
|
}
|
|
|
|
$GLOBALS['_cache'][$software.$instance] = $config;
|
|
return $config;
|
|
}
|
|
|
|
function instance_config_require($software, $instance=null) {
|
|
$config = instance_config($software, $instance);
|
|
if ($config === null)
|
|
apiresult(['error' => 'instance parameter is incorrect. Does not exist'], 400);
|
|
return $config;
|
|
}
|
|
|
|
function instance_http_get($url) { return instance_http_request($url, 'GET'); }
|
|
function instance_http_post($url, $data=null) { return instance_http_request($url, 'POST', $data); }
|
|
function instance_http_delete($url) { return instance_http_request($url, 'DELETE'); }
|
|
function instance_http_request($url, $method, $data=null) {
|
|
$software = null;
|
|
if (isset($_SERVER['REQUEST_URI'])) {
|
|
$huri = substr(trim($_SERVER['REQUEST_URI']), 7);
|
|
$ps = explode('/', trim($huri, '/'));
|
|
if ($ps[0] !== 'http' || !in_array($ps[1], $GLOBALS['supported_ap_software']))
|
|
return apiresult(['error' => 'this method can only be called from api/v1/http/<software> URIs'], 500);
|
|
$software = $ps[1];
|
|
}
|
|
|
|
if ($software === null && isset($GLOBALS['ap_software']))
|
|
$software = $GLOBALS['ap_software'];
|
|
|
|
$config = instance_config($software);
|
|
$url = $config['instance_url'].$url;
|
|
|
|
$ch = curl_init();
|
|
curl_setopt($ch, CURLOPT_URL, $url);
|
|
if ($method === 'POST' || $method === 'DELETE') {
|
|
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
|
|
if ($data !== null)
|
|
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
|
|
}
|
|
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
|
|
|
if (isset($config['api_authkey'])) {
|
|
curl_setopt($ch, CURLOPT_HTTPHEADER, [
|
|
'Authorization: Bearer '.$config['api_authkey'],
|
|
]);
|
|
}
|
|
|
|
$output = curl_exec($ch);
|
|
curl_close($ch);
|
|
return $output;
|
|
}
|
|
|
|
function valid_mastodon_account_id($id) {
|
|
return preg_match('/^\d+$/', strval($id));
|
|
}
|
|
|
|
function valid_for_path($str) {
|
|
return strpos($str, '/') === false;
|
|
}
|
|
|
|
function valid_uuid($str) {
|
|
return preg_match('/^[a-z0-9\-]+$/', trim($str));
|
|
}
|
|
|
|
// source: https://stackoverflow.com/questions/1755144/how-to-validate-domain-name-in-php
|
|
function valid_domain_name($domain_name)
|
|
{
|
|
return (preg_match("/^([a-z\d](-*[a-z\d])*)(\.([a-z\d](-*[a-z\d])*))*$/i", $domain_name)
|
|
&& preg_match("/^.{1,253}$/", $domain_name)
|
|
&& preg_match("/^[^\.]{1,63}(\.[^\.]{1,63})*$/", $domain_name));
|
|
}
|
|
|
|
function remove_accents($string) {
|
|
if ( !preg_match('/[\x80-\xff]/', $string) )
|
|
return $string;
|
|
|
|
$chars = array(
|
|
// Decompositions for Latin-1 Supplement
|
|
chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
|
|
chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
|
|
chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
|
|
chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
|
|
chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
|
|
chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
|
|
chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
|
|
chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
|
|
chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
|
|
chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
|
|
chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
|
|
chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
|
|
chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
|
|
chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
|
|
chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
|
|
chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
|
|
chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
|
|
chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
|
|
chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
|
|
chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
|
|
chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
|
|
chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
|
|
chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
|
|
chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
|
|
chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
|
|
chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
|
|
chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
|
|
chr(195).chr(191) => 'y',
|
|
// Decompositions for Latin Extended-A
|
|
chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
|
|
chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
|
|
chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
|
|
chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
|
|
chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
|
|
chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
|
|
chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
|
|
chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
|
|
chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
|
|
chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
|
|
chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
|
|
chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
|
|
chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
|
|
chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
|
|
chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
|
|
chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
|
|
chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
|
|
chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
|
|
chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
|
|
chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
|
|
chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
|
|
chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
|
|
chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
|
|
chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
|
|
chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
|
|
chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
|
|
chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
|
|
chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
|
|
chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
|
|
chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
|
|
chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
|
|
chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
|
|
chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
|
|
chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
|
|
chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
|
|
chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
|
|
chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
|
|
chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
|
|
chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
|
|
chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
|
|
chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
|
|
chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
|
|
chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
|
|
chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
|
|
chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
|
|
chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
|
|
chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
|
|
chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
|
|
chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
|
|
chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
|
|
chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
|
|
chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
|
|
chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
|
|
chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
|
|
chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
|
|
chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
|
|
chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
|
|
chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
|
|
chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
|
|
chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
|
|
chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
|
|
chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
|
|
chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
|
|
chr(197).chr(190) => 'z', chr(197).chr(191) => 's'
|
|
);
|
|
|
|
$string = strtr($string, $chars);
|
|
|
|
return $string;
|
|
}
|
|
|
|
if (!function_exists('str_starts_with')) {
|
|
function str_starts_with($haystack, $needle) {
|
|
return (string)$needle !== '' && strncmp($haystack, $needle, strlen($needle)) === 0;
|
|
}
|
|
}
|
|
|
|
function set_chat_at($str, $i, $c) {
|
|
return substr($str, 0, $i).$c.substr($str, $i+1);
|
|
}
|
|
|
|
function normalize_word_sound($word, $cback=null) {
|
|
$hashes = [
|
|
'4:a', '3:e', '1:i', '0:o',
|
|
'5:s', 'b:v', '8:b', 'k:c',
|
|
'y:i', 'que:kee', 'q:k',
|
|
];
|
|
foreach ($hashes as $hash) {
|
|
$hash = explode(':', $hash);
|
|
if ($cback !== null)
|
|
$word = $cback($word, $hash);
|
|
else $word = str_replace($hash[0], $hash[1], $word);
|
|
}
|
|
return $word;
|
|
}
|
|
|
|
function normalize_for_search($str, $wsound=true) {
|
|
if (trim($str) === '') return '';
|
|
$str = trim(strip_tags(str_replace('>', '> ', $str)));
|
|
$str = strtolower(remove_accents($str));
|
|
$str = preg_replace('/[^a-z0-9]+/', ' ', $str);
|
|
$str = preg_replace('/\s+/', ' ', $str);
|
|
$words = explode(' ', trim($str));
|
|
$newwords = [];
|
|
foreach ($words as $word) {
|
|
if (trim($word) === '')
|
|
continue;
|
|
if ($wsound)
|
|
$word = normalize_word_sound($word);
|
|
$nword = '';
|
|
if (strlen($word) <= 3) {
|
|
$newwords [] = $word;
|
|
continue;
|
|
}
|
|
for ($i = 0; $i < strlen($word); $i++) {
|
|
if ($i === 0) {
|
|
$nword .= $word[0];
|
|
continue;
|
|
}
|
|
if ($word[$i] !== $word[$i-1]) {
|
|
$nword .= $word[$i];
|
|
}
|
|
}
|
|
$newwords [] = $nword;
|
|
}
|
|
return trim(implode(' ', $newwords));
|
|
}
|
|
|
|
function parse_comparing_expression($expr) {
|
|
$expr = preg_replace('/\n/', ' ', $expr);
|
|
$expr = preg_replace('/\s+/', ' ', $expr);
|
|
$p_expr = $expr;
|
|
$quot = false;
|
|
for ($i = 0; $i < strlen($p_expr); $i++) {
|
|
if ($p_expr[$i] === '"') {
|
|
$quot = !$quot;
|
|
continue;
|
|
}
|
|
if ($quot) {
|
|
if ($p_expr[$i] === '(')
|
|
$p_expr = set_chat_at($p_expr, $i, 'º');
|
|
else if ($p_expr[$i] === ')')
|
|
$p_expr = set_chat_at($p_expr, $i, 'ª');
|
|
}
|
|
}
|
|
$p_expr = preg_replace('/\(|\)/', ' ', $p_expr);
|
|
$p_expr = preg_replace('/\s+/', ' ', $p_expr);
|
|
$p_expr = preg_split('/OR|AND(\sNOT)?/', $p_expr);
|
|
$p_expr = str_replace('º', '(', $p_expr);
|
|
$p_expr = str_replace('ª', ')', $p_expr);
|
|
foreach ($p_expr as &$e) $e = trim($e);
|
|
return [
|
|
'original' => $expr,
|
|
'parsed' => $p_expr,
|
|
];
|
|
}
|
|
|
|
function matches_comparing_expression($expr, $o_text, $debug=false) {
|
|
if (gettype($expr) === 'string')
|
|
$expr = parse_comparing_expression($expr);
|
|
$result = $expr['original'];
|
|
if ($debug) {
|
|
echo '<h2>Original</h2>';
|
|
echo '<pre>'.$o_text.'</pre>';
|
|
}
|
|
$text = normalize_for_search($o_text);
|
|
$i_text = null;
|
|
if (strpos($expr['original'], '=') !== false)
|
|
$i_text = normalize_for_search($o_text, false);
|
|
if ($debug) {
|
|
echo '<h2>Normalized</h2>';
|
|
echo '<pre>'.$text.'</pre>';
|
|
echo '<br><br>';
|
|
}
|
|
|
|
$m_text_words = explode(' ', $text);
|
|
$i_text_words = null;
|
|
if ($i_text !== null)
|
|
$i_text_words = explode(' ', $i_text);
|
|
|
|
$o_text_words = null;
|
|
if (preg_match('/(^|\s)\*\w+/', $expr['original']))
|
|
{
|
|
$nw_text_words = [];
|
|
$o_text_words = explode(' ', $o_text);
|
|
foreach ($o_text_words as $o)
|
|
if ($o !== '')
|
|
$nw_text_words []= $o;
|
|
$o_text_words = $nw_text_words;
|
|
}
|
|
|
|
foreach ($expr['parsed'] as $t)
|
|
{
|
|
$bool = false;
|
|
$t = trim($t);
|
|
$selector = substr($t, 0, strpos($t, ' '));
|
|
$content = substr($t, strpos($t, ' ')+1);
|
|
$content = trim(trim(trim($content), '"'));
|
|
$o_bool = ($selector[0] === '*' && $o_text_words !== null);
|
|
$i_bool = ($selector[0] === '=' && $i_text_words !== null);
|
|
if ($o_bool || $i_bool)
|
|
$selector = substr($selector, 1);
|
|
|
|
switch ($selector)
|
|
{
|
|
case 'words':
|
|
case 'hasall':
|
|
$ws = explode(' ', $content);
|
|
$hasall = true;
|
|
foreach ($ws as $w)
|
|
{
|
|
if ($o_bool) {
|
|
if (!in_array($w, $o_text_words)) {
|
|
$hasall = false;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if ($i_bool) {
|
|
if (!in_array(normalize_for_search($w, false), $i_text_words)) {
|
|
$hasall = false;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (!in_array(normalize_for_search($w), $m_text_words)) {
|
|
$hasall = false;
|
|
break;
|
|
}
|
|
}
|
|
$bool = $hasall;
|
|
if ($debug) {
|
|
echo '<br><br>';
|
|
echo '<h3>words</h3>';
|
|
echo '<pre>';
|
|
echo $content;
|
|
echo '</pre>';
|
|
echo '<br>Result: ';
|
|
var_dump($bool);
|
|
echo '<br>';
|
|
}
|
|
break;
|
|
|
|
case 'anyword':
|
|
case 'hasany':
|
|
$ws = explode(' ', $content);
|
|
$hasany = false;
|
|
foreach ($ws as $w)
|
|
{
|
|
if ($o_bool) {
|
|
if (in_array($w, $o_text_words)) {
|
|
$hasany = true;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if ($i_bool) {
|
|
if (in_array(normalize_for_search($w, false), $i_text_words)) {
|
|
$hasany = true;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (in_array(normalize_for_search($w), $m_text_words)) {
|
|
$hasany = true;
|
|
break;
|
|
}
|
|
}
|
|
$bool = $hasany;
|
|
if ($debug) {
|
|
echo '<br><br>';
|
|
echo '<h3>hasany</h3>';
|
|
echo '<pre>';
|
|
echo $content;
|
|
echo '</pre>';
|
|
echo '<br>Result: ';
|
|
var_dump($bool);
|
|
echo '<br>';
|
|
}
|
|
break;
|
|
|
|
case 'has':
|
|
case 'includes':
|
|
case 'contains':
|
|
$a = null; $b = null;
|
|
if ($o_bool) {
|
|
$a = str_replace(' ', '', $o_text);
|
|
$b = str_replace(' ', '', $content);
|
|
} else if ($i_bool) {
|
|
$a = str_replace(' ', '', $i_text);
|
|
$b = str_replace(' ', '', normalize_for_search($content, false));
|
|
} else {
|
|
$a = str_replace(' ', '', $text);
|
|
$b = str_replace(' ', '', normalize_for_search($content));
|
|
}
|
|
if ($debug) {
|
|
echo '<br><br>';
|
|
echo '<h3>contains</h3>';
|
|
echo '<pre>';
|
|
echo $content;
|
|
echo '</pre>';
|
|
}
|
|
$bool = strpos($a, $b) !== false;
|
|
if ($debug) {
|
|
echo '<br>Result: ';
|
|
var_dump($bool);
|
|
echo '<br>';
|
|
}
|
|
unset($a); unset($b);
|
|
break;
|
|
|
|
case 'regex':
|
|
case 'matches':
|
|
if (strlen($content) === 0)
|
|
continue 2;
|
|
if (!$o_bool)
|
|
{
|
|
$content = normalize_word_sound($content, function($w, $h) {
|
|
if ($h[0] === 'b')
|
|
return preg_replace('/([^\\\])b/', '\1'.$h[1], $w);
|
|
if (preg_match('/^\d$/', $h[0])) {
|
|
$b = false;
|
|
for ($i = 0; $i < strlen($w); $i++) {
|
|
if (in_array($w[$i], ['{','}','[',']'])) {
|
|
$b = !$b;
|
|
continue;
|
|
}
|
|
if (!$b && $w[$i] === $h[0])
|
|
$w = set_chat_at($w, $i, $h[1]);
|
|
}
|
|
return $w;
|
|
}
|
|
return str_replace($h[0], $h[1], $w);
|
|
});
|
|
preg_match_all('/\w{4,}/', $content, $mts);
|
|
foreach ((isset($mts[0]) ? $mts[0] : []) as $m)
|
|
$content = preg_replace('/\b'.$m.'\b/', normalize_for_search($m, !$i_bool), $content);
|
|
}
|
|
if ($content[0] != '^')
|
|
$content = '^.*'.$content;
|
|
if ($content[strlen($content)-1] != '$')
|
|
$content .= '.*$';
|
|
$content = str_replace('#', '\#', $content);
|
|
if ($debug) {
|
|
echo '<br><br>';
|
|
echo '<h3>regex</h3>';
|
|
echo '<pre>';
|
|
echo $content;
|
|
echo '</pre>';
|
|
}
|
|
$bool = false;
|
|
if ($o_bool)
|
|
$bool = preg_match('#'.$content.'#i', $o_text) === 1;
|
|
else $bool = preg_match('#'.$content.'#', $text) === 1;
|
|
if ($debug) {
|
|
echo '<br>Result: ';
|
|
var_dump($bool);
|
|
echo '<br>';
|
|
}
|
|
break;
|
|
|
|
}
|
|
$result = str_replace($t, $bool ? 'true' : 'false', $result);
|
|
}
|
|
$result = str_replace('OR', '||', $result);
|
|
$result = str_replace('AND', '&&', $result);
|
|
$result = str_replace('NOT ', '!', $result);
|
|
$result = str_replace('NOT', '!', $result);
|
|
try {
|
|
if ($debug) {
|
|
echo '<br><hr>';
|
|
echo '<h3>Final result</h3>';
|
|
echo '<br>eval: ';
|
|
var_dump($result);
|
|
}
|
|
eval('$result = '.$result.';');
|
|
if ($debug) {
|
|
echo '<br>';
|
|
echo '<br>result: ';
|
|
var_dump($result);
|
|
die;
|
|
}
|
|
} catch (\Throwable $e) {
|
|
return apiresult(['error' => 'Query contains errors, please correct it and try again.']);
|
|
}
|
|
return in_array($result, [0,false]) ? false : true;
|
|
}
|
|
|
|
function http_cache($seconds, $data=null) {
|
|
if ($data === null)
|
|
$data = $_GET;
|
|
$cache_key = sha1('http_cache'.json_encode($data));
|
|
$cache = content_cache__get($cache_key);
|
|
if ($cache !== null)
|
|
return apiresult($cache);
|
|
$GLOBALS['http_cache_config'] = [
|
|
'seconds' => $seconds,
|
|
'key' => $cache_key
|
|
];
|
|
}
|
|
|
|
function _cachekey_construct(...$keys) {
|
|
$nkeys = [];
|
|
foreach ($keys as $key)
|
|
$nkeys []= _cachekey($key);
|
|
return implode(',', $nkeys);
|
|
}
|
|
|
|
function _cachekey($str) {
|
|
return preg_replace('/[^a-z0-9\_]+/', '', strtolower($str));
|
|
}
|
|
|
|
function content_cache__exists($key) {
|
|
$cache_dir = $GLOBALS['appconf']['data_dir'].'/cache';
|
|
if (!file_exists($cache_dir)) {
|
|
mkdir($cache_dir);
|
|
return false;
|
|
}
|
|
$key = md5($key);
|
|
$cache_file = null;
|
|
foreach (scandir($cache_dir) as $fil) {
|
|
if (strpos($fil, $key) !== false) {
|
|
$cache_file = $cache_dir.'/'.$fil;
|
|
$ps = explode(',',$fil);
|
|
array_splice($ps, 0, 1);
|
|
if ($ps[0] !== 'always' && count($ps) > 1)
|
|
$ps[1] = intval($ps[1]);
|
|
return (object)[
|
|
'file' => $cache_file,
|
|
'config' => $ps
|
|
];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function content_cache__get($key) {
|
|
$cfg = content_cache__exists($key);
|
|
if ($cfg === false)
|
|
return null;
|
|
$ms = time() - filemtime($cfg->file);
|
|
if ($cfg->config[0] === 'ondemand' &&
|
|
$ms > $cfg->config[1]) {
|
|
unlink($cfg->file);
|
|
return null;
|
|
}
|
|
$fname = basename($cfg->file);
|
|
$ps = explode(',', $fname);
|
|
if (count($ps) === 2 && $ps[1] === 'always') {
|
|
$dir = filedb_getdir('cron/db');
|
|
foreach (scandir($dir) as $fl) {
|
|
if (in_array($fl,['.','..']))
|
|
continue;
|
|
if (strpos($fl, ','.$ps[0].',') !== false) {
|
|
$data = @unserialize(filedb_get('cron/db',$fl));
|
|
if ($data === false) break;
|
|
$data['last_accessed'] = time();
|
|
file_put_contents($dir.'/'.$fl, serialize($data));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return unserialize(file_get_contents($cfg->file));
|
|
}
|
|
|
|
function content_cache__put($key, $config, $data) {
|
|
$cache_dir = $GLOBALS['appconf']['data_dir'].'/cache';
|
|
if (!file_exists($cache_dir))
|
|
mkdir($cache_dir);
|
|
$ps = explode(',', trim($config));
|
|
$cache_file = $cache_dir.'/'.md5($key);
|
|
if ($ps[0] === 'always')
|
|
$cache_file .= ','.$ps[0];
|
|
else if ($ps[0] === 'ondemand')
|
|
$cache_file .= ','.$config;
|
|
return file_put_contents($cache_file, serialize($data));
|
|
}
|
|
|
|
function cronjob_db_create__check_cachecfg($software, $instance, $sql, $cache=null) {
|
|
if ($cache === null)
|
|
return false;
|
|
$ps = explode(',',trim($cache));
|
|
if ($ps[0] !== 'always')
|
|
return false;
|
|
return cronjob_db_create($software, $instance, $sql, intval($ps[1]));
|
|
}
|
|
|
|
function cronjob_db_create($software, $instance, $sql, $time=3600) {
|
|
$job_key = md5($software.$instance.$sql);
|
|
$dir_crons = $GLOBALS['appconf']['data_dir'].'/cron';
|
|
if (!file_exists($dir_crons))
|
|
mkdir($dir_crons);
|
|
$dir_crons_db = $dir_crons.'/db';
|
|
if (!file_exists($dir_crons_db))
|
|
mkdir($dir_crons_db);
|
|
|
|
$cron_file = $software.','.$instance.','.$job_key;
|
|
$result_file = $dir_crons_db.'/'.$cron_file.','.$time;
|
|
if (!file_exists($result_file)) {
|
|
file_put_contents($result_file, serialize(
|
|
['last_accessed' => time(), 'sql' => $sql]));
|
|
touch($result_file, 1000);
|
|
}
|
|
|
|
$result_fname = basename($result_file);
|
|
foreach (scandir($dir_crons_db) as $fl) {
|
|
if (in_array($fl,['.','..']))
|
|
continue;
|
|
if (strpos($fl, $cron_file) !== false && $fl !== $result_fname)
|
|
unlink($dir_crons_db.'/'.$fl);
|
|
}
|
|
return $cron_file;
|
|
}
|
|
|
|
// classes
|
|
require 'classes/PgDatabase.php';
|
|
require 'classes/RedisDatabase.php';
|