inc/confutils.php

   1 <?php
   2
   3 /**
   4  * Utilities for collecting data from config files
   5  *
   6  * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)
   7  * @author     Harry Fuecks <hfuecks@gmail.com>
   8  */
   9
  10 /*
  11  * line prefix used to negate single value config items
  12  * (scheme.conf & stopwords.conf), e.g.
  13  * !gopher
  14  */
  15
  16 use dokuwiki\Extension\AuthPlugin;
  17 use dokuwiki\Extension\Event;
  18
  19 const DOKU_CONF_NEGATION = '!';
  20
  21 /**
  22  * Returns the (known) extension and mimetype of a given filename
  23  *
  24  * If $knownonly is true (the default), then only known extensions
  25  * are returned.
  26  *
  27  * @author Andreas Gohr <andi@splitbrain.org>
  28  *
  29  * @param string $file file name
  30  * @param bool   $knownonly
  31  * @return array with extension, mimetype and if it should be downloaded
  32  */
  33 function mimetype($file, $knownonly = true)
  34 {
  35     $mtypes = getMimeTypes();     // known mimetypes
  36     $ext    = strrpos($file, '.');
  37     if ($ext === false) {
  38         return [false, false, false];
  39     }
  40     $ext = strtolower(substr($file, $ext + 1));
  41     if (!isset($mtypes[$ext])) {
  42         if ($knownonly) {
  43             return [false, false, false];
  44         } else {
  45             return [$ext, 'application/octet-stream', true];
  46         }
  47     }
  48     if ($mtypes[$ext][0] == '!') {
  49         return [$ext, substr($mtypes[$ext], 1), true];
  50     } else {
  51         return [$ext, $mtypes[$ext], false];
  52     }
  53 }
  54
  55 /**
  56  * returns a hash of mimetypes
  57  *
  58  * @author Andreas Gohr <andi@splitbrain.org>
  59  */
  60 function getMimeTypes()
  61 {
  62     static $mime = null;
  63     if (!$mime) {
  64         $mime = retrieveConfig('mime', 'confToHash');
  65         $mime = array_filter($mime);
  66     }
  67     return $mime;
  68 }
  69
  70 /**
  71  * returns a hash of acronyms
  72  *
  73  * @author Harry Fuecks <hfuecks@gmail.com>
  74  */
  75 function getAcronyms()
  76 {
  77     static $acronyms = null;
  78     if (!$acronyms) {
  79         $acronyms = retrieveConfig('acronyms', 'confToHash');
  80         $acronyms = array_filter($acronyms, 'strlen');
  81     }
  82     return $acronyms;
  83 }
  84
  85 /**
  86  * returns a hash of smileys
  87  *
  88  * @author Harry Fuecks <hfuecks@gmail.com>
  89  */
  90 function getSmileys()
  91 {
  92     static $smileys = null;
  93     if (!$smileys) {
  94         $smileys = retrieveConfig('smileys', 'confToHash');
  95         $smileys = array_filter($smileys, 'strlen');
  96     }
  97     return $smileys;
  98 }
  99
 100 /**
 101  * returns a hash of entities
 102  *
 103  * @author Harry Fuecks <hfuecks@gmail.com>
 104  */
 105 function getEntities()
 106 {
 107     static $entities = null;
 108     if (!$entities) {
 109         $entities = retrieveConfig('entities', 'confToHash');
 110         $entities = array_filter($entities, 'strlen');
 111     }
 112     return $entities;
 113 }
 114
 115 /**
 116  * returns a hash of interwikilinks
 117  *
 118  * @author Harry Fuecks <hfuecks@gmail.com>
 119  */
 120 function getInterwiki()
 121 {
 122     static $wikis = null;
 123     if (!$wikis) {
 124         $wikis = retrieveConfig('interwiki', 'confToHash', [true]);
 125         $wikis = array_filter($wikis, 'strlen');
 126
 127         //add sepecial case 'this'
 128         $wikis['this'] = DOKU_URL . '{NAME}';
 129     }
 130     return $wikis;
 131 }
 132
 133 /**
 134  * Returns the jquery script URLs for the versions defined in lib/scripts/jquery/versions
 135  *
 136  * @trigger CONFUTIL_CDN_SELECT
 137  * @return array
 138  */
 139 function getCdnUrls()
 140 {
 141     global $conf;
 142
 143     // load version info
 144     $versions = [];
 145     $lines = file(DOKU_INC . 'lib/scripts/jquery/versions');
 146     foreach ($lines as $line) {
 147         $line = trim(preg_replace('/#.*$/', '', $line));
 148         if ($line === '') continue;
 149         [$key, $val] = sexplode('=', $line, 2, '');
 150         $key = trim($key);
 151         $val = trim($val);
 152         $versions[$key] = $val;
 153     }
 154
 155     $src = [];
 156     $data = ['versions' => $versions, 'src' => &$src];
 157     $event = new Event('CONFUTIL_CDN_SELECT', $data);
 158     if ($event->advise_before()) {
 159         if (!$conf['jquerycdn']) {
 160             $jqmod = md5(implode('-', $versions));
 161             $src[] = DOKU_BASE . 'lib/exe/jquery.php' . '?tseed=' . $jqmod;
 162         } elseif ($conf['jquerycdn'] == 'jquery') {
 163             $src[] = sprintf('https://code.jquery.com/jquery-%s.min.js', $versions['JQ_VERSION']);
 164             $src[] = sprintf('https://code.jquery.com/ui/%s/jquery-ui.min.js', $versions['JQUI_VERSION']);
 165         } elseif ($conf['jquerycdn'] == 'cdnjs') {
 166             $src[] = sprintf(
 167                 'https://cdnjs.cloudflare.com/ajax/libs/jquery/%s/jquery.min.js',
 168                 $versions['JQ_VERSION']
 169             );
 170             $src[] = sprintf(
 171                 'https://cdnjs.cloudflare.com/ajax/libs/jqueryui/%s/jquery-ui.min.js',
 172                 $versions['JQUI_VERSION']
 173             );
 174         }
 175     }
 176     $event->advise_after();
 177
 178     return $src;
 179 }
 180
 181 /**
 182  * returns array of wordblock patterns
 183  *
 184  */
 185 function getWordblocks()
 186 {
 187     static $wordblocks = null;
 188     if (!$wordblocks) {
 189         $wordblocks = retrieveConfig('wordblock', 'file', null, 'array_merge_with_removal');
 190     }
 191     return $wordblocks;
 192 }
 193
 194 /**
 195  * Gets the list of configured schemes
 196  *
 197  * @return array the schemes
 198  */
 199 function getSchemes()
 200 {
 201     static $schemes = null;
 202     if (!$schemes) {
 203         $schemes = retrieveConfig('scheme', 'file', null, 'array_merge_with_removal');
 204         $schemes = array_map('trim', $schemes);
 205         $schemes = preg_replace('/^#.*/', '', $schemes);
 206         $schemes = array_filter($schemes);
 207     }
 208     return $schemes;
 209 }
 210
 211 /**
 212  * Builds a hash from an array of lines
 213  *
 214  * If $lower is set to true all hash keys are converted to
 215  * lower case.
 216  *
 217  * @author Harry Fuecks <hfuecks@gmail.com>
 218  * @author Andreas Gohr <andi@splitbrain.org>
 219  * @author Gina Haeussge <gina@foosel.net>
 220  *
 221  * @param array $lines
 222  * @param bool $lower
 223  *
 224  * @return array
 225  */
 226 function linesToHash($lines, $lower = false)
 227 {
 228     $conf = [];
 229     // remove BOM
 230     if (isset($lines[0]) && str_starts_with($lines[0], pack('CCC', 0xef, 0xbb, 0xbf)))
 231         $lines[0] = substr($lines[0], 3);
 232     foreach ($lines as $line) {
 233         //ignore comments (except escaped ones)
 234         $line = preg_replace('/(?<![&\\\\])#.*$/', '', $line);
 235         $line = str_replace('\\#', '#', $line);
 236         $line = trim($line);
 237         if ($line === '') continue;
 238         $line = preg_split('/\s+/', $line, 2);
 239         $line = array_pad($line, 2, '');
 240         // Build the associative array
 241         if ($lower) {
 242             $conf[strtolower($line[0])] = $line[1];
 243         } else {
 244             $conf[$line[0]] = $line[1];
 245         }
 246     }
 247
 248     return $conf;
 249 }
 250
 251 /**
 252  * Builds a hash from a configfile
 253  *
 254  * If $lower is set to true all hash keys are converted to
 255  * lower case.
 256  *
 257  * @author Harry Fuecks <hfuecks@gmail.com>
 258  * @author Andreas Gohr <andi@splitbrain.org>
 259  * @author Gina Haeussge <gina@foosel.net>
 260  *
 261  * @param string $file
 262  * @param bool $lower
 263  *
 264  * @return array
 265  */
 266 function confToHash($file, $lower = false)
 267 {
 268     $conf = [];
 269     $lines = @file($file);
 270     if (!$lines) return $conf;
 271
 272     return linesToHash($lines, $lower);
 273 }
 274
 275 /**
 276  * Read a json config file into an array
 277  *
 278  * @param string $file
 279  * @return array
 280  * @throws JsonException
 281  */
 282 function jsonToArray($file)
 283 {
 284     $json = file_get_contents($file);
 285
 286     $conf = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
 287
 288     if ($conf === null) {
 289         return [];
 290     }
 291
 292     return $conf;
 293 }
 294
 295 /**
 296  * Retrieve the requested configuration information
 297  *
 298  * @author Chris Smith <chris@jalakai.co.uk>
 299  *
 300  * @param  string   $type     the configuration settings to be read, must correspond to a key/array in $config_cascade
 301  * @param  callback $fn       the function used to process the configuration file into an array
 302  * @param  array    $params   optional additional params to pass to the callback
 303  * @param  callback $combine  the function used to combine arrays of values read from different configuration files;
 304  *                            the function takes two parameters,
 305  *                               $combined - the already read & merged configuration values
 306  *                               $new - array of config values from the config cascade file being currently processed
 307  *                            and returns an array of the merged configuration values.
 308  * @return array    configuration values
 309  */
 310 function retrieveConfig($type, $fn, $params = null, $combine = 'array_merge')
 311 {
 312     global $config_cascade;
 313
 314     if (!is_array($params)) $params = [];
 315
 316     $combined = [];
 317     if (!is_array($config_cascade[$type])) trigger_error('Missing config cascade for "' . $type . '"', E_USER_WARNING);
 318     foreach (['default', 'local', 'protected'] as $config_group) {
 319         if (empty($config_cascade[$type][$config_group])) continue;
 320         foreach ($config_cascade[$type][$config_group] as $file) {
 321             if (file_exists($file)) {
 322                 $config = call_user_func_array($fn, array_merge([$file], $params));
 323                 $combined = $combine($combined, $config);
 324             }
 325         }
 326     }
 327
 328     return $combined;
 329 }
 330
 331 /**
 332  * Include the requested configuration information
 333  *
 334  * @author Chris Smith <chris@jalakai.co.uk>
 335  *
 336  * @param  string   $type     the configuration settings to be read, must correspond to a key/array in $config_cascade
 337  * @return array              list of files, default before local before protected
 338  */
 339 function getConfigFiles($type)
 340 {
 341     global $config_cascade;
 342     $files = [];
 343
 344     if (!is_array($config_cascade[$type])) trigger_error('Missing config cascade for "' . $type . '"', E_USER_WARNING);
 345     foreach (['default', 'local', 'protected'] as $config_group) {
 346         if (empty($config_cascade[$type][$config_group])) continue;
 347         $files = array_merge($files, $config_cascade[$type][$config_group]);
 348     }
 349
 350     return $files;
 351 }
 352
 353 /**
 354  * check if the given action was disabled in config
 355  *
 356  * @author Andreas Gohr <andi@splitbrain.org>
 357  * @param string $action
 358  * @returns boolean true if enabled, false if disabled
 359  */
 360 function actionOK($action)
 361 {
 362     static $disabled = null;
 363     if (is_null($disabled) || defined('SIMPLE_TEST')) {
 364         global $conf;
 365         /** @var AuthPlugin $auth */
 366         global $auth;
 367
 368         // prepare disabled actions array and handle legacy options
 369         $disabled = explode(',', $conf['disableactions']);
 370         $disabled = array_map('trim', $disabled);
 371         if (
 372             (isset($conf['openregister']) && !$conf['openregister']) || !$auth instanceof AuthPlugin
 373             || !$auth->canDo('addUser')
 374         ) {
 375             $disabled[] = 'register';
 376         }
 377         if (
 378             (isset($conf['resendpasswd']) && !$conf['resendpasswd']) || !$auth instanceof AuthPlugin
 379             || !$auth->canDo('modPass')
 380         ) {
 381             $disabled[] = 'resendpwd';
 382         }
 383         if ((isset($conf['subscribers']) && !$conf['subscribers']) || !$auth instanceof AuthPlugin) {
 384             $disabled[] = 'subscribe';
 385         }
 386         if (!$auth instanceof AuthPlugin || !$auth->canDo('Profile')) {
 387             $disabled[] = 'profile';
 388         }
 389         if (!$auth instanceof AuthPlugin || !$auth->canDo('delUser')) {
 390             $disabled[] = 'profile_delete';
 391         }
 392         if (!$auth instanceof AuthPlugin) {
 393             $disabled[] = 'login';
 394         }
 395         if (!$auth instanceof AuthPlugin || !$auth->canDo('logout')) {
 396             $disabled[] = 'logout';
 397         }
 398         $disabled = array_unique($disabled);
 399     }
 400
 401     return !in_array($action, $disabled);
 402 }
 403
 404 /**
 405  * check if headings should be used as link text for the specified link type
 406  *
 407  * @author Chris Smith <chris@jalakai.co.uk>
 408  *
 409  * @param   string  $linktype   'content'|'navigation', content applies to links in wiki text
 410  *                                                      navigation applies to all other links
 411  * @return  boolean             true if headings should be used for $linktype, false otherwise
 412  */
 413 function useHeading($linktype)
 414 {
 415     static $useHeading = null;
 416     if (defined('DOKU_UNITTEST')) $useHeading = null; // don't cache during unit tests
 417
 418     if (is_null($useHeading)) {
 419         global $conf;
 420
 421         if (!empty($conf['useheading'])) {
 422             switch ($conf['useheading']) {
 423                 case 'content':
 424                     $useHeading['content'] = true;
 425                     break;
 426
 427                 case 'navigation':
 428                     $useHeading['navigation'] = true;
 429                     break;
 430                 default:
 431                     $useHeading['content'] = true;
 432                     $useHeading['navigation'] = true;
 433             }
 434         } else {
 435             $useHeading = [];
 436         }
 437     }
 438
 439     return (!empty($useHeading[$linktype]));
 440 }
 441
 442 /**
 443  * obscure config data so information isn't plain text
 444  *
 445  * @param string       $str     data to be encoded
 446  * @param string       $code    encoding method, values: plain, base64, uuencode.
 447  * @return string               the encoded value
 448  */
 449 function conf_encodeString($str, $code)
 450 {
 451     switch ($code) {
 452         case 'base64':
 453             return '<b>' . base64_encode($str);
 454         case 'uuencode':
 455             return '<u>' . convert_uuencode($str);
 456         case 'plain':
 457         default:
 458             return $str;
 459     }
 460 }
 461 /**
 462  * return obscured data as plain text
 463  *
 464  * @param  string      $str   encoded data
 465  * @return string             plain text
 466  */
 467 function conf_decodeString($str)
 468 {
 469     switch (substr($str, 0, 3)) {
 470         case '<b>':
 471             return base64_decode(substr($str, 3));
 472         case '<u>':
 473             return convert_uudecode(substr($str, 3));
 474         default:  // not encoded (or unknown)
 475             return $str;
 476     }
 477 }
 478
 479 /**
 480  * array combination function to remove negated values (prefixed by !)
 481  *
 482  * @param  array $current
 483  * @param  array $new
 484  *
 485  * @return array the combined array, numeric keys reset
 486  */
 487 function array_merge_with_removal($current, $new)
 488 {
 489     foreach ($new as $val) {
 490         if (str_starts_with($val, DOKU_CONF_NEGATION)) {
 491             $idx = array_search(trim(substr($val, 1)), $current);
 492             if ($idx !== false) {
 493                 unset($current[$idx]);
 494             }
 495         } else {
 496             $current[] = trim($val);
 497         }
 498     }
 499
 500     return array_slice($current, 0);
 501 }
 502 //Setup VIM: ex: et ts=4 :