]> CyberLeo.Net >> Repos - SourceForge/phpwiki.git/blob - lib/loadsave.php
ereg_replace --> preg_replace
[SourceForge/phpwiki.git] / lib / loadsave.php
1 <?php //-*-php-*-
2 // $Id$
3
4 /*
5  * Copyright 1999,2000,2001,2002,2004,2005,2006,2007 $ThePhpWikiProgrammingTeam
6  * Copyright 2008-2010 Marc-Etienne Vargenau, Alcatel-Lucent
7  *
8  * This file is part of PhpWiki.
9  *
10  * PhpWiki is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * PhpWiki is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License along
21  * with PhpWiki; if not, write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 require_once("lib/ziplib.php");
26 require_once("lib/Template.php");
27
28 /**
29  * ignore fatal errors during dump
30  */
31 function _dump_error_handler($error) {
32     if ($error->isFatal()) {
33         $error->errno = E_USER_WARNING;
34         return true;
35     }
36     return true;         // Ignore error
37     /*
38     if (preg_match('/Plugin/', $error->errstr))
39         return true;
40     */
41     // let the message come through: call the remaining handlers:
42     // return false;
43 }
44
45 function StartLoadDump(&$request, $title, $html = '')
46 {
47     // MockRequest is from the unit testsuite, a faked request. (may be cmd-line)
48     // We are silent on unittests.
49     if (isa($request,'MockRequest'))
50         return;
51     // FIXME: This is a hack. This really is the worst overall hack in phpwiki.
52     if ($html)
53         $html->pushContent('%BODY%');
54     $tmpl = Template('html', array('TITLE' => $title,
55                                    'HEADER' => $title,
56                                    'CONTENT' => $html ? $html : '%BODY%'));
57     echo preg_replace('/%BODY%.*/s', '', $tmpl->getExpansion($html));
58     $request->chunkOutput();
59
60     // set marker for sendPageChangeNotification()
61     $request->_deferredPageChangeNotification = array();
62 }
63
64 function EndLoadDump(&$request)
65 {
66     global $WikiTheme;
67
68     if (isa($request,'MockRequest'))
69         return;
70     $action = $request->getArg('action');
71     $label = '';
72     switch ($action) {
73     case 'zip':        $label = _("ZIP files of database"); break;
74     case 'dumpserial': $label = _("Dump to directory"); break;
75     case 'upload':     $label = _("Upload File"); break;
76     case 'loadfile':   $label = _("Load File"); break;
77     case 'upgrade':    $label = _("Upgrade"); break;
78     case 'dumphtml':
79     case 'ziphtml':    $label = _("Dump pages as XHTML"); break;
80     }
81     if ($label) $label = str_replace(" ","_",$label);
82     if ($action == 'browse') // loading virgin
83         $pagelink = WikiLink(HOME_PAGE);
84     else
85         $pagelink = WikiLink(new WikiPageName(_("PhpWikiAdministration"),false,$label));
86
87     // do deferred sendPageChangeNotification()
88     if (!empty($request->_deferredPageChangeNotification)) {
89         $pages = $all_emails = $all_users = array();
90         foreach ($request->_deferredPageChangeNotification as $p) {
91             list($pagename, $emails, $userids) = $p;
92             $pages[] = $pagename;
93             $all_emails = array_unique(array_merge($all_emails, $emails));
94             $all_users = array_unique(array_merge($all_users, $userids));
95         }
96         $editedby = sprintf(_("Edited by: %s"), $request->_user->getId());
97         $content = "Loaded the following pages:\n" . join("\n", $pages);
98         if (mail(join(',',$all_emails),"[".WIKI_NAME."] "._("LoadDump"),
99                  _("LoadDump")."\n".
100                  $editedby."\n\n".
101                  $content))
102             trigger_error(sprintf(_("PageChange Notification of %s sent to %s"),
103                                   join("\n",$pages), join(',',$all_users)), E_USER_NOTICE);
104         else
105             trigger_error(sprintf(_("PageChange Notification Error: Couldn't send %s to %s"),
106                                   join("\n",$pages), join(',',$all_users)), E_USER_WARNING);
107         unset($pages);
108         unset($all_emails);
109         unset($all_users);
110     }
111     unset($request->_deferredPageChangeNotification);
112
113     PrintXML(HTML::p(HTML::strong(_("Complete."))),
114              HTML::p(fmt("Return to %s", $pagelink)));
115     // Ugly hack to get valid XHTML code
116     if (isa($WikiTheme, 'WikiTheme_fusionforge')) {
117         echo "</div>\n";
118         echo "</div>\n";
119         echo "</article>\n";
120         echo "</div>\n";
121     } else if (isa($WikiTheme, 'WikiTheme_Sidebar')
122            or isa($WikiTheme, 'WikiTheme_MonoBook')) {
123         echo "</div>\n";
124         echo "</div>\n";
125         echo "</div>\n";
126         echo "</div>\n";
127     } else if (isa($WikiTheme, 'WikiTheme_wikilens')) {
128         echo "</div>\n";
129         echo "</td>\n";
130         echo "</tr>\n";
131         echo "</table>\n";
132     } else if (isa($WikiTheme, 'WikiTheme_blog')) {
133         echo "</div>\n";
134         echo "</div>\n";
135     } else if (isa($WikiTheme, 'WikiTheme_Crao')
136            or isa($WikiTheme, 'WikiTheme_Hawaiian')
137            or isa($WikiTheme, 'WikiTheme_MacOSX')
138            or isa($WikiTheme, 'WikiTheme_shamino_com')
139            or isa($WikiTheme, 'WikiTheme_smaller')) {
140         echo "</div>\n";
141     }
142     echo "</body></html>\n";
143 }
144
145 ////////////////////////////////////////////////////////////////
146 //
147 //  Functions for dumping.
148 //
149 ////////////////////////////////////////////////////////////////
150
151 /**
152  * For reference see:
153  * http://www.nacs.uci.edu/indiv/ehood/MIME/2045/rfc2045.html
154  * http://www.faqs.org/rfcs/rfc2045.html
155  * (RFC 1521 has been superceeded by RFC 2045 & others).
156  *
157  * Also see http://www.faqs.org/rfcs/rfc2822.html
158  */
159 function MailifyPage ($page, $nversions = 1)
160 {
161     $current = $page->getCurrentRevision(false);
162     $head = '';
163
164     if (STRICT_MAILABLE_PAGEDUMPS) {
165         $from = defined('SERVER_ADMIN') ? SERVER_ADMIN : 'foo@bar';
166         //This is for unix mailbox format: (not RFC (2)822)
167         // $head .= "From $from  " . CTime(time()) . "\r\n";
168         $head .= "Subject: " . rawurlencode($page->getName()) . "\r\n";
169         $head .= "From: $from (PhpWiki)\r\n";
170         // RFC 2822 requires only a Date: and originator (From:)
171         // field, however the obsolete standard RFC 822 also
172         // requires a destination field.
173         $head .= "To: $from (PhpWiki)\r\n";
174     }
175     $head .= "Date: " . Rfc2822DateTime($current->get('mtime')) . "\r\n";
176     $head .= sprintf("Mime-Version: 1.0 (Produced by PhpWiki %s)\r\n",
177                      PHPWIKI_VERSION);
178
179     // This should just be entered by hand (or by script?)
180     // in the actual pgsrc files, since only they should have
181     // RCS ids.
182     //$head .= "X-Rcs-Id: \$Id\$\r\n";
183
184     $iter = $page->getAllRevisions();
185     $parts = array();
186     while ($revision = $iter->next()) {
187         $parts[] = MimeifyPageRevision($page, $revision);
188         if ($nversions > 0 && count($parts) >= $nversions)
189             break;
190     }
191     if (count($parts) > 1)
192         return $head . MimeMultipart($parts);
193     assert($parts);
194     return $head . $parts[0];
195 }
196
197 /***
198  * Compute filename to used for storing contents of a wiki page.
199  *
200  * Basically we do a rawurlencode() which encodes everything except
201  * ASCII alphanumerics and '.', '-', and '_'.
202  *
203  * But we also want to encode leading dots to avoid filenames like
204  * '.', and '..'. (Also, there's no point in generating "hidden" file
205  * names, like '.foo'.)
206  *
207  * We have to apply a different "/" logic for dumpserial, htmldump and zipdump.
208  * dirs are allowed for zipdump and htmldump, not for dumpserial
209  *
210  *
211  * @param $pagename string Pagename.
212  * @return string Filename for page.
213  */
214 function FilenameForPage ($pagename, $action = false)
215 {
216     $enc = rawurlencode($pagename);
217     if (!$action) {
218         global $request;
219     $action = $request->getArg('action');
220     }
221     if ($action != 'dumpserial') { // zip, ziphtml, dumphtml
222     // For every %2F we will need to mkdir -p dirname($pagename)
223     $enc = preg_replace('/%2F/', '/', $enc);
224     }
225     $enc = preg_replace('/^\./', '%2E', $enc);
226     $enc = preg_replace('/%20/', ' ',   $enc);
227     $enc = preg_replace('/\.$/', '%2E', $enc);
228     return $enc;
229 }
230
231 /**
232  * The main() function which generates a zip archive of a PhpWiki.
233  *
234  * If $include_archive is false, only the current version of each page
235  * is included in the zip file; otherwise all archived versions are
236  * included as well.
237  */
238 function MakeWikiZip (&$request)
239 {
240     global $ErrorManager;
241     if ($request->getArg('include') == 'all') {
242         $zipname         = WIKI_NAME . _("FullDump") . date('Ymd-Hi') . '.zip';
243         $include_archive = true;
244     }
245     else {
246         $zipname         = WIKI_NAME . _("LatestSnapshot") . date('Ymd-Hi') . '.zip';
247         $include_archive = false;
248     }
249     $include_empty = false;
250     if ($request->getArg('include') == 'empty') {
251     $include_empty = true;
252     }
253
254     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
255
256     /* ignore fatals in plugins */
257     $ErrorManager->pushErrorHandler(new WikiFunctionCb('_dump_error_handler'));
258
259     $dbi =& $request->_dbi;
260     $thispage = $request->getArg('pagename'); // for "Return to ..."
261     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
262         $excludeList = explodePageList($exclude);
263     } else {
264         $excludeList = array();
265     }
266     if ($pages = $request->getArg('pages')) {  // which pagenames
267         if ($pages == '[]') // current page
268             $pages = $thispage;
269         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
270     } else {
271         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
272     }
273     $request_args = $request->args;
274     $timeout = (! $request->getArg('start_debug')) ? 30 : 240;
275
276     while ($page = $page_iter->next()) {
277     $request->args = $request_args; // some plugins might change them (esp. on POST)
278         longer_timeout($timeout);     // Reset watchdog
279
280         $current = $page->getCurrentRevision();
281         if ($current->getVersion() == 0)
282             continue;
283
284         $pagename = $page->getName();
285         $wpn = new WikiPageName($pagename);
286         if (!$wpn->isValid())
287             continue;
288         if (in_array($page->getName(), $excludeList)) {
289             continue;
290         }
291
292         $attrib = array('mtime'    => $current->get('mtime'),
293                         'is_ascii' => 1);
294         if ($page->get('locked'))
295             $attrib['write_protected'] = 1;
296
297         if ($include_archive)
298             $content = MailifyPage($page, 0);
299         else
300             $content = MailifyPage($page);
301
302         $zip->addRegularFile( FilenameForPage($pagename),
303                               $content, $attrib);
304     }
305     $zip->finish();
306
307     $ErrorManager->popErrorHandler();
308 }
309
310 function DumpToDir (&$request)
311 {
312     $directory = $request->getArg('directory');
313     if (empty($directory))
314         $directory = DEFAULT_DUMP_DIR; // See lib/plugin/WikiForm.php:87
315     if (empty($directory))
316         $request->finish(_("You must specify a directory to dump to"));
317
318     // see if we can access the directory the user wants us to use
319     if (! file_exists($directory)) {
320         if (! mkdir($directory, 0755))
321             $request->finish(fmt("Cannot create directory '%s'", $directory));
322         else
323             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
324                                 $directory));
325     } else {
326         $html = HTML::p(fmt("Using directory '%s'", $directory));
327     }
328
329     StartLoadDump($request, _("Dumping Pages"), $html);
330
331     $dbi =& $request->_dbi;
332     $thispage = $request->getArg('pagename'); // for "Return to ..."
333     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
334         $excludeList = explodePageList($exclude);
335     } else {
336         $excludeList = array();
337     }
338     $include_empty = false;
339     if ($request->getArg('include') == 'empty') {
340     $include_empty = true;
341     }
342     if ($pages = $request->getArg('pages')) {  // which pagenames
343         if ($pages == '[]') // current page
344             $pages = $thispage;
345         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
346     } else {
347         $page_iter = $dbi->getAllPages($include_empty,false,false,$excludeList);
348     }
349
350     $request_args = $request->args;
351     $timeout = (! $request->getArg('start_debug')) ? 30 : 240;
352
353     while ($page = $page_iter->next()) {
354     $request->args = $request_args; // some plugins might change them (esp. on POST)
355         longer_timeout($timeout);     // Reset watchdog
356
357         $pagename = $page->getName();
358         if (!isa($request,'MockRequest')) {
359             PrintXML(HTML::br(), $pagename, ' ... ');
360             flush();
361         }
362
363         if (in_array($pagename, $excludeList)) {
364             if (!isa($request, 'MockRequest')) {
365                 PrintXML(_("Skipped."));
366                 flush();
367             }
368             continue;
369         }
370         $filename = FilenameForPage($pagename);
371         $msg = HTML();
372         if($page->getName() != $filename) {
373             $msg->pushContent(HTML::small(fmt("saved as %s", $filename)),
374                               " ... ");
375         }
376
377         if ($request->getArg('include') == 'all')
378             $data = MailifyPage($page, 0);
379         else
380             $data = MailifyPage($page);
381
382         if ( !($fd = fopen($directory."/".$filename, "wb")) ) {
383             $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
384                                                "$directory/$filename")));
385             $request->finish($msg);
386         }
387
388         $num = fwrite($fd, $data, strlen($data));
389         $msg->pushContent(HTML::small(fmt("%s bytes written", $num)));
390         if (!isa($request, 'MockRequest')) {
391             PrintXML($msg);
392             flush();
393         }
394         assert($num == strlen($data));
395         fclose($fd);
396     }
397
398     EndLoadDump($request);
399 }
400
401 function _copyMsg($page, $smallmsg) {
402     if (!isa($GLOBALS['request'], 'MockRequest')) {
403         if ($page) $msg = HTML(HTML::br(), HTML($page), HTML::small($smallmsg));
404         else $msg = HTML::small($smallmsg);
405         PrintXML($msg);
406         flush();
407     }
408 }
409
410 function mkdir_p($pathname, $permission = 0777) {
411     $arr = explode("/", $pathname);
412     if (empty($arr)) {
413     return mkdir($pathname, $permission);
414     }
415     $s = array_shift($arr);
416     $ok = TRUE;
417     foreach ($arr as $p) {
418     $curr = "$s/$p";
419     if (!is_dir($curr))
420         $ok = mkdir($curr, $permission);
421     $s = $curr;
422     if (!$ok) return FALSE;
423     }
424     return TRUE;
425 }
426
427 /**
428  * Dump all pages as XHTML to a directory, as pagename.html.
429  * Copies all used css files to the directory, all used images to a
430  * "images" subdirectory, and all used buttons to a "images/buttons" subdirectory.
431  * The webserver must have write permissions to these directories.
432  *   chown httpd HTML_DUMP_DIR; chmod u+rwx HTML_DUMP_DIR
433  * should be enough.
434  *
435  * @param string directory (optional) path to dump to. Default: HTML_DUMP_DIR
436  * @param string pages     (optional) Comma-seperated of glob-style pagenames to dump.
437  *                                    Also array of pagenames allowed.
438  * @param string exclude   (optional) Comma-seperated of glob-style pagenames to exclude
439  */
440 function DumpHtmlToDir (&$request)
441 {
442     global $WikiTheme;
443     $directory = $request->getArg('directory');
444     if (empty($directory))
445         $directory = HTML_DUMP_DIR; // See lib/plugin/WikiForm.php:87
446     if (empty($directory))
447         $request->finish(_("You must specify a directory to dump to"));
448
449     // See if we can access the directory the user wants us to use
450     if (! file_exists($directory)) {
451         if (! mkdir($directory, 0755))
452             $request->finish(fmt("Cannot create directory '%s'", $directory));
453         else
454             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
455                                 $directory));
456     } else {
457         $html = HTML::p(fmt("Using directory '%s'", $directory));
458     }
459     StartLoadDump($request, _("Dumping Pages"), $html);
460     $thispage = $request->getArg('pagename'); // for "Return to ..."
461
462     $dbi =& $request->_dbi;
463     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
464         $excludeList = explodePageList($exclude);
465     } else {
466         $excludeList = array('DebugAuthInfo', 'DebugGroupInfo', 'AuthInfo');
467     }
468     if ($pages = $request->getArg('pages')) {  // which pagenames
469         if ($pages == '[]') // current page
470             $pages = $thispage;
471         $page_iter = new WikiDB_Array_generic_iter(explodePageList($pages));
472     // not at admin page: dump only the current page
473     } elseif ($thispage != _("PhpWikiAdministration")) {
474         $page_iter = new WikiDB_Array_generic_iter(array($thispage));
475     } else {
476         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
477     }
478
479     $WikiTheme->DUMP_MODE = 'HTML';
480     _DumpHtmlToDir($directory, $page_iter, $request->getArg('exclude'));
481     $WikiTheme->DUMP_MODE = false;
482
483     $request->setArg('pagename',$thispage); // Template::_basepage fix
484     EndLoadDump($request);
485 }
486
487 /* Known problem: any plugins or other code which echo()s text will
488  * lead to a corrupted html zip file which may produce the following
489  * errors upon unzipping:
490  *
491  * warning [wikihtml.zip]:  2401 extra bytes at beginning or within zipfile
492  * file #58:  bad zipfile offset (local header sig):  177561
493  *  (attempting to re-compensate)
494  *
495  * However, the actual wiki page data should be unaffected.
496  */
497 function MakeWikiZipHtml (&$request)
498 {
499     global $WikiTheme;
500     if ($request->getArg('zipname')) {
501         $zipname = basename($request->getArg('zipname'));
502         if (!preg_match("/\.zip$/i", $zipname))
503             $zipname .= ".zip";
504         $request->setArg('zipname', false);
505     } else {
506         $zipname = "wikihtml.zip";
507     }
508     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
509     $dbi =& $request->_dbi;
510     $thispage = $request->getArg('pagename'); // for "Return to ..."
511     if ($pages = $request->getArg('pages')) {  // which pagenames
512         if ($pages == '[]') // current page
513             $pages = $thispage;
514         $page_iter = new WikiDB_Array_generic_iter(explodePageList($pages));
515     } else {
516         $page_iter = $dbi->getAllPages(false,false,false,$request->getArg('exclude'));
517     }
518
519     $WikiTheme->DUMP_MODE = 'ZIPHTML';
520     _DumpHtmlToDir($zip, $page_iter, $request->getArg('exclude'));
521     $WikiTheme->DUMP_MODE = false;
522 }
523
524 /*
525  * Internal html dumper. Used for dumphtml, ziphtml and pdf
526  */
527 function _DumpHtmlToDir ($target, $page_iter, $exclude = false)
528 {
529     global $WikiTheme, $request, $ErrorManager;
530     $silent = true; $zip = false; $directory = false;
531     if ($WikiTheme->DUMP_MODE == 'HTML') {
532         $directory = $target;
533         $silent = false;
534     } elseif ($WikiTheme->DUMP_MODE == 'PDFHTML') {
535         $directory = $target;
536     } elseif (is_object($target)) { // $WikiTheme->DUMP_MODE == 'ZIPHTML'
537         $zip = $target;
538     }
539
540     $request->_TemplatesProcessed = array();
541     if ($exclude) {   // exclude which pagenames
542         $excludeList = explodePageList($exclude);
543     } else {
544         $excludeList = array('DebugAuthInfo', 'DebugGroupInfo', 'AuthInfo');
545     }
546     $WikiTheme->VALID_LINKS = array();
547     if ($request->getArg('format')) { // pagelist
548         $page_iter_sav = $page_iter;
549         foreach ($page_iter_sav->asArray() as $handle) {
550             $WikiTheme->VALID_LINKS[] = is_string($handle) ? $handle : $handle->getName();
551         }
552         $page_iter_sav->reset();
553     }
554
555     if (defined('HTML_DUMP_SUFFIX')) {
556         $WikiTheme->HTML_DUMP_SUFFIX = HTML_DUMP_SUFFIX;
557     }
558     if (isset($WikiTheme->_MoreAttr['body'])) {
559         $_bodyAttr = $WikiTheme->_MoreAttr['body'];
560         unset($WikiTheme->_MoreAttr['body']);
561     }
562
563     $ErrorManager->pushErrorHandler(new WikiFunctionCb('_dump_error_handler'));
564
565     // check if the dumped file will be accessible from outside
566     $doc_root = $request->get("DOCUMENT_ROOT");
567     if ($WikiTheme->DUMP_MODE == 'HTML') {
568         $ldir = NormalizeLocalFileName($directory);
569         $wikiroot = NormalizeLocalFileName('');
570         if (string_starts_with($ldir, $doc_root)) {
571             $link_prefix = substr($directory, strlen($doc_root))."/";
572         } elseif (string_starts_with($ldir, $wikiroot)) {
573             $link_prefix = NormalizeWebFileName(substr($directory, strlen($wikiroot)))."/";
574         } else {
575             $prefix = '';
576             if (isWindows()) {
577                 $prefix = '/'; // . substr($doc_root,0,2); // add drive where apache is installed
578             }
579             $link_prefix = "file://".$prefix.$directory."/";
580         }
581     } else {
582         $link_prefix = "";
583     }
584
585     $request_args = $request->args;
586     $timeout = (! $request->getArg('start_debug')) ? 60 : 240;
587     if ($directory) {
588         if (isWindows())
589             $directory = str_replace("\\", "/", $directory); // no Win95 support.
590         if (!is_dir("$directory/images"))
591             mkdir("$directory/images");
592     }
593     $already = array();
594     $outfiles = array();
595     $already_images = array();
596
597     while ($page = $page_iter->next()) {
598         if (is_string($page)) {
599             $pagename = $page;
600             $page = $request->_dbi->getPage($pagename);
601         } else {
602             $pagename = $page->getName();
603         }
604         if (empty($firstpage)) $firstpage = $pagename;
605         if (array_key_exists($pagename, $already))
606             continue;
607         $already[$pagename] = 1;
608         $current = $page->getCurrentRevision();
609         //if ($current->getVersion() == 0)
610         //    continue;
611
612         $request->args = $request_args; // some plugins might change them (esp. on POST)
613         longer_timeout($timeout);     // Reset watchdog
614
615         if ($zip) {
616             $attrib = array('mtime'    => $current->get('mtime'),
617                             'is_ascii' => 1);
618             if ($page->get('locked'))
619                 $attrib['write_protected'] = 1;
620         } elseif (!$silent) {
621             if (!isa($request,'MockRequest')) {
622                 PrintXML(HTML::br(), $pagename, ' ... ');
623                 flush();
624             }
625         }
626         if (in_array($pagename, $excludeList)) {
627             if (!$silent and !isa($request,'MockRequest')) {
628                 PrintXML(_("Skipped."));
629                 flush();
630             }
631             continue;
632         }
633         $relative_base = '';
634         if ($WikiTheme->DUMP_MODE == 'PDFHTML')
635             $request->setArg('action', 'pdf');   // to omit cache headers
636         $request->setArg('pagename', $pagename); // Template::_basepage fix
637         $filename = FilenameForPage($pagename) . $WikiTheme->HTML_DUMP_SUFFIX;
638         $args = array('revision'      => $current,
639                       'CONTENT'       => $current->getTransformedContent(),
640                       'relative_base' => $relative_base);
641         // For every %2F will need to mkdir -p dirname($pagename)
642         if (preg_match("/(%2F|\/)/", $filename)) {
643             // mkdir -p and set relative base for subdir pages
644             $filename = preg_replace("/%2F/", "/", $filename);
645             $count = substr_count($filename, "/");
646             $dirname = dirname($filename);
647             if ($directory)
648                 mkdir_p($directory."/".$dirname);
649             // Fails with "XX / YY", "XX" is created, "XX / YY" cannot be written
650             // if (isWindows()) // interesting Windows bug: cannot mkdir "bla "
651             // Since dumps needs to be copied, we have to disallow this for all platforms.
652             $filename = preg_replace("/ \//", "/", $filename);
653             $relative_base = "../";
654             while ($count > 1) {
655                 $relative_base .= "../";
656                 $count--;
657             }
658             $args['relative_base'] = $relative_base;
659         }
660         $msg = HTML();
661
662         $DUMP_MODE = $WikiTheme->DUMP_MODE;
663         $data = GeneratePageasXML(new Template('browse', $request, $args),
664                      $pagename, $current, $args);
665         $WikiTheme->DUMP_MODE = $DUMP_MODE;
666
667         if (preg_match_all("/<img .*?src=\"(\/.+?)\"/", $data, $m)) {
668             // fix to local relative path for uploaded images, so that pdf will work
669             foreach ($m[1] as $img_file) {
670                 $base = basename($img_file);
671                 $data = str_replace('src="'.$img_file.'"','src="images/'.$base.'"', $data);
672                 if (array_key_exists($img_file, $already_images))
673                     continue;
674                 $already_images[$img_file] = 1;
675                 // resolve src from webdata to file
676                 $src = $doc_root . $img_file;
677                 if (file_exists($src) and $base) {
678                     if ($directory) {
679                         $target = "$directory/images/$base";
680                         if (copy($src, $target)) {
681                             if (!$silent)
682                                 _copyMsg($img_file, fmt("... copied to %s", $target));
683                         } else {
684                             if (!$silent)
685                                 _copyMsg($img_file, fmt("... not copied to %s", $target));
686                         }
687                     } else {
688                         $target = "images/$base";
689                         $zip->addSrcFile($target, $src);
690                     }
691                 }
692             }
693         }
694
695     if ($directory) {
696         $outfile = $directory."/".$filename;
697         if ( !($fd = fopen($outfile, "wb")) ) {
698         $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
699                            $outfile)));
700         $request->finish($msg);
701         }
702         $len = strlen($data);
703         $num = fwrite($fd, $data, $len);
704         if ($pagename != $filename) {
705         $link = LinkURL($link_prefix.$filename, $filename);
706         $msg->pushContent(HTML::small(_("saved as "), $link, " ... "));
707         }
708         $msg->pushContent(HTML::small(fmt("%s bytes written", $num), "\n"));
709         if (!$silent) {
710         if (!isa($request, 'MockRequest')) {
711             PrintXML($msg);
712         }
713         flush();
714         $request->chunkOutput();
715         }
716         assert($num == $len);
717         fclose($fd);
718         $outfiles[] = $outfile;
719     } else {
720         $zip->addRegularFile($filename, $data, $attrib);
721     }
722
723         if (USECACHE) {
724             $request->_dbi->_cache->invalidate_cache($pagename);
725             unset ($request->_dbi->_cache->_pagedata_cache);
726             unset ($request->_dbi->_cache->_versiondata_cache);
727             unset ($request->_dbi->_cache->_glv_cache);
728         }
729         unset ($request->_dbi->_cache->_backend->_page_data);
730
731         unset($msg);
732         unset($current->_transformedContent);
733         unset($current);
734     if (!empty($template)) {
735         unset($template->_request);
736         unset($template);
737     }
738         unset($data);
739     }
740     $page_iter->free();
741
742     $attrib = false; //array('is_ascii' => 0);
743     if (!empty($WikiTheme->dumped_images) and is_array($WikiTheme->dumped_images)) {
744         // @mkdir("$directory/images");
745         foreach ($WikiTheme->dumped_images as $img_file) {
746         if (array_key_exists($img_file, $already_images))
747             continue;
748         $already_images[$img_file] = 1;
749             if ($img_file
750                 and ($from = $WikiTheme->_findFile($img_file, true))
751                 and basename($from))
752             {
753         if ($directory) {
754             $target = "$directory/images/".basename($from);
755             if ($silent)
756             copy($WikiTheme->_path . $from, $target);
757             else {
758             if (copy($WikiTheme->_path . $from, $target)) {
759                 _copyMsg($from, fmt("... copied to %s", $target));
760             } else {
761                 _copyMsg($from, fmt("... not copied to %s", $target));
762             }
763             }
764         } else {
765             $target = "images/".basename($from);
766             $zip->addSrcFile($target, $WikiTheme->_path . $from);
767         }
768             } elseif (!$silent) {
769                 _copyMsg($from, _("... not found"));
770             }
771         }
772     }
773
774     if (!empty($WikiTheme->dumped_buttons)
775          and is_array($WikiTheme->dumped_buttons))
776     {
777         // Buttons also
778         if ($directory && !is_dir("$directory/images/buttons"))
779             mkdir("$directory/images/buttons");
780         foreach ($WikiTheme->dumped_buttons as $text => $img_file) {
781             if (array_key_exists($img_file, $already_images))
782                 continue;
783         $already_images[$img_file] = 1;
784             if ($img_file
785                 and ($from = $WikiTheme->_findFile($img_file, true))
786                 and basename($from))
787             {
788         if ($directory) {
789             $target = "$directory/images/buttons/".basename($from);
790             if ($silent)
791             copy($WikiTheme->_path . $from, $target);
792             else {
793                 if (copy($WikiTheme->_path . $from, $target)) {
794                     _copyMsg($from, fmt("... copied to %s", $target));
795                 } else {
796                     _copyMsg($from, fmt("... not copied to %s", $target));
797                 }
798             }
799         } else {
800             $target = "images/buttons/".basename($from);
801             $zip->addSrcFile($target, $WikiTheme->_path . $from);
802         }
803             } elseif (!$silent) {
804                 _copyMsg($from, _("... not found"));
805             }
806         }
807     }
808     if (!empty($WikiTheme->dumped_css) and is_array($WikiTheme->dumped_css)) {
809         foreach ($WikiTheme->dumped_css as $css_file) {
810             if (array_key_exists($css_file, $already_images))
811                 continue;
812         $already_images[$css_file] = 1;
813             if ($css_file
814                 and ($from = $WikiTheme->_findFile(basename($css_file), true))
815                 and basename($from))
816             {
817         // TODO: fix @import url(main.css);
818         if ($directory) {
819             $target = "$directory/" . basename($css_file);
820             if ($silent)
821             copy($WikiTheme->_path . $from, $target);
822             else {
823             if (copy($WikiTheme->_path . $from, $target)) {
824                 _copyMsg($from, fmt("... copied to %s", $target));
825             } else {
826                 _copyMsg($from, fmt("... not copied to %s", $target));
827             }
828             }
829         } else {
830             //$attrib = array('is_ascii' => 0);
831             $target = basename($css_file);
832             $zip->addSrcFile($target, $WikiTheme->_path . $from);
833         }
834             } elseif (!$silent) {
835                 _copyMsg($from, _("... not found"));
836             }
837         }
838     }
839
840     if ($zip)
841     $zip->finish();
842
843     if ($WikiTheme->DUMP_MODE == 'PDFHTML') {
844     if (USE_EXTERNAL_HTML2PDF and $outfiles) {
845         $cmd = EXTERNAL_HTML2PDF_PAGELIST.' "'.join('" "', $outfiles).'"';
846         $filename = FilenameForPage($firstpage);
847         if (DEBUG) {
848         $tmpfile = $directory . "/createpdf.bat";
849         $fp = fopen($tmpfile, "wb");
850         fwrite($fp, $cmd . " > $filename.pdf");
851         fclose($fp);
852         }
853         if (!headers_sent()) {
854         Header('Content-Type: application/pdf');
855         passthru($cmd);
856         }
857         else {
858         $tmpdir = getUploadFilePath();
859         $s = passthru($cmd . " > $tmpdir/$filename.pdf");
860         $errormsg = "<br />\nGenerated <a href=\"".getUploadDataPath()."$filename.pdf\">Upload:$filename.pdf</a>\n";
861         $errormsg .= $s;
862         echo $errormsg;
863         }
864         if (!DEBUG) {
865         foreach($outfiles as $f) unlink($f);
866         }
867     }
868     if (!empty($errormsg)) {
869         $request->discardOutput();
870         $GLOBALS['ErrorManager']->_postponed_errors = array();
871     }
872     }
873
874     $ErrorManager->popErrorHandler();
875
876     $WikiTheme->HTML_DUMP_SUFFIX = '';
877     $WikiTheme->DUMP_MODE = false;
878     $WikiTheme->_MoreAttr['body'] = isset($_bodyAttr) ? $_bodyAttr : '';
879 }
880
881
882 ////////////////////////////////////////////////////////////////
883 //
884 //  Functions for restoring.
885 //
886 ////////////////////////////////////////////////////////////////
887
888 function SavePage (&$request, &$pageinfo, $source, $filename)
889 {
890     static $overwite_all = false;
891     $pagedata    = $pageinfo['pagedata'];    // Page level meta-data.
892     $versiondata = $pageinfo['versiondata']; // Revision level meta-data.
893
894     if (empty($pageinfo['pagename'])) {
895         PrintXML(HTML::p(HTML::strong(_("Empty pagename!"))));
896         return;
897     }
898
899     if (empty($versiondata['author_id']))
900         $versiondata['author_id'] = $versiondata['author'];
901
902     // remove invalid backend specific chars. utf8 issues mostly
903     $pagename_check = new WikiPagename($pageinfo['pagename']);
904     if (!$pagename_check->isValid()) {
905         PrintXML(HTML::p(HTML::strong(sprintf(_("'%s': Bad page name"), $pageinfo['pagename']))));
906         return;
907     }
908     $pagename = $pagename_check->getName();
909     $content  = $pageinfo['content'];
910
911     if ($pagename == _("InterWikiMap"))
912         $content = _tryinsertInterWikiMap($content);
913
914     $dbi =& $request->_dbi;
915     $page = $dbi->getPage($pagename);
916
917     // Try to merge if updated pgsrc contents are different. This
918     // whole thing is hackish
919     //
920     // TODO: try merge unless:
921     // if (current contents = default contents && pgsrc_version >=
922     // pgsrc_version) then just upgrade this pgsrc
923     $needs_merge = false;
924     $merging = false;
925     $overwrite = false;
926
927     if ($request->getArg('merge')) {
928         $merging = true;
929     }
930     else if ($request->getArg('overwrite')) {
931         $overwrite = true;
932     }
933
934     $current = $page->getCurrentRevision();
935     $skip = false;
936     $edit = $request->getArg('edit');
937     if ($merging) {
938         if (isset($edit['keep_old'])) {
939             $merging = false;
940             $skip = true;
941         }
942         elseif (isset($edit['overwrite'])) {
943             $merging = false;
944             $overwrite = true;
945         }
946         elseif ( $current and (! $current->hasDefaultContents())
947          && ($current->getPackedContent() != $content) )
948         {
949             include_once('lib/editpage.php');
950             $request->setArg('pagename', $pagename);
951             $v = $current->getVersion();
952             $request->setArg('revision', $current->getVersion());
953             $p = new LoadFileConflictPageEditor($request);
954             $p->_content = $content;
955             $p->_currentVersion = $v - 1;
956             $p->editPage($saveFailed = true);
957             return; //early return
958        }
959     }
960     if (!$skip)
961       foreach ($pagedata as $key => $value) {
962         if (!empty($value))
963             $page->set($key, $value);
964       }
965
966     $mesg = HTML::p(array('style' => 'text-indent: 3em;'));
967     if ($source)
968         $mesg->pushContent(' ', fmt("from %s", $source));
969
970     if (!$current) {
971         //FIXME: This should not happen! (empty vdata, corrupt cache or db)
972         $current = $page->getCurrentRevision();
973     }
974     if ($current->getVersion() == 0) {
975         $versiondata['author'] = ADMIN_USER;
976         $versiondata['author_id'] = ADMIN_USER;
977         $mesg->pushContent(' - ', _("New page"));
978         $isnew = true;
979     }
980     else {
981         if ( (! $current->hasDefaultContents())
982              && ($current->getPackedContent() != $content) ) {
983             if ($overwrite) {
984                 $mesg->pushContent(' ',
985                                    fmt("has edit conflicts - overwriting anyway"));
986                 $skip = false;
987                 if (substr_count($source, 'pgsrc')) {
988                     $versiondata['author'] = ADMIN_USER;
989                     // but leave authorid as userid who loaded the file
990                 }
991             }
992             else {
993         if (isset($edit['keep_old'])) {
994             $mesg->pushContent(' ', fmt("keep old"));
995         } else {
996             $mesg->pushContent(' ', fmt("has edit conflicts - skipped"));
997             $needs_merge = true; // hackish, to display the buttons
998         }
999                 $skip = true;
1000             }
1001         }
1002         else if ($current->getPackedContent() == $content) {
1003             // The page content is the same, we don't need a new revision.
1004             $mesg->pushContent(' ',
1005                                fmt("content is identical to current version %d - no new revision created",
1006                                    $current->getVersion()));
1007             $skip = true;
1008         }
1009         $isnew = false;
1010     }
1011
1012     if (! $skip ) {
1013         // in case of failures print the culprit:
1014         if (!isa($request,'MockRequest')) {
1015             PrintXML(HTML::p(WikiLink($pagename))); flush();
1016         }
1017         $new = $page->save($content, WIKIDB_FORCE_CREATE, $versiondata);
1018         $dbi->touch();
1019         $mesg->pushContent(' ', fmt("- saved to database as version %d",
1020                                     $new->getVersion()));
1021     }
1022     if ($needs_merge) {
1023         $f = $source;
1024         // hackish, $source contains needed path+filename
1025         $f = str_replace(sprintf(_("MIME file %s"), ''), '', $f);
1026         $f = str_replace(sprintf(_("Serialized file %s"), ''), '', $f);
1027         $f = str_replace(sprintf(_("plain file %s"), ''), '', $f);
1028         //check if uploaded file? they pass just the content, but the file is gone
1029         if (@stat($f)) {
1030             global $WikiTheme;
1031             $meb = Button(array('action' => 'loadfile',
1032                                 'merge'=> true,
1033                                 'source'=> $f),
1034                           _("Merge Edit"),
1035                           _("PhpWikiAdministration"),
1036                           'wikiadmin');
1037             $owb = Button(array('action' => 'loadfile',
1038                                 'overwrite'=> true,
1039                                 'source'=> $f),
1040                           _("Restore Anyway"),
1041                           _("PhpWikiAdministration"),
1042                           'wikiunsafe');
1043             $mesg->pushContent(' ', $meb, " ", $owb);
1044             if (!$overwite_all) {
1045                 $args = $request->getArgs();
1046                 $args['overwrite'] = 1;
1047                 $owb = Button($args,
1048                               _("Overwrite All"),
1049                               _("PhpWikiAdministration"),
1050                               'wikiunsafe');
1051                 $mesg->pushContent(HTML::span(array('class' => 'hint'), $owb));
1052                 $overwite_all = true;
1053             }
1054         } else {
1055             $mesg->pushContent(HTML::em(_(" Sorry, cannot merge.")));
1056         }
1057     }
1058
1059     if (!isa($request,'MockRequest')) {
1060       if ($skip)
1061         PrintXML(HTML::p(HTML::em(WikiLink($pagename))), $mesg);
1062       else
1063         PrintXML($mesg);
1064       flush();
1065     }
1066 }
1067
1068 // action=revert (by diff)
1069 function RevertPage (&$request)
1070 {
1071     $mesg = HTML::div();
1072     $pagename = $request->getArg('pagename');
1073     $version = $request->getArg('version');
1074     $dbi =& $request->_dbi;
1075     $page = $dbi->getPage($pagename);
1076     if (!$version) {
1077         $request->redirect(WikiURL($page,
1078                            array('warningmsg' => _('Revert: missing required version argument'))));
1079         // noreturn
1080     }
1081     $current = $page->getCurrentRevision();
1082     $currversion = $current->getVersion();
1083     if ($currversion == 0) {
1084         $request->redirect(WikiURL($page,
1085                            array('errormsg' => _('No revert: no page content'))));
1086         // noreturn
1087     }
1088     if ($currversion == $version) {
1089         $request->redirect(WikiURL($page,
1090                            array('warningmsg' => _('No revert: same version page'))));
1091         // noreturn
1092     }
1093     if ($request->getArg('cancel')) {
1094         $request->redirect(WikiURL($page,
1095                            array('warningmsg' => _('Revert cancelled'))));
1096         // noreturn
1097     }
1098     if (!$request->getArg('verify')) {
1099         $mesg->pushContent(HTML::p(fmt("Are you sure to revert %s to version $version?", WikiLink($pagename))),
1100                            HTML::form(array('action' => $request->getPostURL(),
1101                                             'method' => 'post'),
1102                                       HiddenInputs($request->getArgs(), false, array('verify')),
1103                                       HiddenInputs(array('verify' => 1)),
1104                                       Button('submit:verify', _("Yes"), 'button'),
1105                                       HTML::Raw('&nbsp;'),
1106                                       Button('submit:cancel', _("Cancel"), 'button'))
1107                            );
1108         $rev = $page->getRevision($version);
1109         $html = HTML(HTML::fieldset($mesg), HTML::hr(), $rev->getTransformedContent());
1110         $template = Template('browse',
1111                              array('CONTENT' => $html));
1112         GeneratePage($template, $pagename, $rev);
1113         $request->checkValidators();
1114         flush();
1115         return;
1116     }
1117     $rev = $page->getRevision($version);
1118     $content = $rev->getPackedContent();
1119     $versiondata = $rev->_data;
1120     $versiondata['summary'] = sprintf(_("revert to version %d"), $version);
1121     $versiondata['mtime'] = time();
1122     $new = $page->save($content, $currversion + 1, $versiondata);
1123     $dbi->touch();
1124
1125     $mesg = HTML::span();
1126     $pagelink = WikiLink($pagename);
1127     $mesg->pushContent(fmt("Revert: %s", $pagelink),
1128                        fmt("- version %d saved to database as version %d",
1129                            $version, $new->getVersion()));
1130     // Force browse of current page version.
1131     $request->setArg('version', false);
1132     $template = Template('savepage', array());
1133     $template->replace('CONTENT', $new->getTransformedContent());
1134
1135     GeneratePage($template, $mesg, $new);
1136     flush();
1137 }
1138
1139 function _tryinsertInterWikiMap($content) {
1140     $goback = false;
1141     if (strpos($content, "<verbatim>")) {
1142         //$error_html = " The newly loaded pgsrc already contains a verbatim block.";
1143         $goback = true;
1144     }
1145     if (!$goback && !defined('INTERWIKI_MAP_FILE')) {
1146         $error_html = sprintf(" "._("%s: not defined"), "INTERWIKI_MAP_FILE");
1147         $goback = true;
1148     }
1149     $mapfile = FindFile(INTERWIKI_MAP_FILE,1);
1150     if (!$goback && !file_exists($mapfile)) {
1151         $error_html = sprintf(" "._("%s: file not found"), INTERWIKI_MAP_FILE);
1152         $goback = true;
1153     }
1154
1155     if (!empty($error_html))
1156         trigger_error(_("Default InterWiki map file not loaded.")
1157                       . $error_html, E_USER_NOTICE);
1158     if ($goback)
1159         return $content;
1160
1161     // if loading from virgin setup do echo, otherwise trigger_error E_USER_NOTICE
1162     if (!isa($GLOBALS['request'], 'MockRequest'))
1163         echo sprintf(_("Loading InterWikiMap from external file %s."), $mapfile),"<br />";
1164
1165     $fd = fopen ($mapfile, "rb");
1166     $data = fread ($fd, filesize($mapfile));
1167     fclose ($fd);
1168     $content = $content . "\n<verbatim>\n$data</verbatim>\n";
1169     return $content;
1170 }
1171
1172 function ParseSerializedPage($text, $default_pagename, $user)
1173 {
1174     if (!preg_match('/^a:\d+:{[si]:\d+/', $text))
1175         return false;
1176
1177     $pagehash = unserialize($text);
1178
1179     // Split up pagehash into four parts:
1180     //   pagename
1181     //   content
1182     //   page-level meta-data
1183     //   revision-level meta-data
1184
1185     if (!defined('FLAG_PAGE_LOCKED'))
1186         define('FLAG_PAGE_LOCKED', 1);
1187     if (!defined('FLAG_PAGE_EXTERNAL'))
1188         define('FLAG_PAGE_EXTERNAL', 1);
1189     $pageinfo = array('pagedata'    => array(),
1190                       'versiondata' => array());
1191
1192     $pagedata = &$pageinfo['pagedata'];
1193     $versiondata = &$pageinfo['versiondata'];
1194
1195     // Fill in defaults.
1196     if (empty($pagehash['pagename']))
1197         $pagehash['pagename'] = $default_pagename;
1198     if (empty($pagehash['author'])) {
1199         $pagehash['author'] = $user->getId();
1200     }
1201
1202     foreach ($pagehash as $key => $value) {
1203         switch($key) {
1204             case 'pagename':
1205             case 'version':
1206             case 'hits':
1207                 $pageinfo[$key] = $value;
1208                 break;
1209             case 'content':
1210                 $pageinfo[$key] = join("\n", $value);
1211                 break;
1212             case 'flags':
1213                 if (($value & FLAG_PAGE_LOCKED) != 0)
1214                     $pagedata['locked'] = 'yes';
1215                 if (($value & FLAG_PAGE_EXTERNAL) != 0)
1216                     $pagedata['external'] = 'yes';
1217                 break;
1218             case 'owner':
1219             case 'created':
1220                 $pagedata[$key] = $value;
1221                 break;
1222             case 'acl':
1223             case 'perm':
1224                 $pagedata['perm'] = ParseMimeifiedPerm($value);
1225                 break;
1226             case 'lastmodified':
1227                 $versiondata['mtime'] = $value;
1228                 break;
1229             case 'author':
1230             case 'author_id':
1231             case 'summary':
1232                 $versiondata[$key] = $value;
1233                 break;
1234         }
1235     }
1236     if (empty($pagehash['charset']))
1237         $pagehash['charset'] = 'utf-8';
1238     // compare to target charset
1239     if (strtolower($pagehash['charset']) != strtolower($GLOBALS['charset'])) {
1240         $pageinfo['content'] = charset_convert($params['charset'], $GLOBALS['charset'], $pageinfo['content']);
1241         $pageinfo['pagename'] = charset_convert($params['charset'], $GLOBALS['charset'], $pageinfo['pagename']);
1242     }
1243     return $pageinfo;
1244 }
1245
1246 function SortByPageVersion ($a, $b) {
1247     return $a['version'] - $b['version'];
1248 }
1249
1250 /**
1251  * Security alert! We should not allow to import config.ini into our wiki (or from a sister wiki?)
1252  * because the sql passwords are in plaintext there. And the webserver must be able to read it.
1253  * Detected by Santtu Jarvi.
1254  */
1255 function LoadFile (&$request, $filename, $text = false, $mtime = false)
1256 {
1257     if (preg_match("/config$/", dirname($filename))             // our or other config
1258         and preg_match("/config.*\.ini/", basename($filename))) // backups and other versions also
1259     {
1260         trigger_error(sprintf("Refused to load %s", $filename), E_USER_WARNING);
1261         return;
1262     }
1263     if (!is_string($text)) {
1264         // Read the file.
1265         $stat  = stat($filename);
1266         $mtime = $stat[9];
1267         $text  = implode("", file($filename));
1268     }
1269
1270     if (! $request->getArg('start_debug')) @set_time_limit(30); // Reset watchdog
1271     else @set_time_limit(240);
1272
1273     // FIXME: basename("filewithnoslashes") seems to return garbage sometimes.
1274     $basename = basename("/dummy/" . $filename);
1275
1276     if (!$mtime)
1277         $mtime = time();    // Last resort.
1278
1279     // DONE: check source - target charset for content and pagename
1280     // but only for pgsrc'ed content, not from the browser.
1281
1282     $default_pagename = rawurldecode($basename);
1283     if ( ($parts = ParseMimeifiedPages($text)) ) {
1284         if (count($parts) > 1)
1285             $overwrite = $request->getArg('overwrite');
1286         usort($parts, 'SortByPageVersion');
1287         foreach ($parts as $pageinfo) {
1288             // force overwrite
1289             if (count($parts) > 1)
1290                 $request->setArg('overwrite', 1);
1291             SavePage($request, $pageinfo, sprintf(_("MIME file %s"),
1292                                                   $filename), $basename);
1293     }
1294         if (count($parts) > 1)
1295             if ($overwrite)
1296                 $request->setArg('overwrite', $overwrite);
1297             else
1298             unset($request->_args['overwrite']);
1299     }
1300     else if ( ($pageinfo = ParseSerializedPage($text, $default_pagename,
1301                                                $request->getUser())) ) {
1302         SavePage($request, $pageinfo, sprintf(_("Serialized file %s"),
1303                                               $filename), $basename);
1304     }
1305     else {
1306         // plain old file
1307         $user = $request->getUser();
1308
1309         $file_charset = 'utf-8';
1310         // compare to target charset
1311         if ($file_charset != strtolower($GLOBALS['charset'])) {
1312             $text = charset_convert($file_charset, $GLOBALS['charset'], $text);
1313             $default_pagename = charset_convert($file_charset, $GLOBALS['charset'], $default_pagename);
1314         }
1315
1316         // Assume plain text file.
1317         $pageinfo = array('pagename' => $default_pagename,
1318                           'pagedata' => array(),
1319                           'versiondata'
1320                           => array('author' => $user->getId()),
1321                           'content'  => preg_replace('/[ \t\r]*\n/', "\n",
1322                                                      chop($text))
1323                           );
1324         SavePage($request, $pageinfo, sprintf(_("plain file %s"), $filename),
1325                  $basename);
1326     }
1327 }
1328
1329 function LoadZip (&$request, $zipfile, $files = false, $exclude = false) {
1330     $zip = new ZipReader($zipfile);
1331     $timeout = (! $request->getArg('start_debug')) ? 20 : 120;
1332     while (list ($fn, $data, $attrib) = $zip->readFile()) {
1333         // FIXME: basename("filewithnoslashes") seems to return
1334         // garbage sometimes.
1335         $fn = basename("/dummy/" . $fn);
1336         if ( ($files && !in_array($fn, $files))
1337              || ($exclude && in_array($fn, $exclude)) ) {
1338             PrintXML(HTML::p(WikiLink($fn)),
1339                      HTML::p(_("Skipping")));
1340             flush();
1341             continue;
1342         }
1343         longer_timeout($timeout);     // longer timeout per page
1344         LoadFile($request, $fn, $data, $attrib['mtime']);
1345     }
1346 }
1347
1348 function LoadDir (&$request, $dirname, $files = false, $exclude = false) {
1349     $fileset = new LimitedFileSet($dirname, $files, $exclude);
1350
1351     if (!$files and ($skiplist = $fileset->getSkippedFiles())) {
1352         PrintXML(HTML::p(HTML::strong(_("Skipping"))));
1353         $list = HTML::ul();
1354         foreach ($skiplist as $file)
1355             $list->pushContent(HTML::li(WikiLink($file)));
1356         PrintXML(HTML::p($list));
1357     }
1358
1359     // Defer HomePage loading until the end. If anything goes wrong
1360     // the pages can still be loaded again.
1361     $files = $fileset->getFiles();
1362     if (in_array(HOME_PAGE, $files)) {
1363         $files = array_diff($files, array(HOME_PAGE));
1364         $files[] = HOME_PAGE;
1365     }
1366     $timeout = (! $request->getArg('start_debug')) ? 20 : 120;
1367     foreach ($files as $file) {
1368         longer_timeout($timeout);     // longer timeout per page
1369         if (substr($file,-1,1) != '~')  // refuse to load backup files
1370             LoadFile($request, "$dirname/$file");
1371     }
1372 }
1373
1374 class LimitedFileSet extends FileSet {
1375     function LimitedFileSet($dirname, $_include, $exclude) {
1376         $this->_includefiles = $_include;
1377         $this->_exclude = $exclude;
1378         $this->_skiplist = array();
1379         parent::FileSet($dirname);
1380     }
1381
1382     function _filenameSelector($fn) {
1383         $incl = &$this->_includefiles;
1384         $excl = &$this->_exclude;
1385
1386         if ( ($incl && !in_array($fn, $incl))
1387              || ($excl && in_array($fn, $excl)) ) {
1388             $this->_skiplist[] = $fn;
1389             return false;
1390         } else {
1391             return true;
1392         }
1393     }
1394
1395     function getSkippedFiles () {
1396         return $this->_skiplist;
1397     }
1398 }
1399
1400
1401 function IsZipFile ($filename_or_fd)
1402 {
1403     // See if it looks like zip file
1404     if (is_string($filename_or_fd))
1405     {
1406         $fd    = fopen($filename_or_fd, "rb");
1407         $magic = fread($fd, 4);
1408         fclose($fd);
1409     }
1410     else
1411     {
1412         $fpos  = ftell($filename_or_fd);
1413         $magic = fread($filename_or_fd, 4);
1414         fseek($filename_or_fd, $fpos);
1415     }
1416
1417     return $magic == ZIP_LOCHEAD_MAGIC || $magic == ZIP_CENTHEAD_MAGIC;
1418 }
1419
1420
1421 function LoadAny (&$request, $file_or_dir, $files = false, $exclude = false)
1422 {
1423     // Try urlencoded filename for accented characters.
1424     if (!file_exists($file_or_dir)) {
1425         // Make sure there are slashes first to avoid confusing phps
1426         // with broken dirname or basename functions.
1427         // FIXME: windows uses \ and :
1428         if (is_integer(strpos($file_or_dir, "/"))) {
1429             $newfile = FindFile($file_or_dir, true);
1430             // Panic. urlencoded by the browser (e.g. San%20Diego => San Diego)
1431             if (!$newfile)
1432                 $file_or_dir = dirname($file_or_dir) . "/"
1433                     . rawurlencode(basename($file_or_dir));
1434         } else {
1435             // This is probably just a file.
1436             $file_or_dir = rawurlencode($file_or_dir);
1437         }
1438     }
1439
1440     $type = filetype($file_or_dir);
1441     if ($type == 'link') {
1442         // For symbolic links, use stat() to determine
1443         // the type of the underlying file.
1444         list(,,$mode) = stat($file_or_dir);
1445         $type = ($mode >> 12) & 017;
1446         if ($type == 010)
1447             $type = 'file';
1448         elseif ($type == 004)
1449             $type = 'dir';
1450     }
1451
1452     if (! $type) {
1453         $request->finish(fmt("Empty or not existing source. Unable to load: %s", $file_or_dir));
1454     }
1455     else if ($type == 'dir') {
1456         LoadDir($request, $file_or_dir, $files, $exclude);
1457     }
1458     else if ($type != 'file' && !preg_match('/^(http|ftp):/', $file_or_dir))
1459     {
1460         $request->finish(fmt("Bad file type: %s", $type));
1461     }
1462     else if (IsZipFile($file_or_dir)) {
1463         LoadZip($request, $file_or_dir, $files, $exclude);
1464     }
1465     else /* if (!$files || in_array(basename($file_or_dir), $files)) */
1466     {
1467         LoadFile($request, $file_or_dir);
1468     }
1469 }
1470
1471 function LoadFileOrDir (&$request)
1472 {
1473     $source = $request->getArg('source');
1474     $finder = new FileFinder;
1475     $source = $finder->slashifyPath($source);
1476     StartLoadDump($request,
1477         sprintf(_("Loading '%s'"), $source));
1478     LoadAny($request, $source);
1479     EndLoadDump($request);
1480 }
1481
1482 /**
1483  * HomePage was not found so first-time install is supposed to run.
1484  * - import all pgsrc pages.
1485  * - Todo: installer interface to edit config/config.ini settings
1486  * - Todo: ask for existing old index.php to convert to config/config.ini
1487  * - Todo: theme-specific pages:
1488  *   blog - HomePage, ADMIN_USER/Blogs
1489  */
1490 function SetupWiki (&$request)
1491 {
1492     global $GenericPages, $LANG;
1493
1494     //FIXME: This is a hack (err, "interim solution")
1495     // This is a bogo-bogo-login:  Login without
1496     // saving login information in session state.
1497     // This avoids logging in the unsuspecting
1498     // visitor as ADMIN_USER
1499     //
1500     // This really needs to be cleaned up...
1501     // (I'm working on it.)
1502     $real_user = $request->_user;
1503     if (ENABLE_USER_NEW)
1504         $request->_user = new _BogoUser(ADMIN_USER);
1505
1506     else
1507         $request->_user = new WikiUser($request, ADMIN_USER, WIKIAUTH_BOGO);
1508
1509     StartLoadDump($request, _("Loading up virgin wiki"));
1510
1511     $pgsrc = FindLocalizedFile(WIKI_PGSRC);
1512     $default_pgsrc = FindFile(DEFAULT_WIKI_PGSRC);
1513
1514     $request->setArg('overwrite', true);
1515     if ($default_pgsrc != $pgsrc) {
1516         LoadAny($request, $default_pgsrc, $GenericPages);
1517     }
1518     $request->setArg('overwrite', false);
1519     LoadAny($request, $pgsrc);
1520     $dbi =& $request->_dbi;
1521
1522     // Ensure that all mandatory pages are loaded
1523     $finder = new FileFinder;
1524
1525     if (!FUSIONFORGE) {
1526         $mandatory = explode(':','SandBox:Template/Category:Template/Talk:SpecialPages:CategoryCategory:CategoryActionPage:Help/OldTextFormattingRules:Help/TextFormattingRules:PhpWikiAdministration');
1527     } else if (WIKI_NAME == "help") {
1528         $mandatory = explode(':','SandBox:Template/Category:Template/Talk:SpecialPages:CategoryCategory:CategoryActionPage:Help/TextFormattingRules:PhpWikiAdministration');
1529     } else {
1530         $mandatory = explode(':','SandBox:Template/UserPage:Template/Category:Template/Talk:SpecialPages:CategoryCategory:CategoryActionPage:TextFormattingRules:PhpWikiAdministration');
1531     }
1532     foreach (array_merge($mandatory,
1533                          $GLOBALS['AllActionPages'],
1534                          array(constant('HOME_PAGE'))) as $f)
1535     {
1536         $page = gettext($f);
1537         $epage = urlencode($page);
1538         if (! $dbi->isWikiPage($page) ) {
1539             // translated version provided?
1540             if ($lf = FindLocalizedFile($pgsrc . $finder->_pathsep . $epage, 1)) {
1541                 LoadAny($request, $lf);
1542             } else { // load english version of required action page
1543                 LoadAny($request, FindFile(DEFAULT_WIKI_PGSRC . $finder->_pathsep . urlencode($f)));
1544                 $page = $f;
1545             }
1546         }
1547         if (! $dbi->isWikiPage($page)) {
1548             trigger_error(sprintf("Mandatory file %s couldn't be loaded!", $page),
1549                           E_USER_WARNING);
1550         }
1551     }
1552
1553     $pagename = _("InterWikiMap");
1554     $map = $dbi->getPage($pagename);
1555     $map->set('locked', true);
1556     PrintXML(HTML::p(HTML::em(WikiLink($pagename)), HTML::strong(" locked")));
1557     EndLoadDump($request);
1558 }
1559
1560 function LoadPostFile (&$request)
1561 {
1562     $upload = $request->getUploadedFile('file');
1563
1564     if (!$upload)
1565         $request->finish(_("No uploaded file to upload?")); // FIXME: more concise message
1566
1567     // Dump http headers.
1568     StartLoadDump($request, sprintf(_("Uploading %s"), $upload->getName()));
1569
1570     $fd = $upload->open();
1571     if (IsZipFile($fd))
1572         LoadZip($request, $fd, false, array(_("RecentChanges")));
1573     else
1574         LoadFile($request, $upload->getName(), $upload->getContents());
1575
1576     EndLoadDump($request);
1577 }
1578
1579 // Local Variables:
1580 // mode: php
1581 // tab-width: 8
1582 // c-basic-offset: 4
1583 // c-hanging-comment-ender-p: nil
1584 // indent-tabs-mode: nil
1585 // End:
1586 ?>