include/functions.php

   1 <?php
   2         define('EXPECTED_CONFIG_VERSION', 26);
   3         define('SCHEMA_VERSION', 131);
   4
   5         define('LABEL_BASE_INDEX', -1024);
   6         define('PLUGIN_FEED_BASE_INDEX', -128);
   7
   8         define('COOKIE_LIFETIME_LONG', 86400*365);
   9
  10         $fetch_last_error = false;
  11         $fetch_last_error_code = false;
  12         $fetch_last_content_type = false;
  13         $fetch_last_error_content = false; // curl only for the time being
  14         $fetch_curl_used = false;
  15         $suppress_debugging = false;
  16
  17         libxml_disable_entity_loader(true);
  18
  19         // separate test because this is included before sanity checks
  20         if (function_exists("mb_internal_encoding")) mb_internal_encoding("UTF-8");
  21
  22         date_default_timezone_set('UTC');
  23         if (defined('E_DEPRECATED')) {
  24                 error_reporting(E_ALL & ~E_NOTICE & ~E_DEPRECATED);
  25         } else {
  26                 error_reporting(E_ALL & ~E_NOTICE);
  27         }
  28
  29         require_once 'config.php';
  30
  31         /**
  32          * Define a constant if not already defined
  33          */
  34         function define_default($name, $value) {
  35                 defined($name) or define($name, $value);
  36         }
  37
  38         /* Some tunables you can override in config.php using define(): */
  39
  40         define_default('FEED_FETCH_TIMEOUT', 45);
  41         // How may seconds to wait for response when requesting feed from a site
  42         define_default('FEED_FETCH_NO_CACHE_TIMEOUT', 15);
  43         // How may seconds to wait for response when requesting feed from a
  44         // site when that feed wasn't cached before
  45         define_default('FILE_FETCH_TIMEOUT', 45);
  46         // Default timeout when fetching files from remote sites
  47         define_default('FILE_FETCH_CONNECT_TIMEOUT', 15);
  48         // How many seconds to wait for initial response from website when
  49         // fetching files from remote sites
  50         define_default('DAEMON_UPDATE_LOGIN_LIMIT', 30);
  51         // stop updating feeds if users haven't logged in for X days
  52         define_default('DAEMON_FEED_LIMIT', 500);
  53         // feed limit for one update batch
  54         define_default('DAEMON_SLEEP_INTERVAL', 120);
  55         // default sleep interval between feed updates (sec)
  56         define_default('MIN_CACHE_FILE_SIZE', 1024);
  57         // do not cache files smaller than that (bytes)
  58         define_default('CACHE_MAX_DAYS', 7);
  59         // max age in days for various automatically cached (temporary) files
  60
  61         /* tunables end here */
  62
  63         if (DB_TYPE == "pgsql") {
  64                 define('SUBSTRING_FOR_DATE', 'SUBSTRING_FOR_DATE');
  65         } else {
  66                 define('SUBSTRING_FOR_DATE', 'SUBSTRING');
  67         }
  68
  69         /**
  70          * Return available translations names.
  71          *
  72          * @access public
  73          * @return array A array of available translations.
  74          */
  75         function get_translations() {
  76                 $tr = array(
  77                                         "auto"  => "Detect automatically",
  78                                         "ar_SA" => "العربيّة (Arabic)",
  79                                         "bg_BG" => "Bulgarian",
  80                                         "da_DA" => "Dansk",
  81                                         "ca_CA" => "Català",
  82                                         "cs_CZ" => "Česky",
  83                                         "en_US" => "English",
  84                                         "el_GR" => "Ελληνικά",
  85                                         "es_ES" => "Español (España)",
  86                                         "es_LA" => "Español",
  87                                         "de_DE" => "Deutsch",
  88                                         "fr_FR" => "Français",
  89                                         "hu_HU" => "Magyar (Hungarian)",
  90                                         "it_IT" => "Italiano",
  91                                         "ja_JP" => "日本語 (Japanese)",
  92                                         "lv_LV" => "Latviešu",
  93                                         "nb_NO" => "Norwegian bokmål",
  94                                         "nl_NL" => "Dutch",
  95                                         "pl_PL" => "Polski",
  96                                         "ru_RU" => "Русский",
  97                                         "pt_BR" => "Portuguese/Brazil",
  98                                         "pt_PT" => "Portuguese/Portugal",
  99                                         "zh_CN" => "Simplified Chinese",
 100                                         "zh_TW" => "Traditional Chinese",
 101                                         "sv_SE" => "Svenska",
 102                                         "fi_FI" => "Suomi",
 103                                         "tr_TR" => "Türkçe");
 104
 105                 return $tr;
 106         }
 107
 108         require_once "lib/accept-to-gettext.php";
 109         require_once "lib/gettext/gettext.inc";
 110
 111         function startup_gettext() {
 112
 113                 # Get locale from Accept-Language header
 114                 $lang = al2gt(array_keys(get_translations()), "text/html");
 115
 116                 if (defined('_TRANSLATION_OVERRIDE_DEFAULT')) {
 117                         $lang = _TRANSLATION_OVERRIDE_DEFAULT;
 118                 }
 119
 120                 if ($_SESSION["uid"] && get_schema_version() >= 120) {
 121                         $pref_lang = get_pref("USER_LANGUAGE", $_SESSION["uid"]);
 122
 123                         if ($pref_lang && $pref_lang != 'auto') {
 124                                 $lang = $pref_lang;
 125                         }
 126                 }
 127
 128                 if ($lang) {
 129                         if (defined('LC_MESSAGES')) {
 130                                 _setlocale(LC_MESSAGES, $lang);
 131                         } else if (defined('LC_ALL')) {
 132                                 _setlocale(LC_ALL, $lang);
 133                         }
 134
 135                         _bindtextdomain("messages", "locale");
 136
 137                         _textdomain("messages");
 138                         _bind_textdomain_codeset("messages", "UTF-8");
 139                 }
 140         }
 141
 142         require_once 'db-prefs.php';
 143         require_once 'version.php';
 144         require_once 'controls.php';
 145
 146         define('SELF_USER_AGENT', 'Tiny Tiny RSS/' . VERSION . ' (http://tt-rss.org/)');
 147         ini_set('user_agent', SELF_USER_AGENT);
 148
 149         $schema_version = false;
 150
 151         function _debug_suppress($suppress) {
 152                 global $suppress_debugging;
 153
 154                 $suppress_debugging = $suppress;
 155         }
 156
 157         /**
 158          * Print a timestamped debug message.
 159          *
 160          * @param string $msg The debug message.
 161          * @return void
 162          */
 163         function _debug($msg, $show = true) {
 164                 global $suppress_debugging;
 165
 166                 //echo "[$suppress_debugging] $msg $show\n";
 167
 168                 if ($suppress_debugging) return false;
 169
 170                 $ts = strftime("%H:%M:%S", time());
 171                 if (function_exists('posix_getpid')) {
 172                         $ts = "$ts/" . posix_getpid();
 173                 }
 174
 175                 if ($show && !(defined('QUIET') && QUIET)) {
 176                         print "[$ts] $msg\n";
 177                 }
 178
 179                 if (defined('LOGFILE'))  {
 180                         $fp = fopen(LOGFILE, 'a+');
 181
 182                         if ($fp) {
 183                                 $locked = false;
 184
 185                                 if (function_exists("flock")) {
 186                                         $tries = 0;
 187
 188                                         // try to lock logfile for writing
 189                                         while ($tries < 5 && !$locked = flock($fp, LOCK_EX | LOCK_NB)) {
 190                                                 sleep(1);
 191                                                 ++$tries;
 192                                         }
 193
 194                                         if (!$locked) {
 195                                                 fclose($fp);
 196                                                 return;
 197                                         }
 198                                 }
 199
 200                                 fputs($fp, "[$ts] $msg\n");
 201
 202                                 if (function_exists("flock")) {
 203                                         flock($fp, LOCK_UN);
 204                                 }
 205
 206                                 fclose($fp);
 207                         }
 208                 }
 209
 210         } // function _debug
 211
 212         /**
 213          * Purge a feed old posts.
 214          *
 215          * @param mixed $link A database connection.
 216          * @param mixed $feed_id The id of the purged feed.
 217          * @param mixed $purge_interval Olderness of purged posts.
 218          * @param boolean $debug Set to True to enable the debug. False by default.
 219          * @access public
 220          * @return void
 221          */
 222         function purge_feed($feed_id, $purge_interval, $debug = false) {
 223
 224                 if (!$purge_interval) $purge_interval = feed_purge_interval($feed_id);
 225
 226                 $rows = -1;
 227
 228                 $result = db_query(
 229                         "SELECT owner_uid FROM ttrss_feeds WHERE id = '$feed_id'");
 230
 231                 $owner_uid = false;
 232
 233                 if (db_num_rows($result) == 1) {
 234                         $owner_uid = db_fetch_result($result, 0, "owner_uid");
 235                 }
 236
 237                 if ($purge_interval == -1 || !$purge_interval) {
 238                         if ($owner_uid) {
 239                                 CCache::update($feed_id, $owner_uid);
 240                         }
 241                         return;
 242                 }
 243
 244                 if (!$owner_uid) return;
 245
 246                 if (FORCE_ARTICLE_PURGE == 0) {
 247                         $purge_unread = get_pref("PURGE_UNREAD_ARTICLES",
 248                                 $owner_uid, false);
 249                 } else {
 250                         $purge_unread = true;
 251                         $purge_interval = FORCE_ARTICLE_PURGE;
 252                 }
 253
 254                 if (!$purge_unread) $query_limit = " unread = false AND ";
 255
 256                 if (DB_TYPE == "pgsql") {
 257                         $result = db_query("DELETE FROM ttrss_user_entries
 258                                 USING ttrss_entries
 259                                 WHERE ttrss_entries.id = ref_id AND
 260                                 marked = false AND
 261                                 feed_id = '$feed_id' AND
 262                                 $query_limit
 263                                 ttrss_entries.date_updated < NOW() - INTERVAL '$purge_interval days'");
 264
 265                 } else {
 266
 267 /*                      $result = db_query("DELETE FROM ttrss_user_entries WHERE
 268                                 marked = false AND feed_id = '$feed_id' AND
 269                                 (SELECT date_updated FROM ttrss_entries WHERE
 270                                         id = ref_id) < DATE_SUB(NOW(), INTERVAL $purge_interval DAY)"); */
 271
 272                         $result = db_query("DELETE FROM ttrss_user_entries
 273                                 USING ttrss_user_entries, ttrss_entries
 274                                 WHERE ttrss_entries.id = ref_id AND
 275                                 marked = false AND
 276                                 feed_id = '$feed_id' AND
 277                                 $query_limit
 278                                 ttrss_entries.date_updated < DATE_SUB(NOW(), INTERVAL $purge_interval DAY)");
 279                 }
 280
 281                 $rows = db_affected_rows($result);
 282
 283                 CCache::update($feed_id, $owner_uid);
 284
 285                 if ($debug) {
 286                         _debug("Purged feed $feed_id ($purge_interval): deleted $rows articles");
 287                 }
 288
 289                 return $rows;
 290         } // function purge_feed
 291
 292         function feed_purge_interval($feed_id) {
 293
 294                 $result = db_query("SELECT purge_interval, owner_uid FROM ttrss_feeds
 295                         WHERE id = '$feed_id'");
 296
 297                 if (db_num_rows($result) == 1) {
 298                         $purge_interval = db_fetch_result($result, 0, "purge_interval");
 299                         $owner_uid = db_fetch_result($result, 0, "owner_uid");
 300
 301                         if ($purge_interval == 0) $purge_interval = get_pref(
 302                                 'PURGE_OLD_DAYS', $owner_uid);
 303
 304                         return $purge_interval;
 305
 306                 } else {
 307                         return -1;
 308                 }
 309         }
 310
 311         /*function get_feed_update_interval($feed_id) {
 312                 $result = db_query("SELECT owner_uid, update_interval FROM
 313                         ttrss_feeds WHERE id = '$feed_id'");
 314
 315                 if (db_num_rows($result) == 1) {
 316                         $update_interval = db_fetch_result($result, 0, "update_interval");
 317                         $owner_uid = db_fetch_result($result, 0, "owner_uid");
 318
 319                         if ($update_interval != 0) {
 320                                 return $update_interval;
 321                         } else {
 322                                 return get_pref('DEFAULT_UPDATE_INTERVAL', $owner_uid, false);
 323                         }
 324
 325                 } else {
 326                         return -1;
 327                 }
 328         }*/
 329
 330         // TODO: multiple-argument way is deprecated, first parameter is a hash now
 331         function fetch_file_contents($options /* previously: 0: $url , 1: $type = false, 2: $login = false, 3: $pass = false,
 332                                 4: $post_query = false, 5: $timeout = false, 6: $timestamp = 0, 7: $useragent = false*/) {
 333
 334                 global $fetch_last_error;
 335                 global $fetch_last_error_code;
 336                 global $fetch_last_error_content;
 337                 global $fetch_last_content_type;
 338                 global $fetch_curl_used;
 339
 340                 $fetch_last_error = false;
 341                 $fetch_last_error_code = -1;
 342                 $fetch_last_error_content = "";
 343                 $fetch_last_content_type = "";
 344                 $fetch_curl_used = false;
 345
 346                 if (!is_array($options)) {
 347
 348                         // falling back on compatibility shim
 349                         $option_names = [ "url", "type", "login", "pass", "post_query", "timeout", "timestamp", "useragent" ];
 350                         $tmp = [];
 351
 352                         for ($i = 0; $i < func_num_args(); $i++) {
 353                                 $tmp[$option_names[$i]] = func_get_arg($i);
 354                         }
 355
 356                         $options = $tmp;
 357
 358                         /*$options = array(
 359                                         "url" => func_get_arg(0),
 360                                         "type" => @func_get_arg(1),
 361                                         "login" => @func_get_arg(2),
 362                                         "pass" => @func_get_arg(3),
 363                                         "post_query" => @func_get_arg(4),
 364                                         "timeout" => @func_get_arg(5),
 365                                         "timestamp" => @func_get_arg(6),
 366                                         "useragent" => @func_get_arg(7)
 367                         ); */
 368                 }
 369
 370                 $url = $options["url"];
 371                 $type = isset($options["type"]) ? $options["type"] : false;
 372                 $login = isset($options["login"]) ? $options["login"] : false;
 373                 $pass = isset($options["pass"]) ? $options["pass"] : false;
 374                 $post_query = isset($options["post_query"]) ? $options["post_query"] : false;
 375                 $timeout = isset($options["timeout"]) ? $options["timeout"] : false;
 376                 $timestamp = isset($options["timestamp"]) ? $options["timestamp"] : 0;
 377                 $useragent = isset($options["useragent"]) ? $options["useragent"] : false;
 378                 $followlocation = isset($options["followlocation"]) ? $options["followlocation"] : true;
 379
 380                 $url = ltrim($url, ' ');
 381                 $url = str_replace(' ', '%20', $url);
 382
 383                 if (strpos($url, "//") === 0)
 384                         $url = 'http:' . $url;
 385
 386                 if (!defined('NO_CURL') && function_exists('curl_init') && !ini_get("open_basedir")) {
 387
 388                         $fetch_curl_used = true;
 389
 390                         $ch = curl_init($url);
 391
 392                         if ($timestamp && !$post_query) {
 393                                 curl_setopt($ch, CURLOPT_HTTPHEADER,
 394                                         array("If-Modified-Since: ".gmdate('D, d M Y H:i:s \G\M\T', $timestamp)));
 395                         }
 396
 397                         curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout ? $timeout : FILE_FETCH_CONNECT_TIMEOUT);
 398                         curl_setopt($ch, CURLOPT_TIMEOUT, $timeout ? $timeout : FILE_FETCH_TIMEOUT);
 399                         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, !ini_get("open_basedir") && $followlocation);
 400                         curl_setopt($ch, CURLOPT_MAXREDIRS, 20);
 401                         curl_setopt($ch, CURLOPT_BINARYTRANSFER, true);
 402                         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 403                         curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 404                         curl_setopt($ch, CURLOPT_USERAGENT, $useragent ? $useragent :
 405                                 SELF_USER_AGENT);
 406                         curl_setopt($ch, CURLOPT_ENCODING, "");
 407                         //curl_setopt($ch, CURLOPT_REFERER, $url);
 408
 409                         if (!ini_get("open_basedir")) {
 410                                 curl_setopt($ch, CURLOPT_COOKIEJAR, "/dev/null");
 411                         }
 412
 413                         if (defined('_CURL_HTTP_PROXY')) {
 414                                 curl_setopt($ch, CURLOPT_PROXY, _CURL_HTTP_PROXY);
 415                         }
 416
 417                         if ($post_query) {
 418                                 curl_setopt($ch, CURLOPT_POST, true);
 419                                 curl_setopt($ch, CURLOPT_POSTFIELDS, $post_query);
 420                         }
 421
 422                         if ($login && $pass)
 423                                 curl_setopt($ch, CURLOPT_USERPWD, "$login:$pass");
 424
 425                         $contents = @curl_exec($ch);
 426
 427                         if (curl_errno($ch) === 23 || curl_errno($ch) === 61) {
 428                                 curl_setopt($ch, CURLOPT_ENCODING, 'none');
 429                                 $contents = @curl_exec($ch);
 430                         }
 431
 432                         if ($contents === false) {
 433                                 $fetch_last_error = curl_errno($ch) . " " . curl_error($ch);
 434                                 curl_close($ch);
 435                                 return false;
 436                         }
 437
 438                         $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 439                         $fetch_last_content_type = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
 440
 441                         $fetch_last_error_code = $http_code;
 442
 443                         if ($http_code != 200 || $type && strpos($fetch_last_content_type, "$type") === false) {
 444                                 if (curl_errno($ch) != 0) {
 445                                         $fetch_last_error = curl_errno($ch) . " " . curl_error($ch);
 446                                 } else {
 447                                         $fetch_last_error = "HTTP Code: $http_code";
 448                                 }
 449                                 $fetch_last_error_content = $contents;
 450                                 curl_close($ch);
 451                                 return false;
 452                         }
 453
 454                         curl_close($ch);
 455
 456                         return $contents;
 457                 } else {
 458
 459                         $fetch_curl_used = false;
 460
 461                         if ($login && $pass){
 462                                 $url_parts = array();
 463
 464                                 preg_match("/(^[^:]*):\/\/(.*)/", $url, $url_parts);
 465
 466                                 $pass = urlencode($pass);
 467
 468                                 if ($url_parts[1] && $url_parts[2]) {
 469                                         $url = $url_parts[1] . "://$login:$pass@" . $url_parts[2];
 470                                 }
 471                         }
 472
 473                         // TODO: should this support POST requests or not? idk
 474
 475                         if (!$post_query && $timestamp) {
 476                                  $context = stream_context_create(array(
 477                                           'http' => array(
 478                                                         'method' => 'GET',
 479                                                     'ignore_errors' => true,
 480                                                     'timeout' => $timeout ? $timeout : FILE_FETCH_TIMEOUT,
 481                                                         'protocol_version'=> 1.1,
 482                                                         'header' => "If-Modified-Since: ".gmdate("D, d M Y H:i:s \\G\\M\\T\r\n", $timestamp)
 483                                           )));
 484                         } else {
 485                                  $context = stream_context_create(array(
 486                                           'http' => array(
 487                                                         'method' => 'GET',
 488                                                     'ignore_errors' => true,
 489                                                     'timeout' => $timeout ? $timeout : FILE_FETCH_TIMEOUT,
 490                                                         'protocol_version'=> 1.1
 491                                           )));
 492                         }
 493
 494                         $old_error = error_get_last();
 495
 496                         $data = @file_get_contents($url, false, $context);
 497
 498                         if (isset($http_response_header) && is_array($http_response_header)) {
 499                                 foreach ($http_response_header as $h) {
 500                                         if (substr(strtolower($h), 0, 13) == 'content-type:') {
 501                                                 $fetch_last_content_type = substr($h, 14);
 502                                                 // don't abort here b/c there might be more than one
 503                                                 // e.g. if we were being redirected -- last one is the right one
 504                                         }
 505
 506                                         if (substr(strtolower($h), 0, 7) == 'http/1.') {
 507                                                 $fetch_last_error_code = (int) substr($h, 9, 3);
 508                                         }
 509                                 }
 510                         }
 511
 512                         if ($fetch_last_error_code != 200) {
 513                                 $error = error_get_last();
 514
 515                                 if ($error['message'] != $old_error['message']) {
 516                                         $fetch_last_error = $error["message"];
 517                                 } else {
 518                                         $fetch_last_error = "HTTP Code: $fetch_last_error_code";
 519                                 }
 520
 521                                 $fetch_last_error_content = $data;
 522
 523                                 return false;
 524                         }
 525                         return $data;
 526                 }
 527
 528         }
 529
 530         /**
 531          * Try to determine the favicon URL for a feed.
 532          * adapted from wordpress favicon plugin by Jeff Minard (http://thecodepro.com/)
 533          * http://dev.wp-plugins.org/file/favatars/trunk/favatars.php
 534          *
 535          * @param string $url A feed or page URL
 536          * @access public
 537          * @return mixed The favicon URL, or false if none was found.
 538          */
 539         function get_favicon_url($url) {
 540
 541                 $favicon_url = false;
 542
 543                 if ($html = @fetch_file_contents($url)) {
 544
 545                         libxml_use_internal_errors(true);
 546
 547                         $doc = new DOMDocument();
 548                         $doc->loadHTML($html);
 549                         $xpath = new DOMXPath($doc);
 550
 551                         $base = $xpath->query('/html/head/base');
 552                         foreach ($base as $b) {
 553                                 $url = $b->getAttribute("href");
 554                                 break;
 555                         }
 556
 557                         $entries = $xpath->query('/html/head/link[@rel="shortcut icon" or @rel="icon"]');
 558                         if (count($entries) > 0) {
 559                                 foreach ($entries as $entry) {
 560                                         $favicon_url = rewrite_relative_url($url, $entry->getAttribute("href"));
 561                                         break;
 562                                 }
 563                         }
 564                 }
 565
 566                 if (!$favicon_url)
 567                         $favicon_url = rewrite_relative_url($url, "/favicon.ico");
 568
 569                 return $favicon_url;
 570         } // function get_favicon_url
 571
 572         function initialize_user_prefs($uid, $profile = false) {
 573
 574                 $uid = db_escape_string($uid);
 575
 576                 if (!$profile) {
 577                         $profile = "NULL";
 578                         $profile_qpart = "AND profile IS NULL";
 579                 } else {
 580                         $profile_qpart = "AND profile = '$profile'";
 581                 }
 582
 583                 if (get_schema_version() < 63) $profile_qpart = "";
 584
 585                 db_query("BEGIN");
 586
 587                 $result = db_query("SELECT pref_name,def_value FROM ttrss_prefs");
 588
 589                 $u_result = db_query("SELECT pref_name
 590                         FROM ttrss_user_prefs WHERE owner_uid = '$uid' $profile_qpart");
 591
 592                 $active_prefs = array();
 593
 594                 while ($line = db_fetch_assoc($u_result)) {
 595                         array_push($active_prefs, $line["pref_name"]);
 596                 }
 597
 598                 while ($line = db_fetch_assoc($result)) {
 599                         if (array_search($line["pref_name"], $active_prefs) === FALSE) {
 600 //                              print "adding " . $line["pref_name"] . "<br>";
 601
 602                                 $line["def_value"] = db_escape_string($line["def_value"]);
 603                                 $line["pref_name"] = db_escape_string($line["pref_name"]);
 604
 605                                 if (get_schema_version() < 63) {
 606                                         db_query("INSERT INTO ttrss_user_prefs
 607                                                 (owner_uid,pref_name,value) VALUES
 608                                                 ('$uid', '".$line["pref_name"]."','".$line["def_value"]."')");
 609
 610                                 } else {
 611                                         db_query("INSERT INTO ttrss_user_prefs
 612                                                 (owner_uid,pref_name,value, profile) VALUES
 613                                                 ('$uid', '".$line["pref_name"]."','".$line["def_value"]."', $profile)");
 614                                 }
 615
 616                         }
 617                 }
 618
 619                 db_query("COMMIT");
 620
 621         }
 622
 623         function get_ssl_certificate_id() {
 624                 if ($_SERVER["REDIRECT_SSL_CLIENT_M_SERIAL"]) {
 625                         return sha1($_SERVER["REDIRECT_SSL_CLIENT_M_SERIAL"] .
 626                                 $_SERVER["REDIRECT_SSL_CLIENT_V_START"] .
 627                                 $_SERVER["REDIRECT_SSL_CLIENT_V_END"] .
 628                                 $_SERVER["REDIRECT_SSL_CLIENT_S_DN"]);
 629                 }
 630                 if ($_SERVER["SSL_CLIENT_M_SERIAL"]) {
 631                         return sha1($_SERVER["SSL_CLIENT_M_SERIAL"] .
 632                                 $_SERVER["SSL_CLIENT_V_START"] .
 633                                 $_SERVER["SSL_CLIENT_V_END"] .
 634                                 $_SERVER["SSL_CLIENT_S_DN"]);
 635                 }
 636                 return "";
 637         }
 638
 639         function authenticate_user($login, $password, $check_only = false) {
 640
 641                 if (!SINGLE_USER_MODE) {
 642                         $user_id = false;
 643
 644                         foreach (PluginHost::getInstance()->get_hooks(PluginHost::HOOK_AUTH_USER) as $plugin) {
 645
 646                                 $user_id = (int) $plugin->authenticate($login, $password);
 647
 648                                 if ($user_id) {
 649                                         $_SESSION["auth_module"] = strtolower(get_class($plugin));
 650                                         break;
 651                                 }
 652                         }
 653
 654                         if ($user_id && !$check_only) {
 655                                 @session_start();
 656
 657                                 $_SESSION["uid"] = $user_id;
 658                                 $_SESSION["version"] = VERSION_STATIC;
 659
 660                                 $result = db_query("SELECT login,access_level,pwd_hash FROM ttrss_users
 661                                         WHERE id = '$user_id'");
 662
 663                                 $_SESSION["name"] = db_fetch_result($result, 0, "login");
 664                                 $_SESSION["access_level"] = db_fetch_result($result, 0, "access_level");
 665                                 $_SESSION["csrf_token"] = uniqid_short();
 666
 667                                 db_query("UPDATE ttrss_users SET last_login = NOW() WHERE id = " .
 668                                         $_SESSION["uid"]);
 669
 670                                 $_SESSION["ip_address"] = $_SERVER["REMOTE_ADDR"];
 671                                 $_SESSION["user_agent"] = sha1($_SERVER['HTTP_USER_AGENT']);
 672                                 $_SESSION["pwd_hash"] = db_fetch_result($result, 0, "pwd_hash");
 673
 674                                 $_SESSION["last_version_check"] = time();
 675
 676                                 initialize_user_prefs($_SESSION["uid"]);
 677
 678                                 return true;
 679                         }
 680
 681                         return false;
 682
 683                 } else {
 684
 685                         $_SESSION["uid"] = 1;
 686                         $_SESSION["name"] = "admin";
 687                         $_SESSION["access_level"] = 10;
 688
 689                         $_SESSION["hide_hello"] = true;
 690                         $_SESSION["hide_logout"] = true;
 691
 692                         $_SESSION["auth_module"] = false;
 693
 694                         if (!$_SESSION["csrf_token"]) {
 695                                 $_SESSION["csrf_token"] = uniqid_short();
 696                         }
 697
 698                         $_SESSION["ip_address"] = $_SERVER["REMOTE_ADDR"];
 699
 700                         initialize_user_prefs($_SESSION["uid"]);
 701
 702                         return true;
 703                 }
 704         }
 705
 706         function make_password($length = 8) {
 707
 708                 $password = "";
 709                 $possible = "0123456789abcdfghjkmnpqrstvwxyzABCDFGHJKMNPQRSTVWXYZ";
 710
 711         $i = 0;
 712
 713                 while ($i < $length) {
 714                         $char = substr($possible, mt_rand(0, strlen($possible)-1), 1);
 715
 716                         if (!strstr($password, $char)) {
 717                                 $password .= $char;
 718                                 $i++;
 719                         }
 720                 }
 721                 return $password;
 722         }
 723
 724         // this is called after user is created to initialize default feeds, labels
 725         // or whatever else
 726
 727         // user preferences are checked on every login, not here
 728
 729         function initialize_user($uid) {
 730
 731                 db_query("insert into ttrss_feeds (owner_uid,title,feed_url)
 732                         values ('$uid', 'Tiny Tiny RSS: Forum',
 733                                 'http://tt-rss.org/forum/rss.php')");
 734         }
 735
 736         function logout_user() {
 737                 session_destroy();
 738                 if (isset($_COOKIE[session_name()])) {
 739                    setcookie(session_name(), '', time()-42000, '/');
 740                 }
 741         }
 742
 743         function validate_csrf($csrf_token) {
 744                 return $csrf_token == $_SESSION['csrf_token'];
 745         }
 746
 747         function load_user_plugins($owner_uid, $pluginhost = false) {
 748
 749                 if (!$pluginhost) $pluginhost = PluginHost::getInstance();
 750
 751                 if ($owner_uid && SCHEMA_VERSION >= 100) {
 752                         $plugins = get_pref("_ENABLED_PLUGINS", $owner_uid);
 753
 754                         $pluginhost->load($plugins, PluginHost::KIND_USER, $owner_uid);
 755
 756                         if (get_schema_version() > 100) {
 757                                 $pluginhost->load_data();
 758                         }
 759                 }
 760         }
 761
 762         function login_sequence() {
 763                 if (SINGLE_USER_MODE) {
 764                         @session_start();
 765                         authenticate_user("admin", null);
 766                         startup_gettext();
 767                         load_user_plugins($_SESSION["uid"]);
 768                 } else {
 769                         if (!validate_session()) $_SESSION["uid"] = false;
 770
 771                         if (!$_SESSION["uid"]) {
 772
 773                                 if (AUTH_AUTO_LOGIN && authenticate_user(null, null)) {
 774                                     $_SESSION["ref_schema_version"] = get_schema_version(true);
 775                                 } else {
 776                                          authenticate_user(null, null, true);
 777                                 }
 778
 779                                 if (!$_SESSION["uid"]) {
 780                                         @session_destroy();
 781                                         setcookie(session_name(), '', time()-42000, '/');
 782
 783                                         render_login_form();
 784                                         exit;
 785                                 }
 786
 787                         } else {
 788                                 /* bump login timestamp */
 789                                 db_query("UPDATE ttrss_users SET last_login = NOW() WHERE id = " .
 790                                         $_SESSION["uid"]);
 791                                 $_SESSION["last_login_update"] = time();
 792                         }
 793
 794                         if ($_SESSION["uid"]) {
 795                                 startup_gettext();
 796                                 load_user_plugins($_SESSION["uid"]);
 797
 798                                 /* cleanup ccache */
 799
 800                                 db_query("DELETE FROM ttrss_counters_cache WHERE owner_uid = ".
 801                                         $_SESSION["uid"] . " AND
 802                                                 (SELECT COUNT(id) FROM ttrss_feeds WHERE
 803                                                         ttrss_feeds.id = feed_id) = 0");
 804
 805                                 db_query("DELETE FROM ttrss_cat_counters_cache WHERE owner_uid = ".
 806                                         $_SESSION["uid"] . " AND
 807                                                 (SELECT COUNT(id) FROM ttrss_feed_categories WHERE
 808                                                         ttrss_feed_categories.id = feed_id) = 0");
 809
 810                         }
 811
 812                 }
 813         }
 814
 815         function truncate_string($str, $max_len, $suffix = '&hellip;') {
 816                 if (mb_strlen($str, "utf-8") > $max_len) {
 817                         return mb_substr($str, 0, $max_len, "utf-8") . $suffix;
 818                 } else {
 819                         return $str;
 820                 }
 821         }
 822
 823         // is not utf8 clean
 824         function truncate_middle($str, $max_len, $suffix = '&hellip;') {
 825                 if (strlen($str) > $max_len) {
 826                         return substr_replace($str, $suffix, $max_len / 2, mb_strlen($str) - $max_len);
 827                 } else {
 828                         return $str;
 829                 }
 830         }
 831
 832         function convert_timestamp($timestamp, $source_tz, $dest_tz) {
 833
 834                 try {
 835                         $source_tz = new DateTimeZone($source_tz);
 836                 } catch (Exception $e) {
 837                         $source_tz = new DateTimeZone('UTC');
 838                 }
 839
 840                 try {
 841                         $dest_tz = new DateTimeZone($dest_tz);
 842                 } catch (Exception $e) {
 843                         $dest_tz = new DateTimeZone('UTC');
 844                 }
 845
 846                 $dt = new DateTime(date('Y-m-d H:i:s', $timestamp), $source_tz);
 847                 return $dt->format('U') + $dest_tz->getOffset($dt);
 848         }
 849
 850         function make_local_datetime($timestamp, $long, $owner_uid = false,
 851                                         $no_smart_dt = false, $eta_min = false) {
 852
 853                 if (!$owner_uid) $owner_uid = $_SESSION['uid'];
 854                 if (!$timestamp) $timestamp = '1970-01-01 0:00';
 855
 856                 global $utc_tz;
 857                 global $user_tz;
 858
 859                 if (!$utc_tz) $utc_tz = new DateTimeZone('UTC');
 860
 861                 $timestamp = substr($timestamp, 0, 19);
 862
 863                 # We store date in UTC internally
 864                 $dt = new DateTime($timestamp, $utc_tz);
 865
 866                 $user_tz_string = get_pref('USER_TIMEZONE', $owner_uid);
 867
 868                 if ($user_tz_string != 'Automatic') {
 869
 870                         try {
 871                                 if (!$user_tz) $user_tz = new DateTimeZone($user_tz_string);
 872                         } catch (Exception $e) {
 873                                 $user_tz = $utc_tz;
 874                         }
 875
 876                         $tz_offset = $user_tz->getOffset($dt);
 877                 } else {
 878                         $tz_offset = (int) -$_SESSION["clientTzOffset"];
 879                 }
 880
 881                 $user_timestamp = $dt->format('U') + $tz_offset;
 882
 883                 if (!$no_smart_dt) {
 884                         return smart_date_time($user_timestamp,
 885                                 $tz_offset, $owner_uid, $eta_min);
 886                 } else {
 887                         if ($long)
 888                                 $format = get_pref('LONG_DATE_FORMAT', $owner_uid);
 889                         else
 890                                 $format = get_pref('SHORT_DATE_FORMAT', $owner_uid);
 891
 892                         return date($format, $user_timestamp);
 893                 }
 894         }
 895
 896         function smart_date_time($timestamp, $tz_offset = 0, $owner_uid = false, $eta_min = false) {
 897                 if (!$owner_uid) $owner_uid = $_SESSION['uid'];
 898
 899                 if ($eta_min && time() + $tz_offset - $timestamp < 3600) {
 900                         return T_sprintf("%d min", date("i", time() + $tz_offset - $timestamp));
 901                 } else if (date("Y.m.d", $timestamp) == date("Y.m.d", time() + $tz_offset)) {
 902                         return date("G:i", $timestamp);
 903                 } else if (date("Y", $timestamp) == date("Y", time() + $tz_offset)) {
 904                         $format = get_pref('SHORT_DATE_FORMAT', $owner_uid);
 905                         return date($format, $timestamp);
 906                 } else {
 907                         $format = get_pref('LONG_DATE_FORMAT', $owner_uid);
 908                         return date($format, $timestamp);
 909                 }
 910         }
 911
 912         function sql_bool_to_bool($s) {
 913                 if ($s == "t" || $s == "1" || strtolower($s) == "true") {
 914                         return true;
 915                 } else {
 916                         return false;
 917                 }
 918         }
 919
 920         function bool_to_sql_bool($s) {
 921                 if ($s) {
 922                         return "true";
 923                 } else {
 924                         return "false";
 925                 }
 926         }
 927
 928         // Session caching removed due to causing wrong redirects to upgrade
 929         // script when get_schema_version() is called on an obsolete session
 930         // created on a previous schema version.
 931         function get_schema_version($nocache = false) {
 932                 global $schema_version;
 933
 934                 if (!$schema_version && !$nocache) {
 935                         $result = db_query("SELECT schema_version FROM ttrss_version");
 936                         $version = db_fetch_result($result, 0, "schema_version");
 937                         $schema_version = $version;
 938                         return $version;
 939                 } else {
 940                         return $schema_version;
 941                 }
 942         }
 943
 944         function sanity_check() {
 945                 require_once 'errors.php';
 946                 global $ERRORS;
 947
 948                 $error_code = 0;
 949                 $schema_version = get_schema_version(true);
 950
 951                 if ($schema_version != SCHEMA_VERSION) {
 952                         $error_code = 5;
 953                 }
 954
 955                 if (DB_TYPE == "mysql") {
 956                         $result = db_query("SELECT true", false);
 957                         if (db_num_rows($result) != 1) {
 958                                 $error_code = 10;
 959                         }
 960                 }
 961
 962                 if (db_escape_string("testTEST") != "testTEST") {
 963                         $error_code = 12;
 964                 }
 965
 966                 return array("code" => $error_code, "message" => $ERRORS[$error_code]);
 967         }
 968
 969         function file_is_locked($filename) {
 970                 if (file_exists(LOCK_DIRECTORY . "/$filename")) {
 971                         if (function_exists('flock')) {
 972                                 $fp = @fopen(LOCK_DIRECTORY . "/$filename", "r");
 973                                 if ($fp) {
 974                                         if (flock($fp, LOCK_EX | LOCK_NB)) {
 975                                                 flock($fp, LOCK_UN);
 976                                                 fclose($fp);
 977                                                 return false;
 978                                         }
 979                                         fclose($fp);
 980                                         return true;
 981                                 } else {
 982                                         return false;
 983                                 }
 984                         }
 985                         return true; // consider the file always locked and skip the test
 986                 } else {
 987                         return false;
 988                 }
 989         }
 990
 991
 992         function make_lockfile($filename) {
 993                 $fp = fopen(LOCK_DIRECTORY . "/$filename", "w");
 994
 995                 if ($fp && flock($fp, LOCK_EX | LOCK_NB)) {
 996                         $stat_h = fstat($fp);
 997                         $stat_f = stat(LOCK_DIRECTORY . "/$filename");
 998
 999                         if (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN') {
1000                                 if ($stat_h["ino"] != $stat_f["ino"] ||
1001                                                 $stat_h["dev"] != $stat_f["dev"]) {
1002
1003                                         return false;
1004                                 }
1005                         }
1006
1007                         if (function_exists('posix_getpid')) {
1008                                 fwrite($fp, posix_getpid() . "\n");
1009                         }
1010                         return $fp;
1011                 } else {
1012                         return false;
1013                 }
1014         }
1015
1016         function make_stampfile($filename) {
1017                 $fp = fopen(LOCK_DIRECTORY . "/$filename", "w");
1018
1019                 if (flock($fp, LOCK_EX | LOCK_NB)) {
1020                         fwrite($fp, time() . "\n");
1021                         flock($fp, LOCK_UN);
1022                         fclose($fp);
1023                         return true;
1024                 } else {
1025                         return false;
1026                 }
1027         }
1028
1029         function sql_random_function() {
1030                 if (DB_TYPE == "mysql") {
1031                         return "RAND()";
1032                 } else {
1033                         return "RANDOM()";
1034                 }
1035         }
1036
1037         function getFeedUnread($feed, $is_cat = false) {
1038                 return Feeds::getFeedArticles($feed, $is_cat, true, $_SESSION["uid"]);
1039         }
1040
1041
1042         /*function get_pgsql_version() {
1043                 $result = db_query("SELECT version() AS version");
1044                 $version = explode(" ", db_fetch_result($result, 0, "version"));
1045                 return $version[1];
1046         }*/
1047
1048         function checkbox_to_sql_bool($val) {
1049                 return ($val == "on") ? "true" : "false";
1050         }
1051
1052         /*function getFeedCatTitle($id) {
1053                 if ($id == -1) {
1054                         return __("Special");
1055                 } else if ($id < LABEL_BASE_INDEX) {
1056                         return __("Labels");
1057                 } else if ($id > 0) {
1058                         $result = db_query("SELECT ttrss_feed_categories.title
1059                                 FROM ttrss_feeds, ttrss_feed_categories WHERE ttrss_feeds.id = '$id' AND
1060                                         cat_id = ttrss_feed_categories.id");
1061                         if (db_num_rows($result) == 1) {
1062                                 return db_fetch_result($result, 0, "title");
1063                         } else {
1064                                 return __("Uncategorized");
1065                         }
1066                 } else {
1067                         return "getFeedCatTitle($id) failed";
1068                 }
1069
1070         }*/
1071
1072         function uniqid_short() {
1073                 return uniqid(base_convert(rand(), 10, 36));
1074         }
1075
1076         function make_init_params() {
1077                 $params = array();
1078
1079                 foreach (array("ON_CATCHUP_SHOW_NEXT_FEED", "HIDE_READ_FEEDS",
1080                                          "ENABLE_FEED_CATS", "FEEDS_SORT_BY_UNREAD", "CONFIRM_FEED_CATCHUP",
1081                                          "CDM_AUTO_CATCHUP", "FRESH_ARTICLE_MAX_AGE",
1082                                          "HIDE_READ_SHOWS_SPECIAL", "COMBINED_DISPLAY_MODE") as $param) {
1083
1084                         $params[strtolower($param)] = (int) get_pref($param);
1085                 }
1086
1087                 $params["icons_url"] = ICONS_URL;
1088                 $params["cookie_lifetime"] = SESSION_COOKIE_LIFETIME;
1089                 $params["default_view_mode"] = get_pref("_DEFAULT_VIEW_MODE");
1090                 $params["default_view_limit"] = (int) get_pref("_DEFAULT_VIEW_LIMIT");
1091                 $params["default_view_order_by"] = get_pref("_DEFAULT_VIEW_ORDER_BY");
1092                 $params["bw_limit"] = (int) $_SESSION["bw_limit"];
1093                 $params["label_base_index"] = (int) LABEL_BASE_INDEX;
1094
1095                 $theme = get_pref( "USER_CSS_THEME", false, false);
1096                 $params["theme"] = theme_valid("$theme") ? $theme : "";
1097
1098                 $params["plugins"] = implode(", ", PluginHost::getInstance()->get_plugin_names());
1099
1100                 $params["php_platform"] = PHP_OS;
1101                 $params["php_version"] = PHP_VERSION;
1102
1103                 $params["sanity_checksum"] = sha1(file_get_contents("include/sanity_check.php"));
1104
1105                 $result = db_query("SELECT MAX(id) AS mid, COUNT(*) AS nf FROM
1106                                 ttrss_feeds WHERE owner_uid = " . $_SESSION["uid"]);
1107
1108                 $max_feed_id = db_fetch_result($result, 0, "mid");
1109                 $num_feeds = db_fetch_result($result, 0, "nf");
1110
1111                 $params["max_feed_id"] = (int) $max_feed_id;
1112                 $params["num_feeds"] = (int) $num_feeds;
1113
1114                 $params["hotkeys"] = get_hotkeys_map();
1115
1116                 $params["csrf_token"] = $_SESSION["csrf_token"];
1117                 $params["widescreen"] = (int) $_COOKIE["ttrss_widescreen"];
1118
1119                 $params['simple_update'] = defined('SIMPLE_UPDATE_MODE') && SIMPLE_UPDATE_MODE;
1120
1121                 $params["icon_alert"] = base64_img("images/alert.png");
1122                 $params["icon_information"] = base64_img("images/information.png");
1123                 $params["icon_cross"] = base64_img("images/cross.png");
1124                 $params["icon_indicator_white"] = base64_img("images/indicator_white.gif");
1125
1126                 return $params;
1127         }
1128
1129         function get_hotkeys_info() {
1130                 $hotkeys = array(
1131                         __("Navigation") => array(
1132                                 "next_feed" => __("Open next feed"),
1133                                 "prev_feed" => __("Open previous feed"),
1134                                 "next_article" => __("Open next article"),
1135                                 "prev_article" => __("Open previous article"),
1136                                 "next_article_noscroll" => __("Open next article (don't scroll long articles)"),
1137                                 "prev_article_noscroll" => __("Open previous article (don't scroll long articles)"),
1138                                 "next_article_noexpand" => __("Move to next article (don't expand or mark read)"),
1139                                 "prev_article_noexpand" => __("Move to previous article (don't expand or mark read)"),
1140                                 "search_dialog" => __("Show search dialog")),
1141                         __("Article") => array(
1142                                 "toggle_mark" => __("Toggle starred"),
1143                                 "toggle_publ" => __("Toggle published"),
1144                                 "toggle_unread" => __("Toggle unread"),
1145                                 "edit_tags" => __("Edit tags"),
1146                                 "open_in_new_window" => __("Open in new window"),
1147                                 "catchup_below" => __("Mark below as read"),
1148                                 "catchup_above" => __("Mark above as read"),
1149                                 "article_scroll_down" => __("Scroll down"),
1150                                 "article_scroll_up" => __("Scroll up"),
1151                                 "select_article_cursor" => __("Select article under cursor"),
1152                                 "email_article" => __("Email article"),
1153                                 "close_article" => __("Close/collapse article"),
1154                                 "toggle_expand" => __("Toggle article expansion (combined mode)"),
1155                                 "toggle_widescreen" => __("Toggle widescreen mode"),
1156                                 "toggle_embed_original" => __("Toggle embed original")),
1157                         __("Article selection") => array(
1158                                 "select_all" => __("Select all articles"),
1159                                 "select_unread" => __("Select unread"),
1160                                 "select_marked" => __("Select starred"),
1161                                 "select_published" => __("Select published"),
1162                                 "select_invert" => __("Invert selection"),
1163                                 "select_none" => __("Deselect everything")),
1164                         __("Feed") => array(
1165                                 "feed_refresh" => __("Refresh current feed"),
1166                                 "feed_unhide_read" => __("Un/hide read feeds"),
1167                                 "feed_subscribe" => __("Subscribe to feed"),
1168                                 "feed_edit" => __("Edit feed"),
1169                                 "feed_catchup" => __("Mark as read"),
1170                                 "feed_reverse" => __("Reverse headlines"),
1171                                 "feed_toggle_vgroup" => __("Toggle headline grouping"),
1172                                 "feed_debug_update" => __("Debug feed update"),
1173                                 "feed_debug_viewfeed" => __("Debug viewfeed()"),
1174                                 "catchup_all" => __("Mark all feeds as read"),
1175                                 "cat_toggle_collapse" => __("Un/collapse current category"),
1176                                 "toggle_combined_mode" => __("Toggle combined mode"),
1177                                 "toggle_cdm_expanded" => __("Toggle auto expand in combined mode")),
1178                         __("Go to") => array(
1179                                 "goto_all" => __("All articles"),
1180                                 "goto_fresh" => __("Fresh"),
1181                                 "goto_marked" => __("Starred"),
1182                                 "goto_published" => __("Published"),
1183                                 "goto_tagcloud" => __("Tag cloud"),
1184                                 "goto_prefs" => __("Preferences")),
1185                         __("Other") => array(
1186                                 "create_label" => __("Create label"),
1187                                 "create_filter" => __("Create filter"),
1188                                 "collapse_sidebar" => __("Un/collapse sidebar"),
1189                                 "help_dialog" => __("Show help dialog"))
1190                 );
1191
1192                 foreach (PluginHost::getInstance()->get_hooks(PluginHost::HOOK_HOTKEY_INFO) as $plugin) {
1193                         $hotkeys = $plugin->hook_hotkey_info($hotkeys);
1194                 }
1195
1196                 return $hotkeys;
1197         }
1198
1199         function get_hotkeys_map() {
1200                 $hotkeys = array(
1201         //                      "navigation" => array(
1202                         "k" => "next_feed",
1203                         "j" => "prev_feed",
1204                         "n" => "next_article",
1205                         "p" => "prev_article",
1206                         "(38)|up" => "prev_article",
1207                         "(40)|down" => "next_article",
1208         //                              "^(38)|Ctrl-up" => "prev_article_noscroll",
1209         //                              "^(40)|Ctrl-down" => "next_article_noscroll",
1210                         "(191)|/" => "search_dialog",
1211         //                      "article" => array(
1212                         "s" => "toggle_mark",
1213                         "*s" => "toggle_publ",
1214                         "u" => "toggle_unread",
1215                         "*t" => "edit_tags",
1216                         "o" => "open_in_new_window",
1217                         "c p" => "catchup_below",
1218                         "c n" => "catchup_above",
1219                         "*n" => "article_scroll_down",
1220                         "*p" => "article_scroll_up",
1221                         "*(38)|Shift+up" => "article_scroll_up",
1222                         "*(40)|Shift+down" => "article_scroll_down",
1223                         "a *w" => "toggle_widescreen",
1224                         "a e" => "toggle_embed_original",
1225                         "e" => "email_article",
1226                         "a q" => "close_article",
1227         //                      "article_selection" => array(
1228                         "a a" => "select_all",
1229                         "a u" => "select_unread",
1230                         "a *u" => "select_marked",
1231                         "a p" => "select_published",
1232                         "a i" => "select_invert",
1233                         "a n" => "select_none",
1234         //                      "feed" => array(
1235                         "f r" => "feed_refresh",
1236                         "f a" => "feed_unhide_read",
1237                         "f s" => "feed_subscribe",
1238                         "f e" => "feed_edit",
1239                         "f q" => "feed_catchup",
1240                         "f x" => "feed_reverse",
1241                         "f g" => "feed_toggle_vgroup",
1242                         "f *d" => "feed_debug_update",
1243                         "f *g" => "feed_debug_viewfeed",
1244                         "f *c" => "toggle_combined_mode",
1245                         "f c" => "toggle_cdm_expanded",
1246                         "*q" => "catchup_all",
1247                         "x" => "cat_toggle_collapse",
1248         //                      "goto" => array(
1249                         "g a" => "goto_all",
1250                         "g f" => "goto_fresh",
1251                         "g s" => "goto_marked",
1252                         "g p" => "goto_published",
1253                         "g t" => "goto_tagcloud",
1254                         "g *p" => "goto_prefs",
1255         //                      "other" => array(
1256                         "(9)|Tab" => "select_article_cursor", // tab
1257                         "c l" => "create_label",
1258                         "c f" => "create_filter",
1259                         "c s" => "collapse_sidebar",
1260                         "^(191)|Ctrl+/" => "help_dialog",
1261                 );
1262
1263                 if (get_pref('COMBINED_DISPLAY_MODE')) {
1264                         $hotkeys["^(38)|Ctrl-up"] = "prev_article_noscroll";
1265                         $hotkeys["^(40)|Ctrl-down"] = "next_article_noscroll";
1266                 }
1267
1268                 foreach (PluginHost::getInstance()->get_hooks(PluginHost::HOOK_HOTKEY_MAP) as $plugin) {
1269                         $hotkeys = $plugin->hook_hotkey_map($hotkeys);
1270                 }
1271
1272                 $prefixes = array();
1273
1274                 foreach (array_keys($hotkeys) as $hotkey) {
1275                         $pair = explode(" ", $hotkey, 2);
1276
1277                         if (count($pair) > 1 && !in_array($pair[0], $prefixes)) {
1278                                 array_push($prefixes, $pair[0]);
1279                         }
1280                 }
1281
1282                 return array($prefixes, $hotkeys);
1283         }
1284
1285         function check_for_update() {
1286                 if (defined("GIT_VERSION_TIMESTAMP")) {
1287                         $content = @fetch_file_contents(array("url" => "http://tt-rss.org/version.json", "timeout" => 5));
1288
1289                         if ($content) {
1290                                 $content = json_decode($content, true);
1291
1292                                 if ($content && isset($content["changeset"])) {
1293                                         if ((int)GIT_VERSION_TIMESTAMP < (int)$content["changeset"]["timestamp"] &&
1294                                                 GIT_VERSION_HEAD != $content["changeset"]["id"]) {
1295
1296                                                 return $content["changeset"]["id"];
1297                                         }
1298                                 }
1299                         }
1300                 }
1301
1302                 return "";
1303         }
1304
1305         function make_runtime_info($disable_update_check = false) {
1306                 $data = array();
1307
1308                 $result = db_query("SELECT MAX(id) AS mid, COUNT(*) AS nf FROM
1309                                 ttrss_feeds WHERE owner_uid = " . $_SESSION["uid"]);
1310
1311                 $max_feed_id = db_fetch_result($result, 0, "mid");
1312                 $num_feeds = db_fetch_result($result, 0, "nf");
1313
1314                 $data["max_feed_id"] = (int) $max_feed_id;
1315                 $data["num_feeds"] = (int) $num_feeds;
1316
1317                 $data['last_article_id'] = Article::getLastArticleId();
1318                 $data['cdm_expanded'] = get_pref('CDM_EXPANDED');
1319
1320                 $data['dep_ts'] = calculate_dep_timestamp();
1321                 $data['reload_on_ts_change'] = !defined('_NO_RELOAD_ON_TS_CHANGE');
1322
1323
1324                 if (CHECK_FOR_UPDATES && !$disable_update_check && $_SESSION["last_version_check"] + 86400 + rand(-1000, 1000) < time()) {
1325                         $update_result = @check_for_update();
1326
1327                         $data["update_result"] = $update_result;
1328
1329                         $_SESSION["last_version_check"] = time();
1330                 }
1331
1332                 if (file_exists(LOCK_DIRECTORY . "/update_daemon.lock")) {
1333
1334                         $data['daemon_is_running'] = (int) file_is_locked("update_daemon.lock");
1335
1336                         if (time() - $_SESSION["daemon_stamp_check"] > 30) {
1337
1338                                 $stamp = (int) @file_get_contents(LOCK_DIRECTORY . "/update_daemon.stamp");
1339
1340                                 if ($stamp) {
1341                                         $stamp_delta = time() - $stamp;
1342
1343                                         if ($stamp_delta > 1800) {
1344                                                 $stamp_check = 0;
1345                                         } else {
1346                                                 $stamp_check = 1;
1347                                                 $_SESSION["daemon_stamp_check"] = time();
1348                                         }
1349
1350                                         $data['daemon_stamp_ok'] = $stamp_check;
1351
1352                                         $stamp_fmt = date("Y.m.d, G:i", $stamp);
1353
1354                                         $data['daemon_stamp'] = $stamp_fmt;
1355                                 }
1356                         }
1357                 }
1358
1359                 return $data;
1360         }
1361
1362         function search_to_sql($search, $search_language) {
1363
1364                 $keywords = str_getcsv(trim($search), " ");
1365                 $query_keywords = array();
1366                 $search_words = array();
1367                 $search_query_leftover = array();
1368
1369                 if ($search_language)
1370                         $search_language = db_escape_string(mb_strtolower($search_language));
1371                 else
1372                         $search_language = "english";
1373
1374                 foreach ($keywords as $k) {
1375                         if (strpos($k, "-") === 0) {
1376                                 $k = substr($k, 1);
1377                                 $not = "NOT";
1378                         } else {
1379                                 $not = "";
1380                         }
1381
1382                         $commandpair = explode(":", mb_strtolower($k), 2);
1383
1384                         switch ($commandpair[0]) {
1385                                 case "title":
1386                                         if ($commandpair[1]) {
1387                                                 array_push($query_keywords, "($not (LOWER(ttrss_entries.title) LIKE '%".
1388                                                         db_escape_string(mb_strtolower($commandpair[1]))."%'))");
1389                                         } else {
1390                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1391                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1392                                                 array_push($search_words, $k);
1393                                         }
1394                                         break;
1395                                 case "author":
1396                                         if ($commandpair[1]) {
1397                                                 array_push($query_keywords, "($not (LOWER(author) LIKE '%".
1398                                                         db_escape_string(mb_strtolower($commandpair[1]))."%'))");
1399                                         } else {
1400                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1401                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1402                                                 array_push($search_words, $k);
1403                                         }
1404                                         break;
1405                                 case "note":
1406                                         if ($commandpair[1]) {
1407                                                 if ($commandpair[1] == "true")
1408                                                         array_push($query_keywords, "($not (note IS NOT NULL AND note != ''))");
1409                                                 else if ($commandpair[1] == "false")
1410                                                         array_push($query_keywords, "($not (note IS NULL OR note = ''))");
1411                                                 else
1412                                                         array_push($query_keywords, "($not (LOWER(note) LIKE '%".
1413                                                                 db_escape_string(mb_strtolower($commandpair[1]))."%'))");
1414                                         } else {
1415                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1416                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1417                                                 if (!$not) array_push($search_words, $k);
1418                                         }
1419                                         break;
1420                                 case "star":
1421
1422                                         if ($commandpair[1]) {
1423                                                 if ($commandpair[1] == "true")
1424                                                         array_push($query_keywords, "($not (marked = true))");
1425                                                 else
1426                                                         array_push($query_keywords, "($not (marked = false))");
1427                                         } else {
1428                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1429                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1430                                                 if (!$not) array_push($search_words, $k);
1431                                         }
1432                                         break;
1433                                 case "pub":
1434                                         if ($commandpair[1]) {
1435                                                 if ($commandpair[1] == "true")
1436                                                         array_push($query_keywords, "($not (published = true))");
1437                                                 else
1438                                                         array_push($query_keywords, "($not (published = false))");
1439
1440                                         } else {
1441                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1442                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1443                                                 if (!$not) array_push($search_words, $k);
1444                                         }
1445                                         break;
1446                                 case "unread":
1447                                         if ($commandpair[1]) {
1448                                                 if ($commandpair[1] == "true")
1449                                                         array_push($query_keywords, "($not (unread = true))");
1450                                                 else
1451                                                         array_push($query_keywords, "($not (unread = false))");
1452
1453                                         } else {
1454                                                 array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1455                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1456                                                 if (!$not) array_push($search_words, $k);
1457                                         }
1458                                         break;
1459                                 default:
1460                                         if (strpos($k, "@") === 0) {
1461
1462                                                 $user_tz_string = get_pref('USER_TIMEZONE', $_SESSION['uid']);
1463                                                 $orig_ts = strtotime(substr($k, 1));
1464                                                 $k = date("Y-m-d", convert_timestamp($orig_ts, $user_tz_string, 'UTC'));
1465
1466                                                 //$k = date("Y-m-d", strtotime(substr($k, 1)));
1467
1468                                                 array_push($query_keywords, "(".SUBSTRING_FOR_DATE."(updated,1,LENGTH('$k')) $not = '$k')");
1469                                         } else {
1470
1471                                                 if (DB_TYPE == "pgsql") {
1472                                                         $k = mb_strtolower($k);
1473                                                         array_push($search_query_leftover, $not ? "!$k" : $k);
1474                                                 } else {
1475                                                         array_push($query_keywords, "(UPPER(ttrss_entries.title) $not LIKE UPPER('%$k%')
1476                                                                 OR UPPER(ttrss_entries.content) $not LIKE UPPER('%$k%'))");
1477                                                 }
1478
1479                                                 if (!$not) array_push($search_words, $k);
1480                                         }
1481                         }
1482                 }
1483
1484                 if (count($search_query_leftover) > 0) {
1485                         $search_query_leftover = db_escape_string(implode(" & ", $search_query_leftover));
1486
1487                         if (DB_TYPE == "pgsql") {
1488                                 array_push($query_keywords,
1489                                         "(tsvector_combined @@ to_tsquery('$search_language', '$search_query_leftover'))");
1490                         }
1491
1492                 }
1493
1494                 $search_query_part = implode("AND", $query_keywords);
1495
1496                 return array($search_query_part, $search_words);
1497         }
1498
1499         function iframe_whitelisted($entry) {
1500                 $whitelist = array("youtube.com", "youtu.be", "vimeo.com", "player.vimeo.com");
1501
1502                 @$src = parse_url($entry->getAttribute("src"), PHP_URL_HOST);
1503
1504                 if ($src) {
1505                         foreach ($whitelist as $w) {
1506                                 if ($src == $w || $src == "www.$w")
1507                                         return true;
1508                         }
1509                 }
1510
1511                 return false;
1512         }
1513
1514         function sanitize($str, $force_remove_images = false, $owner = false, $site_url = false, $highlight_words = false, $article_id = false) {
1515                 if (!$owner) $owner = $_SESSION["uid"];
1516
1517                 $res = trim($str); if (!$res) return '';
1518
1519                 $charset_hack = '<head>
1520                                 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
1521                         </head>';
1522
1523                 $res = trim($res); if (!$res) return '';
1524
1525                 libxml_use_internal_errors(true);
1526
1527                 $doc = new DOMDocument();
1528                 $doc->loadHTML($charset_hack . $res);
1529                 $xpath = new DOMXPath($doc);
1530
1531                 $ttrss_uses_https = parse_url(get_self_url_prefix(), PHP_URL_SCHEME) === 'https';
1532                 $rewrite_base_url = $site_url ? $site_url : SELF_URL_PATH;
1533
1534                 $entries = $xpath->query('(//a[@href]|//img[@src]|//video/source[@src]|//audio/source[@src])');
1535
1536                 foreach ($entries as $entry) {
1537
1538                         if ($entry->hasAttribute('href')) {
1539                                 $entry->setAttribute('href',
1540                                         rewrite_relative_url($rewrite_base_url, $entry->getAttribute('href')));
1541
1542                                 $entry->setAttribute('rel', 'noopener noreferrer');
1543                         }
1544
1545                         if ($entry->hasAttribute('src')) {
1546                                 $src = rewrite_relative_url($rewrite_base_url, $entry->getAttribute('src'));
1547                                 $cached_filename = CACHE_DIR . '/images/' . sha1($src);
1548
1549                                 if (file_exists($cached_filename)) {
1550
1551                                         // this is strictly cosmetic
1552                                         if ($entry->tagName == 'img') {
1553                                                 $suffix = ".png";
1554                                         } else if ($entry->parentNode && $entry->parentNode->tagName == "video") {
1555                                                 $suffix = ".mp4";
1556                                         } else if ($entry->parentNode && $entry->parentNode->tagName == "audio") {
1557                                                 $suffix = ".ogg";
1558                                         } else {
1559                                                 $suffix = "";
1560                                         }
1561
1562                                         $src = get_self_url_prefix() . '/public.php?op=cached_url&hash=' . sha1($src) . $suffix;
1563
1564                                         if ($entry->hasAttribute('srcset')) {
1565                                                 $entry->removeAttribute('srcset');
1566                                         }
1567
1568                                         if ($entry->hasAttribute('sizes')) {
1569                                                 $entry->removeAttribute('sizes');
1570                                         }
1571                                 }
1572
1573                                 $entry->setAttribute('src', $src);
1574                         }
1575
1576                         if ($entry->nodeName == 'img') {
1577
1578                                 if ($entry->hasAttribute('src')) {
1579                                         $is_https_url = parse_url($entry->getAttribute('src'), PHP_URL_SCHEME) === 'https';
1580
1581                                         if ($ttrss_uses_https && !$is_https_url) {
1582
1583                                                 if ($entry->hasAttribute('srcset')) {
1584                                                         $entry->removeAttribute('srcset');
1585                                                 }
1586
1587                                                 if ($entry->hasAttribute('sizes')) {
1588                                                         $entry->removeAttribute('sizes');
1589                                                 }
1590                                         }
1591                                 }
1592
1593                                 if (($owner && get_pref("STRIP_IMAGES", $owner)) ||
1594                                         $force_remove_images || $_SESSION["bw_limit"]) {
1595
1596                                         $p = $doc->createElement('p');
1597
1598                                         $a = $doc->createElement('a');
1599                                         $a->setAttribute('href', $entry->getAttribute('src'));
1600
1601                                         $a->appendChild(new DOMText($entry->getAttribute('src')));
1602                                         $a->setAttribute('target', '_blank');
1603                                         $a->setAttribute('rel', 'noopener noreferrer');
1604
1605                                         $p->appendChild($a);
1606
1607                                         $entry->parentNode->replaceChild($p, $entry);
1608                                 }
1609                         }
1610
1611                         if (strtolower($entry->nodeName) == "a") {
1612                                 $entry->setAttribute("target", "_blank");
1613                                 $entry->setAttribute("rel", "noopener noreferrer");
1614                         }
1615                 }
1616
1617                 $entries = $xpath->query('//iframe');
1618                 foreach ($entries as $entry) {
1619                         if (!iframe_whitelisted($entry)) {
1620                                 $entry->setAttribute('sandbox', 'allow-scripts');
1621                         } else {
1622                                 if ($_SERVER['HTTPS'] == "on") {
1623                                         $entry->setAttribute("src",
1624                                                 str_replace("http://", "https://",
1625                                                         $entry->getAttribute("src")));
1626                                 }
1627                         }
1628                 }
1629
1630                 $allowed_elements = array('a', 'address', 'acronym', 'audio', 'article', 'aside',
1631                         'b', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br',
1632                         'caption', 'cite', 'center', 'code', 'col', 'colgroup',
1633                         'data', 'dd', 'del', 'details', 'description', 'dfn', 'div', 'dl', 'font',
1634                         'dt', 'em', 'footer', 'figure', 'figcaption',
1635                         'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'html', 'i',
1636                         'img', 'ins', 'kbd', 'li', 'main', 'mark', 'nav', 'noscript',
1637                         'ol', 'p', 'pre', 'q', 'ruby', 'rp', 'rt', 's', 'samp', 'section',
1638                         'small', 'source', 'span', 'strike', 'strong', 'sub', 'summary',
1639                         'sup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'time',
1640                         'tr', 'track', 'tt', 'u', 'ul', 'var', 'wbr', 'video', 'xml:namespace' );
1641
1642                 if ($_SESSION['hasSandbox']) $allowed_elements[] = 'iframe';
1643
1644                 $disallowed_attributes = array('id', 'style', 'class');
1645
1646                 foreach (PluginHost::getInstance()->get_hooks(PluginHost::HOOK_SANITIZE) as $plugin) {
1647                         $retval = $plugin->hook_sanitize($doc, $site_url, $allowed_elements, $disallowed_attributes, $article_id);
1648                         if (is_array($retval)) {
1649                                 $doc = $retval[0];
1650                                 $allowed_elements = $retval[1];
1651                                 $disallowed_attributes = $retval[2];
1652                         } else {
1653                                 $doc = $retval;
1654                         }
1655                 }
1656
1657                 $doc->removeChild($doc->firstChild); //remove doctype
1658                 $doc = strip_harmful_tags($doc, $allowed_elements, $disallowed_attributes);
1659
1660                 if ($highlight_words) {
1661                         foreach ($highlight_words as $word) {
1662
1663                                 // http://stackoverflow.com/questions/4081372/highlight-keywords-in-a-paragraph
1664
1665                                 $elements = $xpath->query("//*/text()");
1666
1667                                 foreach ($elements as $child) {
1668
1669                                         $fragment = $doc->createDocumentFragment();
1670                                         $text = $child->textContent;
1671
1672                                         while (($pos = mb_stripos($text, $word)) !== false) {
1673                                                 $fragment->appendChild(new DomText(mb_substr($text, 0, $pos)));
1674                                                 $word = mb_substr($text, $pos, mb_strlen($word));
1675                                                 $highlight = $doc->createElement('span');
1676                                                 $highlight->appendChild(new DomText($word));
1677                                                 $highlight->setAttribute('class', 'highlight');
1678                                                 $fragment->appendChild($highlight);
1679                                                 $text = mb_substr($text, $pos + mb_strlen($word));
1680                                         }
1681
1682                                         if (!empty($text)) $fragment->appendChild(new DomText($text));
1683
1684                                         $child->parentNode->replaceChild($fragment, $child);
1685                                 }
1686                         }
1687                 }
1688
1689                 $res = $doc->saveHTML();
1690
1691                 /* strip everything outside of <body>...</body> */
1692
1693                 $res_frag = array();
1694                 if (preg_match('/<body>(.*)<\/body>/is', $res, $res_frag)) {
1695                         return $res_frag[1];
1696                 } else {
1697                         return $res;
1698                 }
1699         }
1700
1701         function strip_harmful_tags($doc, $allowed_elements, $disallowed_attributes) {
1702                 $xpath = new DOMXPath($doc);
1703                 $entries = $xpath->query('//*');
1704
1705                 foreach ($entries as $entry) {
1706                         if (!in_array($entry->nodeName, $allowed_elements)) {
1707                                 $entry->parentNode->removeChild($entry);
1708                         }
1709
1710                         if ($entry->hasAttributes()) {
1711                                 $attrs_to_remove = array();
1712
1713                                 foreach ($entry->attributes as $attr) {
1714
1715                                         if (strpos($attr->nodeName, 'on') === 0) {
1716                                                 array_push($attrs_to_remove, $attr);
1717                                         }
1718
1719                                         if ($attr->nodeName == 'href' && stripos($attr->value, 'javascript:') === 0) {
1720                                                 array_push($attrs_to_remove, $attr);
1721                                         }
1722
1723                                         if (in_array($attr->nodeName, $disallowed_attributes)) {
1724                                                 array_push($attrs_to_remove, $attr);
1725                                         }
1726                                 }
1727
1728                                 foreach ($attrs_to_remove as $attr) {
1729                                         $entry->removeAttributeNode($attr);
1730                                 }
1731                         }
1732                 }
1733
1734                 return $doc;
1735         }
1736
1737         function trim_array($array) {
1738                 $tmp = $array;
1739                 array_walk($tmp, 'trim');
1740                 return $tmp;
1741         }
1742
1743         function tag_is_valid($tag) {
1744                 if ($tag == '') return false;
1745                 if (is_numeric($tag)) return false;
1746                 if (mb_strlen($tag) > 250) return false;
1747
1748                 if (!$tag) return false;
1749
1750                 return true;
1751         }
1752
1753         function render_login_form() {
1754                 header('Cache-Control: public');
1755
1756                 require_once "login_form.php";
1757                 exit;
1758         }
1759
1760         function T_sprintf() {
1761                 $args = func_get_args();
1762                 return vsprintf(__(array_shift($args)), $args);
1763         }
1764
1765         function print_checkpoint($n, $s) {
1766                 $ts = microtime(true);
1767                 echo sprintf("<!-- CP[$n] %.4f seconds -->\n", $ts - $s);
1768                 return $ts;
1769         }
1770
1771         function sanitize_tag($tag) {
1772                 $tag = trim($tag);
1773
1774                 $tag = mb_strtolower($tag, 'utf-8');
1775
1776                 $tag = preg_replace('/[,\'\"\+\>\<]/', "", $tag);
1777
1778                 if (DB_TYPE == "mysql") {
1779                         $tag = preg_replace('/[\x{10000}-\x{10FFFF}]/u', "\xEF\xBF\xBD", $tag);
1780                 }
1781
1782                 return $tag;
1783         }
1784
1785         function get_self_url_prefix() {
1786                 if (strrpos(SELF_URL_PATH, "/") === strlen(SELF_URL_PATH)-1) {
1787                         return substr(SELF_URL_PATH, 0, strlen(SELF_URL_PATH)-1);
1788                 } else {
1789                         return SELF_URL_PATH;
1790                 }
1791         }
1792
1793         function encrypt_password($pass, $salt = '', $mode2 = false) {
1794                 if ($salt && $mode2) {
1795                         return "MODE2:" . hash('sha256', $salt . $pass);
1796                 } else if ($salt) {
1797                         return "SHA1X:" . sha1("$salt:$pass");
1798                 } else {
1799                         return "SHA1:" . sha1($pass);
1800                 }
1801         } // function encrypt_password
1802
1803         function load_filters($feed_id, $owner_uid) {
1804                 $filters = array();
1805
1806                 $cat_id = (int)Feeds::getFeedCategory($feed_id);
1807
1808                 if ($cat_id == 0)
1809                         $null_cat_qpart = "cat_id IS NULL OR";
1810                 else
1811                         $null_cat_qpart = "";
1812
1813                 $result = db_query("SELECT * FROM ttrss_filters2 WHERE
1814                                 owner_uid = $owner_uid AND enabled = true ORDER BY order_id, title");
1815
1816                 $check_cats = array_merge(
1817                         Feeds::getParentCategories($cat_id, $owner_uid),
1818                         [$cat_id]);
1819
1820                 $check_cats_str = join(",", $check_cats);
1821                 $check_cats_fullids = array_map(function($a) { return "CAT:$a"; }, $check_cats);
1822
1823                 while ($line = db_fetch_assoc($result)) {
1824                         $filter_id = $line["id"];
1825
1826             $match_any_rule = sql_bool_to_bool($line["match_any_rule"]);
1827
1828                         $result2 = db_query("SELECT
1829                                         r.reg_exp, r.inverse, r.feed_id, r.cat_id, r.cat_filter, r.match_on, t.name AS type_name
1830                                         FROM ttrss_filters2_rules AS r,
1831                                         ttrss_filter_types AS t
1832                                         WHERE
1833                                             (match_on IS NOT NULL OR
1834                                                   (($null_cat_qpart (cat_id IS NULL AND cat_filter = false) OR cat_id IN ($check_cats_str)) AND
1835                                                   (feed_id IS NULL OR feed_id = '$feed_id'))) AND
1836                                                 filter_type = t.id AND filter_id = '$filter_id'");
1837
1838                         $rules = array();
1839                         $actions = array();
1840
1841                         while ($rule_line = db_fetch_assoc($result2)) {
1842         #                               print_r($rule_line);
1843
1844                 if ($rule_line["match_on"]) {
1845                     $match_on = json_decode($rule_line["match_on"], true);
1846
1847                     if (in_array("0", $match_on) || in_array($feed_id, $match_on) || count(array_intersect($check_cats_fullids, $match_on)) > 0) {
1848
1849                         $rule = array();
1850                         $rule["reg_exp"] = $rule_line["reg_exp"];
1851                         $rule["type"] = $rule_line["type_name"];
1852                         $rule["inverse"] = sql_bool_to_bool($rule_line["inverse"]);
1853
1854                         array_push($rules, $rule);
1855                     } else if (!$match_any_rule) {
1856                         // this filter contains a rule that doesn't match to this feed/category combination
1857                         // thus filter has to be rejected
1858
1859                         $rules = [];
1860                         break;
1861                     }
1862
1863                 } else {
1864
1865                     $rule = array();
1866                     $rule["reg_exp"] = $rule_line["reg_exp"];
1867                     $rule["type"] = $rule_line["type_name"];
1868                     $rule["inverse"] = sql_bool_to_bool($rule_line["inverse"]);
1869
1870                     array_push($rules, $rule);
1871                 }
1872                         }
1873
1874                         if (count($rules) > 0) {
1875                 $result2 = db_query("SELECT a.action_param,t.name AS type_name
1876                         FROM ttrss_filters2_actions AS a,
1877                         ttrss_filter_actions AS t
1878                         WHERE
1879                             action_id = t.id AND filter_id = '$filter_id'");
1880
1881                 while ($action_line = db_fetch_assoc($result2)) {
1882                     #                           print_r($action_line);
1883
1884                     $action = array();
1885                     $action["type"] = $action_line["type_name"];
1886                     $action["param"] = $action_line["action_param"];
1887
1888                     array_push($actions, $action);
1889                 }
1890             }
1891
1892                         $filter = array();
1893                         $filter["match_any_rule"] = sql_bool_to_bool($line["match_any_rule"]);
1894                         $filter["inverse"] = sql_bool_to_bool($line["inverse"]);
1895                         $filter["rules"] = $rules;
1896                         $filter["actions"] = $actions;
1897
1898                         if (count($rules) > 0 && count($actions) > 0) {
1899                                 array_push($filters, $filter);
1900                         }
1901                 }
1902
1903                 return $filters;
1904         }
1905
1906         function get_score_pic($score) {
1907                 if ($score > 100) {
1908                         return "score_high.png";
1909                 } else if ($score > 0) {
1910                         return "score_half_high.png";
1911                 } else if ($score < -100) {
1912                         return "score_low.png";
1913                 } else if ($score < 0) {
1914                         return "score_half_low.png";
1915                 } else {
1916                         return "score_neutral.png";
1917                 }
1918         }
1919
1920         function feed_has_icon($id) {
1921                 return is_file(ICONS_DIR . "/$id.ico") && filesize(ICONS_DIR . "/$id.ico") > 0;
1922         }
1923
1924         function init_plugins() {
1925                 PluginHost::getInstance()->load(PLUGINS, PluginHost::KIND_ALL);
1926
1927                 return true;
1928         }
1929
1930         function add_feed_category($feed_cat, $parent_cat_id = false) {
1931
1932                 if (!$feed_cat) return false;
1933
1934                 db_query("BEGIN");
1935
1936                 if ($parent_cat_id) {
1937                         $parent_qpart = "parent_cat = '$parent_cat_id'";
1938                         $parent_insert = "'$parent_cat_id'";
1939                 } else {
1940                         $parent_qpart = "parent_cat IS NULL";
1941                         $parent_insert = "NULL";
1942                 }
1943
1944                 $feed_cat = mb_substr($feed_cat, 0, 250);
1945
1946                 $result = db_query(
1947                         "SELECT id FROM ttrss_feed_categories
1948                                 WHERE $parent_qpart AND title = '$feed_cat' AND owner_uid = ".$_SESSION["uid"]);
1949
1950                 if (db_num_rows($result) == 0) {
1951
1952                         $result = db_query(
1953                                 "INSERT INTO ttrss_feed_categories (owner_uid,title,parent_cat)
1954                                         VALUES ('".$_SESSION["uid"]."', '$feed_cat', $parent_insert)");
1955
1956                         db_query("COMMIT");
1957
1958                         return true;
1959                 }
1960
1961                 return false;
1962         }
1963
1964         /**
1965          * Fixes incomplete URLs by prepending "http://".
1966          * Also replaces feed:// with http://, and
1967          * prepends a trailing slash if the url is a domain name only.
1968          *
1969          * @param string $url Possibly incomplete URL
1970          *
1971          * @return string Fixed URL.
1972          */
1973         function fix_url($url) {
1974
1975                 // support schema-less urls
1976                 if (strpos($url, '//') === 0) {
1977                         $url = 'https:' . $url;
1978                 }
1979
1980                 if (strpos($url, '://') === false) {
1981                         $url = 'http://' . $url;
1982                 } else if (substr($url, 0, 5) == 'feed:') {
1983                         $url = 'http:' . substr($url, 5);
1984                 }
1985
1986                 //prepend slash if the URL has no slash in it
1987                 // "http://www.example" -> "http://www.example/"
1988                 if (strpos($url, '/', strpos($url, ':') + 3) === false) {
1989                         $url .= '/';
1990                 }
1991
1992                 //convert IDNA hostname to punycode if possible
1993                 if (function_exists("idn_to_ascii")) {
1994                         $parts = parse_url($url);
1995                         if (mb_detect_encoding($parts['host']) != 'ASCII')
1996                         {
1997                                 $parts['host'] = idn_to_ascii($parts['host']);
1998                                 $url = build_url($parts);
1999                         }
2000                 }
2001
2002                 if ($url != "http:///")
2003                         return $url;
2004                 else
2005                         return '';
2006         }
2007
2008         function validate_feed_url($url) {
2009                 $parts = parse_url($url);
2010
2011                 return ($parts['scheme'] == 'http' || $parts['scheme'] == 'feed' || $parts['scheme'] == 'https');
2012
2013         }
2014
2015         /* function save_email_address($email) {
2016                 // FIXME: implement persistent storage of emails
2017
2018                 if (!$_SESSION['stored_emails'])
2019                         $_SESSION['stored_emails'] = array();
2020
2021                 if (!in_array($email, $_SESSION['stored_emails']))
2022                         array_push($_SESSION['stored_emails'], $email);
2023         } */
2024
2025
2026         function get_feed_access_key($feed_id, $is_cat, $owner_uid = false) {
2027
2028                 if (!$owner_uid) $owner_uid = $_SESSION["uid"];
2029
2030                 $sql_is_cat = bool_to_sql_bool($is_cat);
2031
2032                 $result = db_query("SELECT access_key FROM ttrss_access_keys
2033                                 WHERE feed_id = '$feed_id'      AND is_cat = $sql_is_cat
2034                                 AND owner_uid = " . $owner_uid);
2035
2036                 if (db_num_rows($result) == 1) {
2037                         return db_fetch_result($result, 0, "access_key");
2038                 } else {
2039                         $key = db_escape_string(uniqid_short());
2040
2041                         $result = db_query("INSERT INTO ttrss_access_keys
2042                                         (access_key, feed_id, is_cat, owner_uid)
2043                                         VALUES ('$key', '$feed_id', $sql_is_cat, '$owner_uid')");
2044
2045                         return $key;
2046                 }
2047                 return false;
2048         }
2049
2050         function get_feeds_from_html($url, $content)
2051         {
2052                 $url     = fix_url($url);
2053                 $baseUrl = substr($url, 0, strrpos($url, '/') + 1);
2054
2055                 libxml_use_internal_errors(true);
2056
2057                 $doc = new DOMDocument();
2058                 $doc->loadHTML($content);
2059                 $xpath = new DOMXPath($doc);
2060                 $entries = $xpath->query('/html/head/link[@rel="alternate" and '.
2061                         '(contains(@type,"rss") or contains(@type,"atom"))]|/html/head/link[@rel="feed"]');
2062                 $feedUrls = array();
2063                 foreach ($entries as $entry) {
2064                         if ($entry->hasAttribute('href')) {
2065                                 $title = $entry->getAttribute('title');
2066                                 if ($title == '') {
2067                                         $title = $entry->getAttribute('type');
2068                                 }
2069                                 $feedUrl = rewrite_relative_url(
2070                                         $baseUrl, $entry->getAttribute('href')
2071                                 );
2072                                 $feedUrls[$feedUrl] = $title;
2073                         }
2074                 }
2075                 return $feedUrls;
2076         }
2077
2078         function is_html($content) {
2079                 return preg_match("/<html|DOCTYPE html/i", substr($content, 0, 100)) !== 0;
2080         }
2081
2082         function url_is_html($url, $login = false, $pass = false) {
2083                 return is_html(fetch_file_contents($url, false, $login, $pass));
2084         }
2085
2086         function build_url($parts) {
2087                 return $parts['scheme'] . "://" . $parts['host'] . $parts['path'];
2088         }
2089
2090         function cleanup_url_path($path) {
2091                 $path = str_replace("/./", "/", $path);
2092                 $path = str_replace("//", "/", $path);
2093
2094                 return $path;
2095         }
2096
2097         /**
2098          * Converts a (possibly) relative URL to a absolute one.
2099          *
2100          * @param string $url     Base URL (i.e. from where the document is)
2101          * @param string $rel_url Possibly relative URL in the document
2102          *
2103          * @return string Absolute URL
2104          */
2105         function rewrite_relative_url($url, $rel_url) {
2106                 if (strpos($rel_url, "://") !== false) {
2107                         return $rel_url;
2108                 } else if (strpos($rel_url, "//") === 0) {
2109                         # protocol-relative URL (rare but they exist)
2110                         return $rel_url;
2111                 } else if (preg_match("/^[a-z]+:/i", $rel_url)) {
2112                         # magnet:, feed:, etc
2113                         return $rel_url;
2114                 } else if (strpos($rel_url, "/") === 0) {
2115                         $parts = parse_url($url);
2116                         $parts['path'] = $rel_url;
2117                         $parts['path'] = cleanup_url_path($parts['path']);
2118
2119                         return build_url($parts);
2120
2121                 } else {
2122                         $parts = parse_url($url);
2123                         if (!isset($parts['path'])) {
2124                                 $parts['path'] = '/';
2125                         }
2126                         $dir = $parts['path'];
2127                         if (substr($dir, -1) !== '/') {
2128                                 $dir = dirname($parts['path']);
2129                                 $dir !== '/' && $dir .= '/';
2130                         }
2131                         $parts['path'] = $dir . $rel_url;
2132                         $parts['path'] = cleanup_url_path($parts['path']);
2133
2134                         return build_url($parts);
2135                 }
2136         }
2137
2138         function cleanup_tags($days = 14, $limit = 1000) {
2139
2140                 if (DB_TYPE == "pgsql") {
2141                         $interval_query = "date_updated < NOW() - INTERVAL '$days days'";
2142                 } else if (DB_TYPE == "mysql") {
2143                         $interval_query = "date_updated < DATE_SUB(NOW(), INTERVAL $days DAY)";
2144                 }
2145
2146                 $tags_deleted = 0;
2147
2148                 while ($limit > 0) {
2149                         $limit_part = 500;
2150
2151                         $query = "SELECT ttrss_tags.id AS id
2152                                         FROM ttrss_tags, ttrss_user_entries, ttrss_entries
2153                                         WHERE post_int_id = int_id AND $interval_query AND
2154                                         ref_id = ttrss_entries.id AND tag_cache != '' LIMIT $limit_part";
2155
2156                         $result = db_query($query);
2157
2158                         $ids = array();
2159
2160                         while ($line = db_fetch_assoc($result)) {
2161                                 array_push($ids, $line['id']);
2162                         }
2163
2164                         if (count($ids) > 0) {
2165                                 $ids = join(",", $ids);
2166
2167                                 $tmp_result = db_query("DELETE FROM ttrss_tags WHERE id IN ($ids)");
2168                                 $tags_deleted += db_affected_rows($tmp_result);
2169                         } else {
2170                                 break;
2171                         }
2172
2173                         $limit -= $limit_part;
2174                 }
2175
2176                 return $tags_deleted;
2177         }
2178
2179         function print_user_stylesheet() {
2180                 $value = get_pref('USER_STYLESHEET');
2181
2182                 if ($value) {
2183                         print "<style type=\"text/css\">";
2184                         print str_replace("<br/>", "\n", $value);
2185                         print "</style>";
2186                 }
2187
2188         }
2189
2190         function filter_to_sql($filter, $owner_uid) {
2191                 $query = array();
2192
2193                 if (DB_TYPE == "pgsql")
2194                         $reg_qpart = "~";
2195                 else
2196                         $reg_qpart = "REGEXP";
2197
2198                 foreach ($filter["rules"] AS $rule) {
2199                         $rule['reg_exp'] = str_replace('/', '\/', $rule["reg_exp"]);
2200                         $regexp_valid = preg_match('/' . $rule['reg_exp'] . '/',
2201                                         $rule['reg_exp']) !== FALSE;
2202
2203                         if ($regexp_valid) {
2204
2205                                 $rule['reg_exp'] = db_escape_string($rule['reg_exp']);
2206
2207                                 switch ($rule["type"]) {
2208                                         case "title":
2209                                                 $qpart = "LOWER(ttrss_entries.title) $reg_qpart LOWER('".
2210                                                         $rule['reg_exp'] . "')";
2211                                                 break;
2212                                         case "content":
2213                                                 $qpart = "LOWER(ttrss_entries.content) $reg_qpart LOWER('".
2214                                                         $rule['reg_exp'] . "')";
2215                                                 break;
2216                                         case "both":
2217                                                 $qpart = "LOWER(ttrss_entries.title) $reg_qpart LOWER('".
2218                                                         $rule['reg_exp'] . "') OR LOWER(" .
2219                                                         "ttrss_entries.content) $reg_qpart LOWER('" . $rule['reg_exp'] . "')";
2220                                                 break;
2221                                         case "tag":
2222                                                 $qpart = "LOWER(ttrss_user_entries.tag_cache) $reg_qpart LOWER('".
2223                                                         $rule['reg_exp'] . "')";
2224                                                 break;
2225                                         case "link":
2226                                                 $qpart = "LOWER(ttrss_entries.link) $reg_qpart LOWER('".
2227                                                         $rule['reg_exp'] . "')";
2228                                                 break;
2229                                         case "author":
2230                                                 $qpart = "LOWER(ttrss_entries.author) $reg_qpart LOWER('".
2231                                                         $rule['reg_exp'] . "')";
2232                                                 break;
2233                                 }
2234
2235                                 if (isset($rule['inverse'])) $qpart = "NOT ($qpart)";
2236
2237                                 if (isset($rule["feed_id"]) && $rule["feed_id"] > 0) {
2238                                         $qpart .= " AND feed_id = " . db_escape_string($rule["feed_id"]);
2239                                 }
2240
2241                                 if (isset($rule["cat_id"])) {
2242
2243                                         if ($rule["cat_id"] > 0) {
2244                                                 $children = Feeds::getChildCategories($rule["cat_id"], $owner_uid);
2245                                                 array_push($children, $rule["cat_id"]);
2246
2247                                                 $children = join(",", $children);
2248
2249                                                 $cat_qpart = "cat_id IN ($children)";
2250                                         } else {
2251                                                 $cat_qpart = "cat_id IS NULL";
2252                                         }
2253
2254                                         $qpart .= " AND $cat_qpart";
2255                                 }
2256
2257                                 $qpart .= " AND feed_id IS NOT NULL";
2258
2259                                 array_push($query, "($qpart)");
2260
2261                         }
2262                 }
2263
2264                 if (count($query) > 0) {
2265                         $fullquery = "(" . join($filter["match_any_rule"] ? "OR" : "AND", $query) . ")";
2266                 } else {
2267                         $fullquery = "(false)";
2268                 }
2269
2270                 if ($filter['inverse']) $fullquery = "(NOT $fullquery)";
2271
2272                 return $fullquery;
2273         }
2274
2275         if (!function_exists('gzdecode')) {
2276                 function gzdecode($string) { // no support for 2nd argument
2277                         return file_get_contents('compress.zlib://data:who/cares;base64,'.
2278                                 base64_encode($string));
2279                 }
2280         }
2281
2282         function get_random_bytes($length) {
2283                 if (function_exists('openssl_random_pseudo_bytes')) {
2284                         return openssl_random_pseudo_bytes($length);
2285                 } else {
2286                         $output = "";
2287
2288                         for ($i = 0; $i < $length; $i++)
2289                                 $output .= chr(mt_rand(0, 255));
2290
2291                         return $output;
2292                 }
2293         }
2294
2295         function read_stdin() {
2296                 $fp = fopen("php://stdin", "r");
2297
2298                 if ($fp) {
2299                         $line = trim(fgets($fp));
2300                         fclose($fp);
2301                         return $line;
2302                 }
2303
2304                 return null;
2305         }
2306
2307         function implements_interface($class, $interface) {
2308                 return in_array($interface, class_implements($class));
2309         }
2310
2311         function get_minified_js($files) {
2312                 require_once 'lib/jshrink/Minifier.php';
2313
2314                 $rv = '';
2315
2316                 foreach ($files as $js) {
2317                         if (!isset($_GET['debug'])) {
2318                                 $cached_file = CACHE_DIR . "/js/".basename($js).".js";
2319
2320                                 if (file_exists($cached_file) && is_readable($cached_file) && filemtime($cached_file) >= filemtime("js/$js.js")) {
2321
2322                                         list($header, $contents) = explode("\n", file_get_contents($cached_file), 2);
2323
2324                                         if ($header && $contents) {
2325                                                 list($htag, $hversion) = explode(":", $header);
2326
2327                                                 if ($htag == "tt-rss" && $hversion == VERSION) {
2328                                                         $rv .= $contents;
2329                                                         continue;
2330                                                 }
2331                                         }
2332                                 }
2333
2334                                 $minified = JShrink\Minifier::minify(file_get_contents("js/$js.js"));
2335                                 file_put_contents($cached_file, "tt-rss:" . VERSION . "\n" . $minified);
2336                                 $rv .= $minified;
2337
2338                         } else {
2339                                 $rv .= file_get_contents("js/$js.js"); // no cache in debug mode
2340                         }
2341                 }
2342
2343                 return $rv;
2344         }
2345
2346         function calculate_dep_timestamp() {
2347                 $files = array_merge(glob("js/*.js"), glob("css/*.css"));
2348
2349                 $max_ts = -1;
2350
2351                 foreach ($files as $file) {
2352                         if (filemtime($file) > $max_ts) $max_ts = filemtime($file);
2353                 }
2354
2355                 return $max_ts;
2356         }
2357
2358         function T_js_decl($s1, $s2) {
2359                 if ($s1 && $s2) {
2360                         $s1 = preg_replace("/\n/", "", $s1);
2361                         $s2 = preg_replace("/\n/", "", $s2);
2362
2363                         $s1 = preg_replace("/\"/", "\\\"", $s1);
2364                         $s2 = preg_replace("/\"/", "\\\"", $s2);
2365
2366                         return "T_messages[\"$s1\"] = \"$s2\";\n";
2367                 }
2368         }
2369
2370         function init_js_translations() {
2371
2372                 print 'var T_messages = new Object();
2373
2374                         function __(msg) {
2375                                 if (T_messages[msg]) {
2376                                         return T_messages[msg];
2377                                 } else {
2378                                         return msg;
2379                                 }
2380                         }
2381
2382                         function ngettext(msg1, msg2, n) {
2383                                 return __((parseInt(n) > 1) ? msg2 : msg1);
2384                         }';
2385
2386                 $l10n = _get_reader();
2387
2388                 for ($i = 0; $i < $l10n->total; $i++) {
2389                         $orig = $l10n->get_original_string($i);
2390                         if(strpos($orig, "\000") !== FALSE) { // Plural forms
2391                                 $key = explode(chr(0), $orig);
2392                                 print T_js_decl($key[0], _ngettext($key[0], $key[1], 1)); // Singular
2393                                 print T_js_decl($key[1], _ngettext($key[0], $key[1], 2)); // Plural
2394                         } else {
2395                                 $translation = __($orig);
2396                                 print T_js_decl($orig, $translation);
2397                         }
2398                 }
2399         }
2400
2401         function get_theme_path($theme) {
2402                 $check = "themes/$theme";
2403                 if (file_exists($check)) return $check;
2404
2405                 $check = "themes.local/$theme";
2406                 if (file_exists($check)) return $check;
2407         }
2408
2409         function theme_valid($theme) {
2410                 $bundled_themes = [ "default.php", "night.css", "compact.css" ];
2411
2412                 if (in_array($theme, $bundled_themes)) return true;
2413
2414                 $file = "themes/" . basename($theme);
2415
2416                 if (!file_exists($file)) $file = "themes.local/" . basename($theme);
2417
2418                 if (file_exists($file) && is_readable($file)) {
2419                         $fh = fopen($file, "r");
2420
2421                         if ($fh) {
2422                                 $header = fgets($fh);
2423                                 fclose($fh);
2424
2425                                 return strpos($header, "supports-version:" . VERSION_STATIC) !== FALSE;
2426                         }
2427                 }
2428
2429                 return false;
2430         }
2431
2432         /**
2433          * @SuppressWarnings(unused)
2434          */
2435         function error_json($code) {
2436                 require_once "errors.php";
2437
2438                 @$message = $ERRORS[$code];
2439
2440                 return json_encode(array("error" =>
2441                         array("code" => $code, "message" => $message)));
2442
2443         }
2444
2445         /*function abs_to_rel_path($dir) {
2446                 $tmp = str_replace(dirname(__DIR__), "", $dir);
2447
2448                 if (strlen($tmp) > 0 && substr($tmp, 0, 1) == "/") $tmp = substr($tmp, 1);
2449
2450                 return $tmp;
2451         }*/
2452
2453         function get_upload_error_message($code) {
2454
2455                 $errors = array(
2456                         0 => __('There is no error, the file uploaded with success'),
2457                         1 => __('The uploaded file exceeds the upload_max_filesize directive in php.ini'),
2458                         2 => __('The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form'),
2459                         3 => __('The uploaded file was only partially uploaded'),
2460                         4 => __('No file was uploaded'),
2461                         6 => __('Missing a temporary folder'),
2462                         7 => __('Failed to write file to disk.'),
2463                         8 => __('A PHP extension stopped the file upload.'),
2464                 );
2465
2466                 return $errors[$code];
2467         }
2468
2469         function base64_img($filename) {
2470                 if (file_exists($filename)) {
2471                         $ext = pathinfo($filename, PATHINFO_EXTENSION);
2472
2473                         return "data:image/$ext;base64," . base64_encode(file_get_contents($filename));
2474                 } else {
2475                         return "";
2476                 }
2477         }
2478