inc/pageutils.php

   1 <?php
   2 /**
   3  * Utilities for handling pagenames
   4  *
   5  * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)
   6  * @author     Andreas Gohr <andi@splitbrain.org>
   7  * @todo       Combine similar functions like {wiki,media,meta}FN()
   8  */
   9
  10 use dokuwiki\ChangeLog\MediaChangeLog;
  11 use dokuwiki\ChangeLog\PageChangeLog;
  12
  13 /**
  14  * Fetch the an ID from request
  15  *
  16  * Uses either standard $_REQUEST variable or extracts it from
  17  * the full request URI when userewrite is set to 2
  18  *
  19  * For $param='id' $conf['start'] is returned if no id was found.
  20  * If the second parameter is true (default) the ID is cleaned.
  21  *
  22  * @author Andreas Gohr <andi@splitbrain.org>
  23  *
  24  * @param string $param  the $_REQUEST variable name, default 'id'
  25  * @param bool   $clean  if true, ID is cleaned
  26  * @return string
  27  */
  28 function getID($param='id',$clean=true){
  29     /** @var Input $INPUT */
  30     global $INPUT;
  31     global $conf;
  32     global $ACT;
  33
  34     $id = $INPUT->str($param);
  35
  36     //construct page id from request URI
  37     if(empty($id) && $conf['userewrite'] == 2){
  38         $request = $INPUT->server->str('REQUEST_URI');
  39         $script = '';
  40
  41         //get the script URL
  42         if($conf['basedir']){
  43             $relpath = '';
  44             if($param != 'id') {
  45                 $relpath = 'lib/exe/';
  46             }
  47             $script = $conf['basedir'] . $relpath .
  48                 \dokuwiki\Utf8\PhpString::basename($INPUT->server->str('SCRIPT_FILENAME'));
  49
  50         }elseif($INPUT->server->str('PATH_INFO')){
  51             $request = $INPUT->server->str('PATH_INFO');
  52         }elseif($INPUT->server->str('SCRIPT_NAME')){
  53             $script = $INPUT->server->str('SCRIPT_NAME');
  54         }elseif($INPUT->server->str('DOCUMENT_ROOT') && $INPUT->server->str('SCRIPT_FILENAME')){
  55             $script = preg_replace ('/^'.preg_quote($INPUT->server->str('DOCUMENT_ROOT'),'/').'/','',
  56                     $INPUT->server->str('SCRIPT_FILENAME'));
  57             $script = '/'.$script;
  58         }
  59
  60         //clean script and request (fixes a windows problem)
  61         $script  = preg_replace('/\/\/+/','/',$script);
  62         $request = preg_replace('/\/\/+/','/',$request);
  63
  64         //remove script URL and Querystring to gain the id
  65         if(preg_match('/^'.preg_quote($script,'/').'(.*)/',$request, $match)){
  66             $id = preg_replace ('/\?.*/','',$match[1]);
  67         }
  68         $id = urldecode($id);
  69         //strip leading slashes
  70         $id = preg_replace('!^/+!','',$id);
  71     }
  72
  73     // Namespace autolinking from URL
  74     if(substr($id,-1) == ':' || ($conf['useslash'] && substr($id,-1) == '/')){
  75         if(page_exists($id.$conf['start'])){
  76             // start page inside namespace
  77             $id = $id.$conf['start'];
  78         }elseif(page_exists($id.noNS(cleanID($id)))){
  79             // page named like the NS inside the NS
  80             $id = $id.noNS(cleanID($id));
  81         }elseif(page_exists($id)){
  82             // page like namespace exists
  83             $id = substr($id,0,-1);
  84         }else{
  85             // fall back to default
  86             $id = $id.$conf['start'];
  87         }
  88         if (isset($ACT) && $ACT === 'show') {
  89             $urlParameters = $_GET;
  90             if (isset($urlParameters['id'])) {
  91                 unset($urlParameters['id']);
  92             }
  93             send_redirect(wl($id, $urlParameters, true, '&'));
  94         }
  95     }
  96     if($clean) $id = cleanID($id);
  97     if($id === '' && $param=='id') $id = $conf['start'];
  98
  99     return $id;
 100 }
 101
 102 /**
 103  * Remove unwanted chars from ID
 104  *
 105  * Cleans a given ID to only use allowed characters. Accented characters are
 106  * converted to unaccented ones
 107  *
 108  * @author Andreas Gohr <andi@splitbrain.org>
 109  *
 110  * @param  string  $raw_id    The pageid to clean
 111  * @param  boolean $ascii     Force ASCII
 112  * @return string cleaned id
 113  */
 114 function cleanID($raw_id,$ascii=false){
 115     global $conf;
 116     static $sepcharpat = null;
 117
 118     global $cache_cleanid;
 119     $cache = & $cache_cleanid;
 120
 121     // check if it's already in the memory cache
 122     if (!$ascii && isset($cache[(string)$raw_id])) {
 123         return $cache[(string)$raw_id];
 124     }
 125
 126     $sepchar = $conf['sepchar'];
 127     if($sepcharpat == null) // build string only once to save clock cycles
 128         $sepcharpat = '#\\'.$sepchar.'+#';
 129
 130     $id = trim((string)$raw_id);
 131     $id = \dokuwiki\Utf8\PhpString::strtolower($id);
 132
 133     //alternative namespace seperator
 134     if($conf['useslash']){
 135         $id = strtr($id,';/','::');
 136     }else{
 137         $id = strtr($id,';/',':'.$sepchar);
 138     }
 139
 140     if($conf['deaccent'] == 2 || $ascii) $id = \dokuwiki\Utf8\Clean::romanize($id);
 141     if($conf['deaccent'] || $ascii) $id = \dokuwiki\Utf8\Clean::deaccent($id,-1);
 142
 143     //remove specials
 144     $id = \dokuwiki\Utf8\Clean::stripspecials($id,$sepchar,'\*');
 145
 146     if($ascii) $id = \dokuwiki\Utf8\Clean::strip($id);
 147
 148     //clean up
 149     $id = preg_replace($sepcharpat,$sepchar,$id);
 150     $id = preg_replace('#:+#',':',$id);
 151     $id = trim($id,':._-');
 152     $id = preg_replace('#:[:\._\-]+#',':',$id);
 153     $id = preg_replace('#[:\._\-]+:#',':',$id);
 154
 155     if (!$ascii) $cache[(string)$raw_id] = $id;
 156     return($id);
 157 }
 158
 159 /**
 160  * Return namespacepart of a wiki ID
 161  *
 162  * @author Andreas Gohr <andi@splitbrain.org>
 163  *
 164  * @param string $id
 165  * @return string|false the namespace part or false if the given ID has no namespace (root)
 166  */
 167 function getNS($id){
 168     $pos = strrpos((string)$id,':');
 169     if($pos!==false){
 170         return substr((string)$id,0,$pos);
 171     }
 172     return false;
 173 }
 174
 175 /**
 176  * Returns the ID without the namespace
 177  *
 178  * @author Andreas Gohr <andi@splitbrain.org>
 179  *
 180  * @param string $id
 181  * @return string
 182  */
 183 function noNS($id) {
 184     $pos = strrpos($id, ':');
 185     if ($pos!==false) {
 186         return substr($id, $pos+1);
 187     } else {
 188         return $id;
 189     }
 190 }
 191
 192 /**
 193  * Returns the current namespace
 194  *
 195  * @author Nathan Fritz <fritzn@crown.edu>
 196  *
 197  * @param string $id
 198  * @return string
 199  */
 200 function curNS($id) {
 201     return noNS(getNS($id));
 202 }
 203
 204 /**
 205  * Returns the ID without the namespace or current namespace for 'start' pages
 206  *
 207  * @author Nathan Fritz <fritzn@crown.edu>
 208  *
 209  * @param string $id
 210  * @return string
 211  */
 212 function noNSorNS($id) {
 213     global $conf;
 214
 215     $p = noNS($id);
 216     if ($p === $conf['start'] || $p === false || $p === '') {
 217         $p = curNS($id);
 218         if ($p === false || $p === '') {
 219             return $conf['start'];
 220         }
 221     }
 222     return $p;
 223 }
 224
 225 /**
 226  * Creates a XHTML valid linkid from a given headline title
 227  *
 228  * @param string  $title   The headline title
 229  * @param array|bool   $check   Existing IDs
 230  * @return string the title
 231  *
 232  * @author Andreas Gohr <andi@splitbrain.org>
 233  */
 234 function sectionID($title,&$check) {
 235     $title = str_replace(array(':','.'),'',cleanID($title));
 236     $new = ltrim($title,'0123456789_-');
 237     if(empty($new)){
 238         $title = 'section'.preg_replace('/[^0-9]+/','',$title); //keep numbers from headline
 239     }else{
 240         $title = $new;
 241     }
 242
 243     if(is_array($check)){
 244         $suffix=0;
 245         $candidateTitle = $title;
 246         while(in_array($candidateTitle, $check)){
 247           $candidateTitle = $title . ++$suffix;
 248         }
 249         $check []= $candidateTitle;
 250         return $candidateTitle;
 251     } else {
 252       return $title;
 253     }
 254 }
 255
 256 /**
 257  * Wiki page existence check
 258  *
 259  * parameters as for wikiFN
 260  *
 261  * @author Chris Smith <chris@jalakai.co.uk>
 262  *
 263  * @param string $id page id
 264  * @param string|int $rev empty or revision timestamp
 265  * @param bool $clean flag indicating that $id should be cleaned (see wikiFN as well)
 266  * @param bool $date_at
 267  * @return bool exists?
 268  */
 269 function page_exists($id, $rev = '', $clean = true, $date_at = false) {
 270     if ($rev !== '' && $date_at) {
 271         $pagelog = new PageChangeLog($id);
 272         $pagelog_rev = $pagelog->getLastRevisionAt($rev);
 273         if ($pagelog_rev !== false)
 274             $rev = $pagelog_rev;
 275     }
 276     return file_exists(wikiFN($id, $rev, $clean));
 277 }
 278
 279 /**
 280  * returns the full path to the datafile specified by ID and optional revision
 281  *
 282  * The filename is URL encoded to protect Unicode chars
 283  *
 284  * @param  $raw_id  string   id of wikipage
 285  * @param  $rev     int|string   page revision, empty string for current
 286  * @param  $clean   bool     flag indicating that $raw_id should be cleaned.  Only set to false
 287  *                           when $id is guaranteed to have been cleaned already.
 288  * @return string full path
 289  *
 290  * @author Andreas Gohr <andi@splitbrain.org>
 291  */
 292 function wikiFN($raw_id,$rev='',$clean=true){
 293     global $conf;
 294
 295     global $cache_wikifn;
 296     $cache = & $cache_wikifn;
 297
 298     $id = $raw_id;
 299
 300     if ($clean) $id = cleanID($id);
 301     $id = str_replace(':','/',$id);
 302
 303     if (isset($cache[$id]) && isset($cache[$id][$rev])) {
 304         return $cache[$id][$rev];
 305     }
 306
 307     if(empty($rev)){
 308         $fn = $conf['datadir'].'/'.utf8_encodeFN($id).'.txt';
 309     }else{
 310         $fn = $conf['olddir'].'/'.utf8_encodeFN($id).'.'.$rev.'.txt';
 311         if($conf['compression']){
 312             //test for extensions here, we want to read both compressions
 313             if (file_exists($fn . '.gz')){
 314                 $fn .= '.gz';
 315             }else if(file_exists($fn . '.bz2')){
 316                 $fn .= '.bz2';
 317             }else{
 318                 //file doesnt exist yet, so we take the configured extension
 319                 $fn .= '.' . $conf['compression'];
 320             }
 321         }
 322     }
 323
 324     if (!isset($cache[$id])) { $cache[$id] = array(); }
 325     $cache[$id][$rev] = $fn;
 326     return $fn;
 327 }
 328
 329 /**
 330  * Returns the full path to the file for locking the page while editing.
 331  *
 332  * @author Ben Coburn <btcoburn@silicodon.net>
 333  *
 334  * @param string $id page id
 335  * @return string full path
 336  */
 337 function wikiLockFN($id) {
 338     global $conf;
 339     return $conf['lockdir'].'/'.md5(cleanID($id)).'.lock';
 340 }
 341
 342
 343 /**
 344  * returns the full path to the meta file specified by ID and extension
 345  *
 346  * @author Steven Danz <steven-danz@kc.rr.com>
 347  *
 348  * @param string $id   page id
 349  * @param string $ext  file extension
 350  * @return string full path
 351  */
 352 function metaFN($id,$ext){
 353     global $conf;
 354     $id = cleanID($id);
 355     $id = str_replace(':','/',$id);
 356     $fn = $conf['metadir'].'/'.utf8_encodeFN($id).$ext;
 357     return $fn;
 358 }
 359
 360 /**
 361  * returns the full path to the media's meta file specified by ID and extension
 362  *
 363  * @author Kate Arzamastseva <pshns@ukr.net>
 364  *
 365  * @param string $id   media id
 366  * @param string $ext  extension of media
 367  * @return string
 368  */
 369 function mediaMetaFN($id,$ext){
 370     global $conf;
 371     $id = cleanID($id);
 372     $id = str_replace(':','/',$id);
 373     $fn = $conf['mediametadir'].'/'.utf8_encodeFN($id).$ext;
 374     return $fn;
 375 }
 376
 377 /**
 378  * returns an array of full paths to all metafiles of a given ID
 379  *
 380  * @author Esther Brunner <esther@kaffeehaus.ch>
 381  * @author Michael Hamann <michael@content-space.de>
 382  *
 383  * @param string $id page id
 384  * @return array
 385  */
 386 function metaFiles($id){
 387     $basename = metaFN($id, '');
 388     $files    = glob($basename.'.*', GLOB_MARK);
 389     // filter files like foo.bar.meta when $id == 'foo'
 390     return    $files ? preg_grep('/^'.preg_quote($basename, '/').'\.[^.\/]*$/u', $files) : array();
 391 }
 392
 393 /**
 394  * returns the full path to the mediafile specified by ID
 395  *
 396  * The filename is URL encoded to protect Unicode chars
 397  *
 398  * @author Andreas Gohr <andi@splitbrain.org>
 399  * @author Kate Arzamastseva <pshns@ukr.net>
 400  *
 401  * @param string     $id  media id
 402  * @param string|int $rev empty string or revision timestamp
 403  * @param bool $clean
 404  *
 405  * @return string full path
 406  */
 407 function mediaFN($id, $rev='', $clean=true){
 408     global $conf;
 409     if ($clean) $id = cleanID($id);
 410     $id = str_replace(':','/',$id);
 411     if(empty($rev)){
 412         $fn = $conf['mediadir'].'/'.utf8_encodeFN($id);
 413     }else{
 414         $ext = mimetype($id);
 415         $name = substr($id,0, -1*strlen($ext[0])-1);
 416         $fn = $conf['mediaolddir'].'/'.utf8_encodeFN($name .'.'.( (int) $rev ).'.'.$ext[0]);
 417     }
 418     return $fn;
 419 }
 420
 421 /**
 422  * Returns the full filepath to a localized file if local
 423  * version isn't found the english one is returned
 424  *
 425  * @param  string $id  The id of the local file
 426  * @param  string $ext The file extension (usually txt)
 427  * @return string full filepath to localized file
 428  *
 429  * @author Andreas Gohr <andi@splitbrain.org>
 430  */
 431 function localeFN($id,$ext='txt'){
 432     global $conf;
 433     $file = DOKU_CONF.'lang/'.$conf['lang'].'/'.$id.'.'.$ext;
 434     if(!file_exists($file)){
 435         $file = DOKU_INC.'inc/lang/'.$conf['lang'].'/'.$id.'.'.$ext;
 436         if(!file_exists($file)){
 437             //fall back to english
 438             $file = DOKU_INC.'inc/lang/en/'.$id.'.'.$ext;
 439         }
 440     }
 441     return $file;
 442 }
 443
 444 /**
 445  * Resolve relative paths in IDs
 446  *
 447  * Do not call directly use resolve_mediaid or resolve_pageid
 448  * instead
 449  *
 450  * Partyly based on a cleanPath function found at
 451  * http://php.net/manual/en/function.realpath.php#57016
 452  *
 453  * @author <bart at mediawave dot nl>
 454  *
 455  * @param string $ns     namespace which is context of id
 456  * @param string $id     relative id
 457  * @param bool   $clean  flag indicating that id should be cleaned
 458  * @return string
 459  */
 460 function resolve_id($ns,$id,$clean=true){
 461     global $conf;
 462
 463     // some pre cleaning for useslash:
 464     if($conf['useslash']) $id = str_replace('/',':',$id);
 465
 466     // if the id starts with a dot we need to handle the
 467     // relative stuff
 468     if($id && $id[0] == '.'){
 469         // normalize initial dots without a colon
 470         $id = preg_replace('/^((\.+:)*)(\.+)(?=[^:\.])/','\1\3:',$id);
 471         // prepend the current namespace
 472         $id = $ns.':'.$id;
 473
 474         // cleanup relatives
 475         $result = array();
 476         $pathA  = explode(':', $id);
 477         if (!$pathA[0]) $result[] = '';
 478         foreach ($pathA AS $key => $dir) {
 479             if ($dir == '..') {
 480                 if (end($result) == '..') {
 481                     $result[] = '..';
 482                 } elseif (!array_pop($result)) {
 483                     $result[] = '..';
 484                 }
 485             } elseif ($dir && $dir != '.') {
 486                 $result[] = $dir;
 487             }
 488         }
 489         if (!end($pathA)) $result[] = '';
 490         $id = implode(':', $result);
 491     }elseif($ns !== false && strpos($id,':') === false){
 492         //if link contains no namespace. add current namespace (if any)
 493         $id = $ns.':'.$id;
 494     }
 495
 496     if($clean) $id = cleanID($id);
 497     return $id;
 498 }
 499
 500 /**
 501  * Returns a full media id
 502  *
 503  * @author Andreas Gohr <andi@splitbrain.org>
 504  *
 505  * @param string $ns namespace which is context of id
 506  * @param string &$page (reference) relative media id, updated to resolved id
 507  * @param bool &$exists (reference) updated with existance of media
 508  * @param int|string $rev
 509  * @param bool $date_at
 510  */
 511 function resolve_mediaid($ns, &$page, &$exists, $rev = '', $date_at = false) {
 512     $page = resolve_id($ns, $page);
 513     if ($rev !== '' &&  $date_at) {
 514         $medialog = new MediaChangeLog($page);
 515         $medialog_rev = $medialog->getLastRevisionAt($rev);
 516         if ($medialog_rev !== false) {
 517             $rev = $medialog_rev;
 518         }
 519     }
 520
 521     $exists = file_exists(mediaFN($page, $rev));
 522 }
 523
 524 /**
 525  * Returns a full page id
 526  *
 527  * @author Andreas Gohr <andi@splitbrain.org>
 528  *
 529  * @param string $ns namespace which is context of id
 530  * @param string &$page (reference) relative page id, updated to resolved id
 531  * @param bool &$exists (reference) updated with existance of media
 532  * @param string $rev
 533  * @param bool $date_at
 534  */
 535 function resolve_pageid($ns, &$page, &$exists, $rev = '', $date_at = false) {
 536     global $conf;
 537     global $ID;
 538     $exists = false;
 539
 540     //empty address should point to current page
 541     if ($page === "") {
 542         $page = $ID;
 543     }
 544
 545     //keep hashlink if exists then clean both parts
 546     if (strpos($page,'#')) {
 547         list($page,$hash) = explode('#', $page, 2);
 548     } else {
 549         $hash = '';
 550     }
 551     $hash = cleanID($hash);
 552     $page = resolve_id($ns, $page, false); // resolve but don't clean, yet
 553
 554     // get filename (calls clean itself)
 555     if ($rev !== '' && $date_at) {
 556         $pagelog = new PageChangeLog($page);
 557         $pagelog_rev = $pagelog->getLastRevisionAt($rev);
 558         if ($pagelog_rev !== false)//something found
 559            $rev = $pagelog_rev;
 560     }
 561     $file = wikiFN($page,$rev);
 562
 563     // if ends with colon or slash we have a namespace link
 564     if (in_array(substr($page, -1), array(':', ';')) ||
 565         ($conf['useslash'] && substr($page,-1) == '/')
 566     ) {
 567         if (page_exists($page.$conf['start'], $rev, true, $date_at)) {
 568             // start page inside namespace
 569             $page = $page.$conf['start'];
 570             $exists = true;
 571         } elseif (page_exists($page.noNS(cleanID($page)), $rev, true, $date_at)) {
 572             // page named like the NS inside the NS
 573             $page = $page.noNS(cleanID($page));
 574             $exists = true;
 575         } elseif (page_exists($page, $rev, true, $date_at)) {
 576             // page like namespace exists
 577             $page = $page;
 578             $exists = true;
 579         } else {
 580             // fall back to default
 581             $page = $page.$conf['start'];
 582         }
 583     } else {
 584         //check alternative plural/nonplural form
 585         if (!file_exists($file)) {
 586             if ($conf['autoplural']) {
 587                 if (substr($page, -1) == 's') {
 588                     $try = substr($page, 0, -1);
 589                 } else {
 590                     $try = $page.'s';
 591                 }
 592                 if (page_exists($try, $rev, true, $date_at)) {
 593                     $page = $try;
 594                     $exists = true;
 595                 }
 596             }
 597         } else {
 598             $exists = true;
 599         }
 600     }
 601
 602     // now make sure we have a clean page
 603     $page = cleanID($page);
 604
 605     //add hash if any
 606     if (!empty($hash)) $page .= '#'.$hash;
 607 }
 608
 609 /**
 610  * Returns the name of a cachefile from given data
 611  *
 612  * The needed directory is created by this function!
 613  *
 614  * @author Andreas Gohr <andi@splitbrain.org>
 615  *
 616  * @param string $data  This data is used to create a unique md5 name
 617  * @param string $ext   This is appended to the filename if given
 618  * @return string       The filename of the cachefile
 619  */
 620 function getCacheName($data,$ext=''){
 621     global $conf;
 622     $md5  = md5($data);
 623     $file = $conf['cachedir'].'/'.$md5[0].'/'.$md5.$ext;
 624     io_makeFileDir($file);
 625     return $file;
 626 }
 627
 628 /**
 629  * Checks a pageid against $conf['hidepages']
 630  *
 631  * @author Andreas Gohr <gohr@cosmocode.de>
 632  *
 633  * @param string $id page id
 634  * @return bool
 635  */
 636 function isHiddenPage($id){
 637     $data = array(
 638         'id' => $id,
 639         'hidden' => false
 640     );
 641     \dokuwiki\Extension\Event::createAndTrigger('PAGEUTILS_ID_HIDEPAGE', $data, '_isHiddenPage');
 642     return $data['hidden'];
 643 }
 644
 645 /**
 646  * callback checks if page is hidden
 647  *
 648  * @param array $data event data    - see isHiddenPage()
 649  */
 650 function _isHiddenPage(&$data) {
 651     global $conf;
 652     global $ACT;
 653
 654     if ($data['hidden']) return;
 655     if(empty($conf['hidepages'])) return;
 656     if($ACT == 'admin') return;
 657
 658     if(preg_match('/'.$conf['hidepages'].'/ui',':'.$data['id'])){
 659         $data['hidden'] = true;
 660     }
 661 }
 662
 663 /**
 664  * Reverse of isHiddenPage
 665  *
 666  * @author Andreas Gohr <gohr@cosmocode.de>
 667  *
 668  * @param string $id page id
 669  * @return bool
 670  */
 671 function isVisiblePage($id){
 672     return !isHiddenPage($id);
 673 }
 674
 675 /**
 676  * Format an id for output to a user
 677  *
 678  * Namespaces are denoted by a trailing “:*”. The root namespace is
 679  * “*”. Output is escaped.
 680  *
 681  * @author Adrian Lang <lang@cosmocode.de>
 682  *
 683  * @param string $id page id
 684  * @return string
 685  */
 686 function prettyprint_id($id) {
 687     if (!$id || $id === ':') {
 688         return '*';
 689     }
 690     if ((substr($id, -1, 1) === ':')) {
 691         $id .= '*';
 692     }
 693     return hsc($id);
 694 }
 695
 696 /**
 697  * Encode a UTF-8 filename to use on any filesystem
 698  *
 699  * Uses the 'fnencode' option to determine encoding
 700  *
 701  * When the second parameter is true the string will
 702  * be encoded only if non ASCII characters are detected -
 703  * This makes it safe to run it multiple times on the
 704  * same string (default is true)
 705  *
 706  * @author Andreas Gohr <andi@splitbrain.org>
 707  * @see    urlencode
 708  *
 709  * @param string $file file name
 710  * @param bool   $safe if true, only encoded when non ASCII characters detected
 711  * @return string
 712  */
 713 function utf8_encodeFN($file,$safe=true){
 714     global $conf;
 715     if($conf['fnencode'] == 'utf-8') return $file;
 716
 717     if($safe && preg_match('#^[a-zA-Z0-9/_\-\.%]+$#',$file)){
 718         return $file;
 719     }
 720
 721     if($conf['fnencode'] == 'safe'){
 722         return SafeFN::encode($file);
 723     }
 724
 725     $file = urlencode($file);
 726     $file = str_replace('%2F','/',$file);
 727     return $file;
 728 }
 729
 730 /**
 731  * Decode a filename back to UTF-8
 732  *
 733  * Uses the 'fnencode' option to determine encoding
 734  *
 735  * @author Andreas Gohr <andi@splitbrain.org>
 736  * @see    urldecode
 737  *
 738  * @param string $file file name
 739  * @return string
 740  */
 741 function utf8_decodeFN($file){
 742     global $conf;
 743     if($conf['fnencode'] == 'utf-8') return $file;
 744
 745     if($conf['fnencode'] == 'safe'){
 746         return SafeFN::decode($file);
 747     }
 748
 749     return urldecode($file);
 750 }
 751
 752 /**
 753  * Find a page in the current namespace (determined from $ID) or any
 754  * higher namespace that can be accessed by the current user,
 755  * this condition can be overriden by an optional parameter.
 756  *
 757  * Used for sidebars, but can be used other stuff as well
 758  *
 759  * @todo   add event hook
 760  *
 761  * @param  string $page the pagename you're looking for
 762  * @param bool $useacl only return pages readable by the current user, false to ignore ACLs
 763  * @return false|string the full page id of the found page, false if any
 764  */
 765 function page_findnearest($page, $useacl = true){
 766     if ((string) $page === '') return false;
 767     global $ID;
 768
 769     $ns = $ID;
 770     do {
 771         $ns = getNS($ns);
 772         $pageid = cleanID("$ns:$page");
 773         if(page_exists($pageid) && (!$useacl || auth_quickaclcheck($pageid) >= AUTH_READ)){
 774             return $pageid;
 775         }
 776     } while($ns !== false);
 777
 778     return false;
 779 }