[ Index ]

PHP Cross Reference of DokuWiki

title

Body

[close]

/inc/ -> confutils.php (source)

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