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