lib/loadsave.php

   1 <?php //-*-php-*-
   2 rcs_id('$Id: loadsave.php,v 1.142 2006-03-19 17:16:32 rurban Exp $');
   3
   4 /*
   5  Copyright 1999,2000,2001,2002,2004,2005 $ThePhpWikiProgrammingTeam
   6
   7  This file is part of PhpWiki.
   8
   9  PhpWiki is free software; you can redistribute it and/or modify
  10  it under the terms of the GNU General Public License as published by
  11  the Free Software Foundation; either version 2 of the License, or
  12  (at your option) any later version.
  13
  14  PhpWiki is distributed in the hope that it will be useful,
  15  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  GNU General Public License for more details.
  18
  19  You should have received a copy of the GNU General Public License
  20  along with PhpWiki; if not, write to the Free Software
  21  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 require_once("lib/ziplib.php");
  25 require_once("lib/Template.php");
  26
  27 /**
  28  * ignore fatal errors during dump
  29  */
  30 function _dump_error_handler(&$error) {
  31     if ($error->isFatal()) {
  32         $error->errno = E_USER_WARNING;
  33         return true;
  34     }
  35     return true;         // Ignore error
  36     /*
  37     if (preg_match('/Plugin/', $error->errstr))
  38         return true;
  39     */
  40     // let the message come through: call the remaining handlers:
  41     // return false;
  42 }
  43
  44 function StartLoadDump(&$request, $title, $html = '')
  45 {
  46     // MockRequest is from the unit testsuite, a faked request. (may be cmd-line)
  47     // We are silent on unittests.
  48     if (isa($request,'MockRequest'))
  49         return;
  50     // FIXME: This is a hack. This really is the worst overall hack in phpwiki.
  51     if ($html)
  52         $html->pushContent('%BODY%');
  53     $tmpl = Template('html', array('TITLE' => $title,
  54                                    'HEADER' => $title,
  55                                    'CONTENT' => $html ? $html : '%BODY%'));
  56     echo ereg_replace('%BODY%.*', '', $tmpl->getExpansion($html));
  57     $request->chunkOutput();
  58
  59     // set marker for sendPageChangeNotification()
  60     $request->_deferredPageChangeNotification = array();
  61 }
  62
  63 function EndLoadDump(&$request)
  64 {
  65     if (isa($request,'MockRequest'))
  66         return;
  67     $action = $request->getArg('action');
  68     $label = '';
  69     switch ($action) {
  70     case 'zip':        $label = _("ZIP files of database"); break;
  71     case 'dumpserial': $label = _("Dump to directory"); break;
  72     case 'upload':     $label = _("Upload File"); break;
  73     case 'loadfile':   $label = _("Load File"); break;
  74     case 'upgrade':    $label = _("Upgrade"); break;
  75     case 'dumphtml':
  76     case 'ziphtml':    $label = _("Dump pages as XHTML"); break;
  77     }
  78     if ($label) $label = str_replace(" ","_",$label);
  79     if ($action == 'browse') // loading virgin
  80         $pagelink = WikiLink(HOME_PAGE);
  81     else
  82         $pagelink = WikiLink(new WikiPageName(_("PhpWikiAdministration"),false,$label));
  83
  84     // do deferred sendPageChangeNotification()
  85     if (!empty($request->_deferredPageChangeNotification)) {
  86         $pages = $all_emails = $all_users = array();
  87         foreach ($request->_deferredPageChangeNotification as $p) {
  88             list($pagename, $emails, $userids) = $p;
  89             $pages[] = $pagename;
  90             $all_emails = array_unique(array_merge($all_emails, $emails));
  91             $all_users = array_unique(array_merge($all_users, $userids));
  92         }
  93         $editedby = sprintf(_("Edited by: %s"), $request->_user->getId());
  94         $content = "Loaded the following pages:\n" . join("\n", $pages);
  95         if (mail(join(',',$all_emails),"[".WIKI_NAME."] "._("LoadDump"),
  96                  _("LoadDump")."\n".
  97                  $editedby."\n\n".
  98                  $content))
  99             trigger_error(sprintf(_("PageChange Notification of %s sent to %s"),
 100                                   join("\n",$pages), join(',',$all_users)), E_USER_NOTICE);
 101         else
 102             trigger_error(sprintf(_("PageChange Notification Error: Couldn't send %s to %s"),
 103                                   join("\n",$pages), join(',',$all_users)), E_USER_WARNING);
 104         unset($pages);
 105         unset($all_emails);
 106         unset($all_users);
 107     }
 108     unset($request->_deferredPageChangeNotification);
 109
 110     PrintXML(HTML::p(HTML::strong(_("Complete."))),
 111              HTML::p(fmt("Return to %s", $pagelink)));
 112     echo "</body></html>\n";
 113 }
 114
 115
 116 ////////////////////////////////////////////////////////////////
 117 //
 118 //  Functions for dumping.
 119 //
 120 ////////////////////////////////////////////////////////////////
 121
 122 /**
 123  * For reference see:
 124  * http://www.nacs.uci.edu/indiv/ehood/MIME/2045/rfc2045.html
 125  * http://www.faqs.org/rfcs/rfc2045.html
 126  * (RFC 1521 has been superceeded by RFC 2045 & others).
 127  *
 128  * Also see http://www.faqs.org/rfcs/rfc2822.html
 129  */
 130 function MailifyPage ($page, $nversions = 1)
 131 {
 132     $current = $page->getCurrentRevision();
 133     $head = '';
 134
 135     if (STRICT_MAILABLE_PAGEDUMPS) {
 136         $from = defined('SERVER_ADMIN') ? SERVER_ADMIN : 'foo@bar';
 137         //This is for unix mailbox format: (not RFC (2)822)
 138         // $head .= "From $from  " . CTime(time()) . "\r\n";
 139         $head .= "Subject: " . rawurlencode($page->getName()) . "\r\n";
 140         $head .= "From: $from (PhpWiki)\r\n";
 141         // RFC 2822 requires only a Date: and originator (From:)
 142         // field, however the obsolete standard RFC 822 also
 143         // requires a destination field.
 144         $head .= "To: $from (PhpWiki)\r\n";
 145     }
 146     $head .= "Date: " . Rfc2822DateTime($current->get('mtime')) . "\r\n";
 147     $head .= sprintf("Mime-Version: 1.0 (Produced by PhpWiki %s)\r\n",
 148                      PHPWIKI_VERSION);
 149
 150     // This should just be entered by hand (or by script?)
 151     // in the actual pgsrc files, since only they should have
 152     // RCS ids.
 153     //$head .= "X-Rcs-Id: \$Id\$\r\n";
 154
 155     $iter = $page->getAllRevisions();
 156     $parts = array();
 157     while ($revision = $iter->next()) {
 158         $parts[] = MimeifyPageRevision($page, $revision);
 159         if ($nversions > 0 && count($parts) >= $nversions)
 160             break;
 161     }
 162     if (count($parts) > 1)
 163         return $head . MimeMultipart($parts);
 164     assert($parts);
 165     return $head . $parts[0];
 166 }
 167
 168 /***
 169  * Compute filename to used for storing contents of a wiki page.
 170  *
 171  * Basically we do a rawurlencode() which encodes everything except
 172  * ASCII alphanumerics and '.', '-', and '_'.
 173  *
 174  * But we also want to encode leading dots to avoid filenames like
 175  * '.', and '..'. (Also, there's no point in generating "hidden" file
 176  * names, like '.foo'.)
 177  *
 178  * @param $pagename string Pagename.
 179  * @return string Filename for page.
 180  */
 181 function FilenameForPage ($pagename)
 182 {
 183     $enc = rawurlencode($pagename);
 184     return preg_replace('/^\./', '%2e', $enc);
 185 }
 186
 187 /**
 188  * The main() function which generates a zip archive of a PhpWiki.
 189  *
 190  * If $include_archive is false, only the current version of each page
 191  * is included in the zip file; otherwise all archived versions are
 192  * included as well.
 193  */
 194 function MakeWikiZip (&$request)
 195 {
 196     if ($request->getArg('include') == 'all') {
 197         $zipname         = WIKI_NAME . _("FullDump") . date('Ymd-Hi') . '.zip';
 198         $include_archive = true;
 199     }
 200     else {
 201         $zipname         = WIKI_NAME . _("LatestSnapshot") . date('Ymd-Hi') . '.zip';
 202         $include_archive = false;
 203     }
 204
 205
 206     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
 207
 208     /* ignore fatals in plugins */
 209     if (check_php_version(4,1)) {
 210         global $ErrorManager;
 211         $ErrorManager->pushErrorHandler(new WikiFunctionCb('_dump_error_handler'));
 212     }
 213
 214     $dbi =& $request->_dbi;
 215     $thispage = $request->getArg('pagename'); // for "Return to ..."
 216     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
 217         $excludeList = explodePageList($exclude);
 218     } else {
 219         $excludeList = array();
 220     }
 221     if ($pages = $request->getArg('pages')) {  // which pagenames
 222         if ($pages == '[]') // current page
 223             $pages = $thispage;
 224         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
 225     } else {
 226         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
 227     }
 228     $request_args = $request->args;
 229     $timeout = (! $request->getArg('start_debug')) ? 30 : 240;
 230
 231     while ($page = $page_iter->next()) {
 232         $request->args = $request_args; // some plugins might change them (esp. on POST)
 233         longer_timeout($timeout);       // Reset watchdog
 234
 235         $current = $page->getCurrentRevision();
 236         if ($current->getVersion() == 0)
 237             continue;
 238
 239         $pagename = $page->getName();
 240         $wpn = new WikiPageName($pagename);
 241         if (!$wpn->isValid())
 242             continue;
 243         if (in_array($page->getName(), $excludeList)) {
 244             continue;
 245         }
 246
 247         $attrib = array('mtime'    => $current->get('mtime'),
 248                         'is_ascii' => 1);
 249         if ($page->get('locked'))
 250             $attrib['write_protected'] = 1;
 251
 252         if ($include_archive)
 253             $content = MailifyPage($page, 0);
 254         else
 255             $content = MailifyPage($page);
 256
 257         $zip->addRegularFile( FilenameForPage($pagename),
 258                               $content, $attrib);
 259     }
 260     $zip->finish();
 261     if (check_php_version(4,1)) {
 262         global $ErrorManager;
 263         $ErrorManager->popErrorHandler();
 264     }
 265 }
 266
 267 function DumpToDir (&$request)
 268 {
 269     $directory = $request->getArg('directory');
 270     if (empty($directory))
 271         $directory = DEFAULT_DUMP_DIR; // See lib/plugin/WikiForm.php:87
 272     if (empty($directory))
 273         $request->finish(_("You must specify a directory to dump to"));
 274
 275     // see if we can access the directory the user wants us to use
 276     if (! file_exists($directory)) {
 277         if (! mkdir($directory, 0755))
 278             $request->finish(fmt("Cannot create directory '%s'", $directory));
 279         else
 280             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
 281                                 $directory));
 282     } else {
 283         $html = HTML::p(fmt("Using directory '%s'", $directory));
 284     }
 285
 286     StartLoadDump($request, _("Dumping Pages"), $html);
 287
 288     $dbi =& $request->_dbi;
 289     $thispage = $request->getArg('pagename'); // for "Return to ..."
 290     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
 291         $excludeList = explodePageList($exclude);
 292     } else {
 293         $excludeList = array();
 294     }
 295     if ($pages = $request->getArg('pages')) {  // which pagenames
 296         if ($pages == '[]') // current page
 297             $pages = $thispage;
 298         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
 299     } else {
 300         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
 301     }
 302
 303     $request_args = $request->args;
 304     $timeout = (! $request->getArg('start_debug')) ? 30 : 240;
 305
 306     while ($page = $page_iter->next()) {
 307         $request->args = $request_args; // some plugins might change them (esp. on POST)
 308         longer_timeout($timeout);       // Reset watchdog
 309
 310         $pagename = $page->getName();
 311         if (!isa($request,'MockRequest')) {
 312             PrintXML(HTML::br(), $pagename, ' ... ');
 313             flush();
 314         }
 315
 316         if (in_array($pagename, $excludeList)) {
 317             if (!isa($request, 'MockRequest')) {
 318                 PrintXML(_("Skipped."));
 319                 flush();
 320             }
 321             continue;
 322         }
 323         $filename = FilenameForPage($pagename);
 324         $msg = HTML();
 325         if($page->getName() != $filename) {
 326             $msg->pushContent(HTML::small(fmt("saved as %s", $filename)),
 327                               " ... ");
 328         }
 329
 330         if ($request->getArg('include') == 'all')
 331             $data = MailifyPage($page, 0);
 332         else
 333             $data = MailifyPage($page);
 334
 335         if ( !($fd = fopen($directory."/".$filename, "wb")) ) {
 336             $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
 337                                                "$directory/$filename")));
 338             $request->finish($msg);
 339         }
 340
 341         $num = fwrite($fd, $data, strlen($data));
 342         $msg->pushContent(HTML::small(fmt("%s bytes written", $num)));
 343         if (!isa($request, 'MockRequest')) {
 344             PrintXML($msg);
 345             flush();
 346         }
 347         assert($num == strlen($data));
 348         fclose($fd);
 349     }
 350
 351     EndLoadDump($request);
 352 }
 353
 354 function _copyMsg($page, $smallmsg) {
 355     if (!isa($GLOBALS['request'], 'MockRequest')) {
 356         if ($page) $msg = HTML(HTML::br(), HTML($page), HTML::small($smallmsg));
 357         else $msg = HTML::small($smallmsg);
 358         PrintXML($msg);
 359         flush();
 360     }
 361 }
 362
 363 /**
 364  * Dump all pages as XHTML to a directory, as pagename.html.
 365  * Copies all used css files to the directory, all used images to a
 366  * "images" subdirectory, and all used buttons to a "images/buttons" subdirectory.
 367  * The webserver must have write permissions to these directories.
 368  *   chown httpd HTML_DUMP_DIR; chmod u+rwx HTML_DUMP_DIR
 369  * should be enough.
 370  *
 371  * @param string directory (optional) path to dump to. Default: HTML_DUMP_DIR
 372  * @param string pages     (optional) Comma-seperated of glob-style pagenames to dump
 373  * @param string exclude   (optional) Comma-seperated of glob-style pagenames to exclude
 374  */
 375 function DumpHtmlToDir (&$request)
 376 {
 377     $directory = $request->getArg('directory');
 378     if (empty($directory))
 379         $directory = HTML_DUMP_DIR; // See lib/plugin/WikiForm.php:87
 380     if (empty($directory))
 381         $request->finish(_("You must specify a directory to dump to"));
 382
 383     // see if we can access the directory the user wants us to use
 384     if (! file_exists($directory)) {
 385         if (! mkdir($directory, 0755))
 386             $request->finish(fmt("Cannot create directory '%s'", $directory));
 387         else
 388             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
 389                                 $directory));
 390     } else {
 391         $html = HTML::p(fmt("Using directory '%s'", $directory));
 392     }
 393     $request->_TemplatesProcessed = array();
 394     StartLoadDump($request, _("Dumping Pages"), $html);
 395     $thispage = $request->getArg('pagename'); // for "Return to ..."
 396
 397     $dbi =& $request->_dbi;
 398     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
 399         $excludeList = explodePageList($exclude);
 400     } else {
 401         $excludeList = array();
 402     }
 403     if ($pages = $request->getArg('pages')) {  // which pagenames
 404         if ($pages == '[]') // current page
 405             $pages = $thispage;
 406         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
 407     // not at admin page: dump only the current page
 408     } elseif ($thispage != _("PhpWikiAdministration")) {
 409         $page_iter = new WikiDB_Array_PageIterator(array($thispage));
 410     } else {
 411         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
 412     }
 413
 414     global $WikiTheme;
 415     if (defined('HTML_DUMP_SUFFIX'))
 416         $WikiTheme->HTML_DUMP_SUFFIX = HTML_DUMP_SUFFIX;
 417     $WikiTheme->DUMP_MODE = 'HTML';
 418     $_bodyAttr = @$WikiTheme->_MoreAttr['body'];
 419     unset($WikiTheme->_MoreAttr['body']);
 420
 421     // check if the dumped file will be accessible from outside
 422     $doc_root = $request->get("DOCUMENT_ROOT");
 423     $ldir = NormalizeLocalFileName($directory);
 424     $wikiroot = NormalizeLocalFileName('');
 425     if (string_starts_with($ldir, $doc_root)) {
 426         $link_prefix = substr($directory, strlen($doc_root))."/";
 427     } elseif (string_starts_with($ldir, $wikiroot)) {
 428         $link_prefix = NormalizeWebFileName(substr($directory, strlen($wikiroot)))."/";
 429     } else {
 430         $prefix = '';
 431         if (isWindows()) {
 432             $prefix = '/' . substr($doc_root,0,2); // add drive where apache is installed
 433         }
 434         $link_prefix = "file://".$prefix.$directory."/";
 435     }
 436
 437     $request_args = $request->args;
 438     $timeout = (! $request->getArg('start_debug')) ? 20 : 240;
 439
 440     while ($page = $page_iter->next()) {
 441         $request->args = $request_args; // some plugins might change them (esp. on POST)
 442         longer_timeout($timeout);       // Reset watchdog
 443
 444         $pagename = $page->getName();
 445         if (!isa($request,'MockRequest')) {
 446             PrintXML(HTML::br(), $pagename, ' ... ');
 447             flush();
 448         }
 449         if (in_array($pagename, $excludeList)) {
 450             if (!isa($request,'MockRequest')) {
 451                 PrintXML(_("Skipped."));
 452                 flush();
 453             }
 454             continue;
 455         }
 456
 457         $request->setArg('pagename', $pagename); // Template::_basepage fix
 458         $filename = FilenameForPage($pagename) . $WikiTheme->HTML_DUMP_SUFFIX;
 459         $msg = HTML();
 460
 461         $revision = $page->getCurrentRevision();
 462         $template = new Template('browse', $request,
 463                                  array('revision' => $revision,
 464                                        'CONTENT' => $revision->getTransformedContent()));
 465
 466         $data = GeneratePageasXML($template, $pagename);
 467
 468         if ( !($fd = fopen($directory."/".$filename, "wb")) ) {
 469             $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
 470                                                "$directory/$filename")));
 471             $request->finish($msg);
 472         }
 473         $num = fwrite($fd, $data, strlen($data));
 474         if ($page->getName() != $filename) {
 475             $link = LinkURL($link_prefix.$filename, $filename);
 476             $msg->pushContent(HTML::small(_("saved as "), $link, " ... "));
 477         }
 478         $msg->pushContent(HTML::small(fmt("%s bytes written", $num), "\n"));
 479         if (!isa($request, 'MockRequest')) {
 480             PrintXML($msg);
 481         }
 482         flush();
 483         $request->chunkOutput();
 484
 485         assert($num == strlen($data));
 486         fclose($fd);
 487
 488         if (USECACHE) {
 489             $request->_dbi->_cache->invalidate_cache($pagename);
 490             unset ($request->_dbi->_cache->_pagedata_cache);
 491             unset ($request->_dbi->_cache->_versiondata_cache);
 492             unset ($request->_dbi->_cache->_glv_cache);
 493         }
 494         unset ($request->_dbi->_cache->_backend->_page_data);
 495
 496         unset($msg);
 497         unset($revision->_transformedContent);
 498         unset($revision);
 499         unset($template->_request);
 500         unset($template);
 501         unset($data);
 502     }
 503     $page_iter->free();
 504
 505     if (!empty($WikiTheme->dumped_images) and is_array($WikiTheme->dumped_images)) {
 506         @mkdir("$directory/images");
 507         foreach ($WikiTheme->dumped_images as $img_file) {
 508             if ($img_file
 509                 and ($from = $WikiTheme->_findFile($img_file, true))
 510                 and basename($from))
 511             {
 512                 $target = "$directory/images/".basename($img_file);
 513                 if (copy($WikiTheme->_path . $from, $target)) {
 514                     _copyMsg($from, fmt("... copied to %s", $target));
 515                 } else {
 516                     _copyMsg($from, fmt("... not copied to %s", $target));
 517                 }
 518             } else {
 519                 _copyMsg($from, _("... not found"));
 520             }
 521         }
 522     }
 523     if (!empty($WikiTheme->dumped_buttons) and is_array($WikiTheme->dumped_buttons)) {
 524         // Buttons also
 525         @mkdir("$directory/images/buttons");
 526         foreach ($WikiTheme->dumped_buttons as $text => $img_file) {
 527             if ($img_file
 528                 and ($from = $WikiTheme->_findFile($img_file, true))
 529                 and basename($from))
 530             {
 531                 $target = "$directory/images/buttons/".basename($img_file);
 532                 if (copy($WikiTheme->_path . $from, $target)) {
 533                     _copyMsg($from, fmt("... copied to %s", $target));
 534                 } else {
 535                     _copyMsg($from, fmt("... not copied to %s", $target));
 536                 }
 537             } else {
 538                 _copyMsg($from, _("... not found"));
 539             }
 540         }
 541     }
 542     if (!empty($WikiTheme->dumped_css) and is_array($WikiTheme->dumped_css)) {
 543         foreach ($WikiTheme->dumped_css as $css_file) {
 544             if ($css_file
 545                 and ($from = $WikiTheme->_findFile(basename($css_file), true))
 546                 and basename($from))
 547             {
 548                 $target = "$directory/" . basename($css_file);
 549                 if (copy($WikiTheme->_path . $from, $target)) {
 550                     _copyMsg($from, fmt("... copied to %s", $target));
 551                 } else {
 552                     _copyMsg($from, fmt("... not copied to %s", $target));
 553                 }
 554             } else {
 555                 _copyMsg($from, _("... not found"));
 556             }
 557         }
 558     }
 559     $WikiTheme->HTML_DUMP_SUFFIX = '';
 560     $WikiTheme->DUMP_MODE = false;
 561     $WikiTheme->_MoreAttr['body'] = $_bodyAttr;
 562
 563     $request->setArg('pagename',$thispage); // Template::_basepage fix
 564     EndLoadDump($request);
 565 }
 566
 567 /* Known problem: any plugins or other code which echo()s text will
 568  * lead to a corrupted html zip file which may produce the following
 569  * errors upon unzipping:
 570  *
 571  * warning [wikihtml.zip]:  2401 extra bytes at beginning or within zipfile
 572  * file #58:  bad zipfile offset (local header sig):  177561
 573  *  (attempting to re-compensate)
 574  *
 575  * However, the actual wiki page data should be unaffected.
 576  */
 577 function MakeWikiZipHtml (&$request)
 578 {
 579     $request->_TemplatesProcessed = array();
 580     $zipname = "wikihtml.zip";
 581     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
 582     $dbi =& $request->_dbi;
 583     $thispage = $request->getArg('pagename'); // for "Return to ..."
 584     if ($exclude = $request->getArg('exclude')) {   // exclude which pagenames
 585         $excludeList = explodePageList($exclude);
 586     } else {
 587         $excludeList = array();
 588     }
 589     if ($pages = $request->getArg('pages')) {  // which pagenames
 590         if ($pages == '[]') // current page
 591             $pages = $thispage;
 592         $page_iter = new WikiDB_Array_PageIterator(explodePageList($pages));
 593     } else {
 594         $page_iter = $dbi->getAllPages(false,false,false,$excludeList);
 595     }
 596
 597     global $WikiTheme;
 598     if (defined('HTML_DUMP_SUFFIX'))
 599         $WikiTheme->HTML_DUMP_SUFFIX = HTML_DUMP_SUFFIX;
 600     $WikiTheme->DUMP_MODE = 'ZIPHTML';
 601     $_bodyAttr = @$WikiTheme->_MoreAttr['body'];
 602     unset($WikiTheme->_MoreAttr['body']);
 603
 604     /* ignore fatals in plugins */
 605     if (check_php_version(4,1)) {
 606         global $ErrorManager;
 607         $ErrorManager->pushErrorHandler(new WikiFunctionCb('_dump_error_handler'));
 608     }
 609
 610     $request_args = $request->args;
 611     $timeout = (! $request->getArg('start_debug')) ? 20 : 240;
 612
 613     while ($page = $page_iter->next()) {
 614         $request->args = $request_args; // some plugins might change them (esp. on POST)
 615         longer_timeout($timeout);       // Reset watchdog
 616
 617         $current = $page->getCurrentRevision();
 618         if ($current->getVersion() == 0)
 619             continue;
 620         $pagename = $page->getName();
 621         if (in_array($pagename, $excludeList)) {
 622             continue;
 623         }
 624
 625         $attrib = array('mtime'    => $current->get('mtime'),
 626                         'is_ascii' => 1);
 627         if ($page->get('locked'))
 628             $attrib['write_protected'] = 1;
 629
 630         $request->setArg('pagename',$pagename); // Template::_basepage fix
 631         $filename = FilenameForPage($pagename) . $WikiTheme->HTML_DUMP_SUFFIX;
 632         $revision = $page->getCurrentRevision();
 633
 634         $transformedContent = $revision->getTransformedContent();
 635
 636         $template = new Template('browse', $request,
 637                                  array('revision' => $revision,
 638                                        'CONTENT' => $transformedContent));
 639
 640         $data = GeneratePageasXML($template, $pagename);
 641
 642         $zip->addRegularFile( $filename, $data, $attrib );
 643
 644         if (USECACHE) {
 645             $request->_dbi->_cache->invalidate_cache($pagename);
 646             unset ($request->_dbi->_cache->_pagedata_cache);
 647             unset ($request->_dbi->_cache->_versiondata_cache);
 648             unset ($request->_dbi->_cache->_glv_cache);
 649         }
 650         unset ($request->_dbi->_cache->_backend->_page_data);
 651
 652         unset($revision->_transformedContent);
 653         unset($revision);
 654         unset($template->_request);
 655         unset($template);
 656         unset($data);
 657     }
 658     $page_iter->free();
 659
 660     $attrib = false;
 661     // Deal with css and images here.
 662     if (!empty($WikiTheme->dumped_images) and is_array($WikiTheme->dumped_images)) {
 663         // dirs are created automatically
 664         //if ($WikiTheme->dumped_images) $zip->addRegularFile("images", "", $attrib);
 665         foreach ($WikiTheme->dumped_images as $img_file) {
 666             if (($from = $WikiTheme->_findFile($img_file, true)) and basename($from)) {
 667                 $target = "images/".basename($img_file);
 668                 if (check_php_version(4,3))
 669                     $zip->addRegularFile($target, file_get_contents($WikiTheme->_path . $from), $attrib);
 670                 else
 671                     $zip->addRegularFile($target, join('', file($WikiTheme->_path . $from)), $attrib);
 672             }
 673         }
 674     }
 675     if (!empty($WikiTheme->dumped_buttons) and is_array($WikiTheme->dumped_buttons)) {
 676         //if ($WikiTheme->dumped_buttons) $zip->addRegularFile("images/buttons", "", $attrib);
 677         foreach ($WikiTheme->dumped_buttons as $text => $img_file) {
 678             if (($from = $WikiTheme->_findFile($img_file, true)) and basename($from)) {
 679                 $target = "images/buttons/".basename($img_file);
 680                 if (check_php_version(4,3))
 681                     $zip->addRegularFile($target, file_get_contents($WikiTheme->_path . $from), $attrib);
 682                 else
 683                     $zip->addRegularFile($target, join('', file($WikiTheme->_path . $from)), $attrib);
 684             }
 685         }
 686     }
 687     if (!empty($WikiTheme->dumped_css) and is_array($WikiTheme->dumped_css)) {
 688         foreach ($WikiTheme->dumped_css as $css_file) {
 689             if (($from = $WikiTheme->_findFile(basename($css_file), true)) and basename($from)) {
 690                 $target = basename($css_file);
 691                 if (check_php_version(4,3))
 692                     $zip->addRegularFile($target, file_get_contents($WikiTheme->_path . $from), $attrib);
 693                 else
 694                     $zip->addRegularFile($target, join('', file($WikiTheme->_path . $from)), $attrib);
 695             }
 696         }
 697     }
 698
 699     $zip->finish();
 700     if (check_php_version(4,1)) {
 701         global $ErrorManager;
 702         $ErrorManager->popErrorHandler();
 703     }
 704     $WikiTheme->HTML_DUMP_SUFFIX = '';
 705     $WikiTheme->DUMP_MODE = false;
 706     $WikiTheme->_MoreAttr['body'] = $_bodyAttr;
 707 }
 708
 709
 710 ////////////////////////////////////////////////////////////////
 711 //
 712 //  Functions for restoring.
 713 //
 714 ////////////////////////////////////////////////////////////////
 715
 716 function SavePage (&$request, &$pageinfo, $source, $filename)
 717 {
 718     static $overwite_all = false;
 719     $pagedata    = $pageinfo['pagedata'];    // Page level meta-data.
 720     $versiondata = $pageinfo['versiondata']; // Revision level meta-data.
 721
 722     if (empty($pageinfo['pagename'])) {
 723         PrintXML(HTML::dt(HTML::strong(_("Empty pagename!"))));
 724         return;
 725     }
 726
 727     if (empty($versiondata['author_id']))
 728         $versiondata['author_id'] = $versiondata['author'];
 729
 730     $pagename = $pageinfo['pagename'];
 731     $content  = $pageinfo['content'];
 732
 733     if ($pagename ==_("InterWikiMap"))
 734         $content = _tryinsertInterWikiMap($content);
 735
 736     $dbi =& $request->_dbi;
 737     $page = $dbi->getPage($pagename);
 738
 739     // Try to merge if updated pgsrc contents are different. This
 740     // whole thing is hackish
 741     //
 742     // TODO: try merge unless:
 743     // if (current contents = default contents && pgsrc_version >=
 744     // pgsrc_version) then just upgrade this pgsrc
 745     $needs_merge = false;
 746     $merging = false;
 747     $overwrite = false;
 748
 749     if ($request->getArg('merge')) {
 750         $merging = true;
 751     }
 752     else if ($request->getArg('overwrite')) {
 753         $overwrite = true;
 754     }
 755
 756     $current = $page->getCurrentRevision();
 757     if ( $current and (! $current->hasDefaultContents())
 758          && ($current->getPackedContent() != $content)
 759          && ($merging == true) ) {
 760         include_once('lib/editpage.php');
 761         $request->setArg('pagename', $pagename);
 762         $r = $current->getVersion();
 763         $request->setArg('revision', $current->getVersion());
 764         $p = new LoadFileConflictPageEditor($request);
 765         $p->_content = $content;
 766         $p->_currentVersion = $r - 1;
 767         $p->editPage($saveFailed = true);
 768         return; //early return
 769     }
 770
 771     foreach ($pagedata as $key => $value) {
 772         if (!empty($value))
 773             $page->set($key, $value);
 774     }
 775
 776     $mesg = HTML::dd();
 777     $skip = false;
 778     if ($source)
 779         $mesg->pushContent(' ', fmt("from %s", $source));
 780
 781
 782     if (!$current) {
 783         //FIXME: This should not happen! (empty vdata, corrupt cache or db)
 784         $current = $page->getCurrentRevision();
 785     }
 786     if ($current->getVersion() == 0) {
 787         $mesg->pushContent(' - ', _("New page"));
 788         $isnew = true;
 789     }
 790     else {
 791         if ( (! $current->hasDefaultContents())
 792              && ($current->getPackedContent() != $content) ) {
 793             if ($overwrite) {
 794                 $mesg->pushContent(' ',
 795                                    fmt("has edit conflicts - overwriting anyway"));
 796                 $skip = false;
 797                 if (substr_count($source, 'pgsrc')) {
 798                     $versiondata['author'] = _("The PhpWiki programming team");
 799                     // but leave authorid as userid who loaded the file
 800                 }
 801             }
 802             else {
 803                 $mesg->pushContent(' ', fmt("has edit conflicts - skipped"));
 804                 $needs_merge = true; // hackish
 805                 $skip = true;
 806             }
 807         }
 808         else if ($current->getPackedContent() == $content
 809                  && $current->get('author') == $versiondata['author']) {
 810             // The page metadata is already changed, we don't need a new revision.
 811             // This was called previously "is identical to current version %d - skipped"
 812             // which is wrong, since the pagedata was stored, not skipped.
 813             $mesg->pushContent(' ',
 814                                fmt("content is identical to current version %d - no new revision created",
 815                                    $current->getVersion()));
 816             $skip = true;
 817         }
 818         $isnew = false;
 819     }
 820
 821     if (! $skip ) {
 822         // in case of failures print the culprit:
 823         if (!isa($request,'MockRequest')) {
 824             PrintXML(HTML::dt(WikiLink($pagename))); flush();
 825         }
 826         $new = $page->save($content, WIKIDB_FORCE_CREATE, $versiondata);
 827         $dbi->touch();
 828         $mesg->pushContent(' ', fmt("- saved to database as version %d",
 829                                     $new->getVersion()));
 830     }
 831     if ($needs_merge) {
 832         $f = $source;
 833         // hackish, $source contains needed path+filename
 834         $f = str_replace(sprintf(_("MIME file %s"), ''), '', $f);
 835         $f = str_replace(sprintf(_("Serialized file %s"), ''), '', $f);
 836         $f = str_replace(sprintf(_("plain file %s"), ''), '', $f);
 837         //check if uploaded file? they pass just the content, but the file is gone
 838         if (@stat($f)) {
 839             global $WikiTheme;
 840             $meb = Button(array('action' => 'loadfile',
 841                                 'merge'=> true,
 842                                 'source'=> $f),
 843                           _("Merge Edit"),
 844                           _("PhpWikiAdministration"),
 845                           'wikiadmin');
 846             $owb = Button(array('action' => 'loadfile',
 847                                 'overwrite'=> true,
 848                                 'source'=> $f),
 849                           _("Restore Anyway"),
 850                           _("PhpWikiAdministration"),
 851                           'wikiunsafe');
 852             $mesg->pushContent(' ', $meb, " ", $owb);
 853             if (!$overwite_all) {
 854                 $args = $request->getArgs();
 855                 $args['overwrite'] = 1;
 856                 $owb = Button($args,
 857                               _("Overwrite All"),
 858                               _("PhpWikiAdministration"),
 859                               'wikiunsafe');
 860                 $mesg->pushContent(HTML::div(array('class' => 'hint'), $owb));
 861                 $overwite_all = true;
 862             }
 863         } else {
 864             $mesg->pushContent(HTML::em(_(" Sorry, cannot merge.")));
 865         }
 866     }
 867
 868     if (!isa($request,'MockRequest')) {
 869       if ($skip)
 870         PrintXML(HTML::dt(HTML::em(WikiLink($pagename))), $mesg);
 871       else
 872         PrintXML($mesg);
 873       flush();
 874     }
 875 }
 876
 877 // action=revert (by diff)
 878 function RevertPage (&$request)
 879 {
 880     $mesg = HTML::dd();
 881     $pagename = $request->getArg('pagename');
 882     $version = $request->getArg('version');
 883     if (!$version) {
 884         PrintXML(HTML::dt(fmt("Revert")," ",WikiLink($pagename)),
 885                  HTML::dd(_("missing required version argument")));
 886         return;
 887     }
 888     $dbi =& $request->_dbi;
 889     $page = $dbi->getPage($pagename);
 890     $current = $page->getCurrentRevision();
 891     $currversion = $current->getVersion();
 892     if ($currversion == 0) {
 893         $mesg->pushContent(' ', _("no page content"));
 894         PrintXML(HTML::dt(fmt("Revert")," ",WikiLink($pagename)),
 895                  $mesg);
 896         flush();
 897         return;
 898     }
 899     if ($currversion == $version) {
 900         $mesg->pushContent(' ', _("same version page"));
 901         PrintXML(HTML::dt(fmt("Revert")," ",WikiLink($pagename)),
 902                  $mesg);
 903         flush();
 904         return;
 905     }
 906     if ($request->getArg('cancel')) {
 907         $mesg->pushContent(' ', _("Cancelled"));
 908         PrintXML(HTML::dt(fmt("Revert")," ",WikiLink($pagename)),
 909                  $mesg);
 910         flush();
 911         return;
 912     }
 913     if (!$request->getArg('verify')) {
 914         $mesg->pushContent(HTML::br(),
 915                            _("Are you sure?"),
 916                            HTML::br(),
 917                            HTML::form(array('action' => $request->getPostURL(),
 918                                             'method' => 'post'),
 919                                       HiddenInputs($request->getArgs(), false, array('verify')),
 920                                       HiddenInputs(array('verify' => 1)),
 921                                       Button('submit:verify', _("Yes"), 'button'),
 922                                       HTML::Raw('&nbsp;'),
 923                                       Button('submit:cancel', _("Cancel"), 'button')));
 924         $rev = $page->getRevision($version);
 925         $html = HTML(HTML::dt(fmt("Revert %s to version $version", WikiLink($pagename))),
 926                      $mesg,
 927                      $rev->getTransformedContent());
 928         $template = Template('browse',
 929                              array('CONTENT' => $html));
 930         GeneratePage($template, $pagename, $rev);
 931         $request->checkValidators();
 932         flush();
 933         return;
 934     }
 935     $rev = $page->getRevision($version);
 936     $content = $rev->getPackedContent();
 937     $versiondata = $rev->_data;
 938     $versiondata['summary'] = sprintf(_("revert to version %d"), $version);
 939     $new = $page->save($content, $currversion + 1, $versiondata);
 940     $dbi->touch();
 941
 942     $pagelink = WikiLink($pagename);
 943     $mesg->pushContent(fmt("Revert: %s", $pagelink),
 944                        fmt("- version %d saved to database as version %d",
 945                            $version, $new->getVersion()));
 946     // Force browse of current page version.
 947     $request->setArg('version', false);
 948     $template = Template('savepage', array());
 949     $template->replace('CONTENT', $new->getTransformedContent());
 950
 951     GeneratePage($template, $mesg, $new);
 952     flush();
 953 }
 954
 955 function _tryinsertInterWikiMap($content) {
 956     $goback = false;
 957     if (strpos($content, "<verbatim>")) {
 958         //$error_html = " The newly loaded pgsrc already contains a verbatim block.";
 959         $goback = true;
 960     }
 961     if (!$goback && !defined('INTERWIKI_MAP_FILE')) {
 962         $error_html = sprintf(" "._("%s: not defined"), "INTERWIKI_MAP_FILE");
 963         $goback = true;
 964     }
 965     $mapfile = FindFile(INTERWIKI_MAP_FILE,1);
 966     if (!$goback && !file_exists($mapfile)) {
 967         $error_html = sprintf(" "._("%s: file not found"), INTERWIKI_MAP_FILE);
 968         $goback = true;
 969     }
 970
 971     if (!empty($error_html))
 972         trigger_error(_("Default InterWiki map file not loaded.")
 973                       . $error_html, E_USER_NOTICE);
 974     if ($goback)
 975         return $content;
 976
 977     // if loading from virgin setup do echo, otherwise trigger_error E_USER_NOTICE
 978     if (!isa($GLOBALS['request'], 'MockRequest'))
 979         echo sprintf(_("Loading InterWikiMap from external file %s."), $mapfile),"<br />";
 980
 981     $fd = fopen ($mapfile, "rb");
 982     $data = fread ($fd, filesize($mapfile));
 983     fclose ($fd);
 984     $content = $content . "\n<verbatim>\n$data</verbatim>\n";
 985     return $content;
 986 }
 987
 988 function ParseSerializedPage($text, $default_pagename, $user)
 989 {
 990     if (!preg_match('/^a:\d+:{[si]:\d+/', $text))
 991         return false;
 992
 993     $pagehash = unserialize($text);
 994
 995     // Split up pagehash into four parts:
 996     //   pagename
 997     //   content
 998     //   page-level meta-data
 999     //   revision-level meta-data
1000
1001     if (!defined('FLAG_PAGE_LOCKED'))
1002         define('FLAG_PAGE_LOCKED', 1);
1003     $pageinfo = array('pagedata'    => array(),
1004                       'versiondata' => array());
1005
1006     $pagedata = &$pageinfo['pagedata'];
1007     $versiondata = &$pageinfo['versiondata'];
1008
1009     // Fill in defaults.
1010     if (empty($pagehash['pagename']))
1011         $pagehash['pagename'] = $default_pagename;
1012     if (empty($pagehash['author'])) {
1013         $pagehash['author'] = $user->getId();
1014     }
1015
1016     foreach ($pagehash as $key => $value) {
1017         switch($key) {
1018             case 'pagename':
1019             case 'version':
1020             case 'hits':
1021                 $pageinfo[$key] = $value;
1022                 break;
1023             case 'content':
1024                 $pageinfo[$key] = join("\n", $value);
1025                 break;
1026             case 'flags':
1027                 if (($value & FLAG_PAGE_LOCKED) != 0)
1028                     $pagedata['locked'] = 'yes';
1029                 break;
1030             case 'owner':
1031             case 'created':
1032                 $pagedata[$key] = $value;
1033                 break;
1034             case 'acl':
1035             case 'perm':
1036                 $pagedata['perm'] = ParseMimeifiedPerm($value);
1037                 break;
1038             case 'lastmodified':
1039                 $versiondata['mtime'] = $value;
1040                 break;
1041             case 'author':
1042             case 'author_id':
1043             case 'summary':
1044                 $versiondata[$key] = $value;
1045                 break;
1046         }
1047     }
1048     return $pageinfo;
1049 }
1050
1051 function SortByPageVersion ($a, $b) {
1052     return $a['version'] - $b['version'];
1053 }
1054
1055 /**
1056  * Security alert! We should not allow to import config.ini into our wiki (or from a sister wiki?)
1057  * because the sql passwords are in plaintext there. And the webserver must be able to read it.
1058  * Detected by Santtu Jarvi.
1059  */
1060 function LoadFile (&$request, $filename, $text = false, $mtime = false)
1061 {
1062     if (preg_match("/config$/", dirname($filename))             // our or other config
1063         and preg_match("/config.*\.ini/", basename($filename))) // backups and other versions also
1064     {
1065         trigger_error(sprintf("Refused to load %s", $filename), E_USER_WARNING);
1066         return;
1067     }
1068     if (!is_string($text)) {
1069         // Read the file.
1070         $stat  = stat($filename);
1071         $mtime = $stat[9];
1072         $text  = implode("", file($filename));
1073     }
1074
1075     if (! $request->getArg('start_debug')) @set_time_limit(30); // Reset watchdog
1076     else @set_time_limit(240);
1077
1078     // FIXME: basename("filewithnoslashes") seems to return garbage sometimes.
1079     $basename = basename("/dummy/" . $filename);
1080
1081     if (!$mtime)
1082         $mtime = time();    // Last resort.
1083
1084     $default_pagename = rawurldecode($basename);
1085     if ( ($parts = ParseMimeifiedPages($text)) ) {
1086         usort($parts, 'SortByPageVersion');
1087         foreach ($parts as $pageinfo)
1088             SavePage($request, $pageinfo, sprintf(_("MIME file %s"),
1089                                                   $filename), $basename);
1090     }
1091     else if ( ($pageinfo = ParseSerializedPage($text, $default_pagename,
1092                                                $request->getUser())) ) {
1093         SavePage($request, $pageinfo, sprintf(_("Serialized file %s"),
1094                                               $filename), $basename);
1095     }
1096     else {
1097         $user = $request->getUser();
1098
1099         // Assume plain text file.
1100         $pageinfo = array('pagename' => $default_pagename,
1101                           'pagedata' => array(),
1102                           'versiondata'
1103                           => array('author' => $user->getId()),
1104                           'content'  => preg_replace('/[ \t\r]*\n/', "\n",
1105                                                      chop($text))
1106                           );
1107         SavePage($request, $pageinfo, sprintf(_("plain file %s"), $filename),
1108                  $basename);
1109     }
1110 }
1111
1112 function LoadZip (&$request, $zipfile, $files = false, $exclude = false) {
1113     $zip = new ZipReader($zipfile);
1114     $timeout = (! $request->getArg('start_debug')) ? 20 : 120;
1115     while (list ($fn, $data, $attrib) = $zip->readFile()) {
1116         // FIXME: basename("filewithnoslashes") seems to return
1117         // garbage sometimes.
1118         $fn = basename("/dummy/" . $fn);
1119         if ( ($files && !in_array($fn, $files))
1120              || ($exclude && in_array($fn, $exclude)) ) {
1121             PrintXML(HTML::dt(WikiLink($fn)),
1122                      HTML::dd(_("Skipping")));
1123             flush();
1124             continue;
1125         }
1126         longer_timeout($timeout);       // longer timeout per page
1127         LoadFile($request, $fn, $data, $attrib['mtime']);
1128     }
1129 }
1130
1131 function LoadDir (&$request, $dirname, $files = false, $exclude = false) {
1132     $fileset = new LimitedFileSet($dirname, $files, $exclude);
1133
1134     if (!$files and ($skiplist = $fileset->getSkippedFiles())) {
1135         PrintXML(HTML::dt(HTML::strong(_("Skipping"))));
1136         $list = HTML::ul();
1137         foreach ($skiplist as $file)
1138             $list->pushContent(HTML::li(WikiLink($file)));
1139         PrintXML(HTML::dd($list));
1140     }
1141
1142     // Defer HomePage loading until the end. If anything goes wrong
1143     // the pages can still be loaded again.
1144     $files = $fileset->getFiles();
1145     if (in_array(HOME_PAGE, $files)) {
1146         $files = array_diff($files, array(HOME_PAGE));
1147         $files[] = HOME_PAGE;
1148     }
1149     $timeout = (! $request->getArg('start_debug')) ? 20 : 120;
1150     foreach ($files as $file) {
1151         longer_timeout($timeout);       // longer timeout per page
1152         if (substr($file,-1,1) != '~')  // refuse to load backup files
1153             LoadFile($request, "$dirname/$file");
1154     }
1155 }
1156
1157 class LimitedFileSet extends FileSet {
1158     function LimitedFileSet($dirname, $_include, $exclude) {
1159         $this->_includefiles = $_include;
1160         $this->_exclude = $exclude;
1161         $this->_skiplist = array();
1162         parent::FileSet($dirname);
1163     }
1164
1165     function _filenameSelector($fn) {
1166         $incl = &$this->_includefiles;
1167         $excl = &$this->_exclude;
1168
1169         if ( ($incl && !in_array($fn, $incl))
1170              || ($excl && in_array($fn, $excl)) ) {
1171             $this->_skiplist[] = $fn;
1172             return false;
1173         } else {
1174             return true;
1175         }
1176     }
1177
1178     function getSkippedFiles () {
1179         return $this->_skiplist;
1180     }
1181 }
1182
1183
1184 function IsZipFile ($filename_or_fd)
1185 {
1186     // See if it looks like zip file
1187     if (is_string($filename_or_fd))
1188     {
1189         $fd    = fopen($filename_or_fd, "rb");
1190         $magic = fread($fd, 4);
1191         fclose($fd);
1192     }
1193     else
1194     {
1195         $fpos  = ftell($filename_or_fd);
1196         $magic = fread($filename_or_fd, 4);
1197         fseek($filename_or_fd, $fpos);
1198     }
1199
1200     return $magic == ZIP_LOCHEAD_MAGIC || $magic == ZIP_CENTHEAD_MAGIC;
1201 }
1202
1203
1204 function LoadAny (&$request, $file_or_dir, $files = false, $exclude = false)
1205 {
1206     // Try urlencoded filename for accented characters.
1207     if (!file_exists($file_or_dir)) {
1208         // Make sure there are slashes first to avoid confusing phps
1209         // with broken dirname or basename functions.
1210         // FIXME: windows uses \ and :
1211         if (is_integer(strpos($file_or_dir, "/"))) {
1212             $file_or_dir = FindFile($file_or_dir);
1213             // Panic
1214             if (!file_exists($file_or_dir))
1215                 $file_or_dir = dirname($file_or_dir) . "/"
1216                     . urlencode(basename($file_or_dir));
1217         } else {
1218             // This is probably just a file.
1219             $file_or_dir = urlencode($file_or_dir);
1220         }
1221     }
1222
1223     $type = filetype($file_or_dir);
1224     if ($type == 'link') {
1225         // For symbolic links, use stat() to determine
1226         // the type of the underlying file.
1227         list(,,$mode) = stat($file_or_dir);
1228         $type = ($mode >> 12) & 017;
1229         if ($type == 010)
1230             $type = 'file';
1231         elseif ($type == 004)
1232             $type = 'dir';
1233     }
1234
1235     if (! $type) {
1236         $request->finish(fmt("Unable to load: %s", $file_or_dir));
1237     }
1238     else if ($type == 'dir') {
1239         LoadDir($request, $file_or_dir, $files, $exclude);
1240     }
1241     else if ($type != 'file' && !preg_match('/^(http|ftp):/', $file_or_dir))
1242     {
1243         $request->finish(fmt("Bad file type: %s", $type));
1244     }
1245     else if (IsZipFile($file_or_dir)) {
1246         LoadZip($request, $file_or_dir, $files, $exclude);
1247     }
1248     else /* if (!$files || in_array(basename($file_or_dir), $files)) */
1249     {
1250         LoadFile($request, $file_or_dir);
1251     }
1252 }
1253
1254 function LoadFileOrDir (&$request)
1255 {
1256     $source = $request->getArg('source');
1257     $finder = new FileFinder;
1258     $source = $finder->slashifyPath($source);
1259     $page = rawurldecode(basename($source));
1260     StartLoadDump($request, fmt("Loading '%s'",
1261         HTML(dirname($source),
1262              dirname($source) ? "/" : "",
1263              WikiLink($page,'auto'))));
1264     echo "<dl>\n";
1265     LoadAny($request, $source);
1266     echo "</dl>\n";
1267     EndLoadDump($request);
1268 }
1269
1270 /**
1271  * HomePage was not found so first-time install is supposed to run.
1272  * - import all pgsrc pages.
1273  * - Todo: installer interface to edit config/config.ini settings
1274  * - Todo: ask for existing old index.php to convert to config/config.ini
1275  * - Todo: theme-specific pages:
1276  *   blog - HomePage, ADMIN_USER/Blogs
1277  */
1278 function SetupWiki (&$request)
1279 {
1280     global $GenericPages, $LANG;
1281
1282     //FIXME: This is a hack (err, "interim solution")
1283     // This is a bogo-bogo-login:  Login without
1284     // saving login information in session state.
1285     // This avoids logging in the unsuspecting
1286     // visitor as "The PhpWiki programming team".
1287     //
1288     // This really needs to be cleaned up...
1289     // (I'm working on it.)
1290     $real_user = $request->_user;
1291     if (ENABLE_USER_NEW)
1292         $request->_user = new _BogoUser(_("The PhpWiki programming team"));
1293
1294     else
1295         $request->_user = new WikiUser($request, _("The PhpWiki programming team"),
1296                                        WIKIAUTH_BOGO);
1297
1298     StartLoadDump($request, _("Loading up virgin wiki"));
1299     echo "<dl>\n";
1300
1301     $pgsrc = FindLocalizedFile(WIKI_PGSRC);
1302     $default_pgsrc = FindFile(DEFAULT_WIKI_PGSRC);
1303
1304     $request->setArg('overwrite', true);
1305     if ($default_pgsrc != $pgsrc) {
1306         LoadAny($request, $default_pgsrc, $GenericPages);
1307     }
1308     $request->setArg('overwrite', false);
1309     LoadAny($request, $pgsrc);
1310     $dbi =& $request->_dbi;
1311
1312     // Ensure that all mandatory pages are loaded
1313     $finder = new FileFinder;
1314     foreach (array_merge(explode(':','Help/OldTextFormattingRules:Help/TextFormattingRules:PhpWikiAdministration'),
1315                          $GLOBALS['AllActionPages'],
1316                          array(constant('HOME_PAGE'))) as $f)
1317     {
1318         $page = gettext($f);
1319         $epage = urlencode($page);
1320         if (! $dbi->isWikiPage($page) ) {
1321             // translated version provided?
1322             if ($lf = FindLocalizedFile($pgsrc . $finder->_pathsep . $epage, 1)) {
1323                 LoadAny($request, $lf);
1324             } else { // load english version of required action page
1325                 LoadAny($request, FindFile(DEFAULT_WIKI_PGSRC . $finder->_pathsep . urlencode($f)));
1326                 $page = $f;
1327             }
1328         }
1329         if (! $dbi->isWikiPage($page)) {
1330             trigger_error(sprintf("Mandatory file %s couldn't be loaded!", $page),
1331                           E_USER_WARNING);
1332         }
1333     }
1334
1335     echo "</dl>\n";
1336     EndLoadDump($request);
1337 }
1338
1339 function LoadPostFile (&$request)
1340 {
1341     $upload = $request->getUploadedFile('file');
1342
1343     if (!$upload)
1344         $request->finish(_("No uploaded file to upload?")); // FIXME: more concise message
1345
1346
1347     // Dump http headers.
1348     StartLoadDump($request, sprintf(_("Uploading %s"), $upload->getName()));
1349     echo "<dl>\n";
1350
1351     $fd = $upload->open();
1352     if (IsZipFile($fd))
1353         LoadZip($request, $fd, false, array(_("RecentChanges")));
1354     else
1355         LoadFile($request, $upload->getName(), $upload->getContents());
1356
1357     echo "</dl>\n";
1358     EndLoadDump($request);
1359 }
1360
1361 /**
1362  $Log: not supported by cvs2svn $
1363  Revision 1.141  2006/03/19 17:11:32  rurban
1364  add verify to RevertPage, display reverted page as template
1365
1366  Revision 1.140  2006/03/07 20:45:43  rurban
1367  wikihash for php-5.1
1368
1369  Revision 1.139  2005/08/27 18:02:43  rurban
1370  fix and expand pages
1371
1372  Revision 1.138  2005/08/27 09:39:10  rurban
1373  dumphtml when not at admin page: dump the current or given page
1374
1375  Revision 1.137  2005/01/30 23:14:38  rurban
1376  simplify page names
1377
1378  Revision 1.136  2005/01/25 07:07:24  rurban
1379  remove body tags in html dumps, add css and images to zipdumps, simplify printing
1380
1381  Revision 1.135  2004/12/26 17:17:25  rurban
1382  announce dumps - mult.requests to avoid request::finish, e.g. LinkDatabase, PdfOut, ...
1383
1384  Revision 1.134  2004/12/20 16:05:01  rurban
1385  gettext msg unification
1386
1387  Revision 1.133  2004/12/08 12:57:41  rurban
1388  page-specific timeouts for long multi-page requests
1389
1390  Revision 1.132  2004/12/08 01:18:33  rurban
1391  Disallow loading config*.ini files. Detected by Santtu Jarvi.
1392
1393  Revision 1.131  2004/11/30 17:48:38  rurban
1394  just comments
1395
1396  Revision 1.130  2004/11/25 08:28:12  rurban
1397  dont fatal on missing css or imgfiles and actually print the miss
1398
1399  Revision 1.129  2004/11/25 08:11:40  rurban
1400  pass exclude to the get_all_pages backend
1401
1402  Revision 1.128  2004/11/16 16:16:44  rurban
1403  enable Overwrite All for upgrade
1404
1405  Revision 1.127  2004/11/01 10:43:57  rurban
1406  seperate PassUser methods into seperate dir (memory usage)
1407  fix WikiUser (old) overlarge data session
1408  remove wikidb arg from various page class methods, use global ->_dbi instead
1409  ...
1410
1411  Revision 1.126  2004/10/16 15:13:39  rurban
1412  new [Overwrite All] button
1413
1414  Revision 1.125  2004/10/14 19:19:33  rurban
1415  loadsave: check if the dumped file will be accessible from outside.
1416  and some other minor fixes. (cvsclient native not yet ready)
1417
1418  Revision 1.124  2004/10/04 23:44:28  rurban
1419  for older or CGI phps
1420
1421  Revision 1.123  2004/09/25 16:26:54  rurban
1422  deferr notifies (to be improved)
1423
1424  Revision 1.122  2004/09/17 14:25:45  rurban
1425  update comments
1426
1427  Revision 1.121  2004/09/08 13:38:00  rurban
1428  improve loadfile stability by using markup=2 as default for undefined markup-style.
1429  use more refs for huge objects.
1430  fix debug=static issue in WikiPluginCached
1431
1432  Revision 1.120  2004/07/08 19:04:42  rurban
1433  more unittest fixes (file backend, metadata RatingsDb)
1434
1435  Revision 1.119  2004/07/08 15:23:59  rurban
1436  less verbose for tests
1437
1438  Revision 1.118  2004/07/08 13:50:32  rurban
1439  various unit test fixes: print error backtrace on _DEBUG_TRACE; allusers fix; new PHPWIKI_NOMAIN constant for omitting the mainloop
1440
1441  Revision 1.117  2004/07/02 09:55:58  rurban
1442  more stability fixes: new DISABLE_GETIMAGESIZE if your php crashes when loading LinkIcons: failing getimagesize in old phps; blockparser stabilized
1443
1444  Revision 1.116  2004/07/01 09:05:41  rurban
1445  support pages and exclude arguments for all 4 dump methods
1446
1447  Revision 1.115  2004/07/01 08:51:22  rurban
1448  dumphtml: added exclude, print pagename before processing
1449
1450  Revision 1.114  2004/06/28 12:51:41  rurban
1451  improved dumphtml and virgin setup
1452
1453  Revision 1.113  2004/06/27 10:26:02  rurban
1454  oci8 patch by Philippe Vanhaesendonck + some ADODB notes+fixes
1455
1456  Revision 1.112  2004/06/25 14:29:20  rurban
1457  WikiGroup refactoring:
1458    global group attached to user, code for not_current user.
1459    improved helpers for special groups (avoid double invocations)
1460  new experimental config option ENABLE_XHTML_XML (fails with IE, and document.write())
1461  fixed a XHTML validation error on userprefs.tmpl
1462
1463  Revision 1.111  2004/06/21 16:38:55  rurban
1464  fixed the StartLoadDump html argument hack.
1465
1466  Revision 1.110  2004/06/21 16:22:30  rurban
1467  add DEFAULT_DUMP_DIR and HTML_DUMP_DIR constants, for easier cmdline dumps,
1468  fixed dumping buttons locally (images/buttons/),
1469  support pages arg for dumphtml,
1470  optional directory arg for dumpserial + dumphtml,
1471  fix a AllPages warning,
1472  show dump warnings/errors on DEBUG,
1473  don't warn just ignore on wikilens pagelist columns, if not loaded.
1474  RateIt pagelist column is called "rating", not "ratingwidget" (Dan?)
1475
1476  Revision 1.109  2004/06/17 11:31:05  rurban
1477  jump back to label after dump/upgrade
1478
1479  Revision 1.108  2004/06/16 12:43:01  rurban
1480  4.0.6 cannot use this errorhandler (not found)
1481
1482  Revision 1.107  2004/06/14 11:31:37  rurban
1483  renamed global $Theme to $WikiTheme (gforge nameclash)
1484  inherit PageList default options from PageList
1485    default sortby=pagename
1486  use options in PageList_Selectable (limit, sortby, ...)
1487  added action revert, with button at action=diff
1488  added option regex to WikiAdminSearchReplace
1489
1490  Revision 1.106  2004/06/13 13:54:25  rurban
1491  Catch fatals on the four dump calls (as file and zip, as html and mimified)
1492  FoafViewer: Check against external requirements, instead of fatal.
1493  Change output for xhtmldumps: using file:// urls to the local fs.
1494  Catch SOAP fatal by checking for GOOGLE_LICENSE_KEY
1495  Import GOOGLE_LICENSE_KEY and FORTUNE_DIR from config.ini.
1496
1497  Revision 1.105  2004/06/08 19:48:16  rurban
1498  fixed foreign setup: no ugly skipped msg for the GenericPages, load english actionpages if translated not found
1499
1500  Revision 1.104  2004/06/08 13:51:57  rurban
1501  some comments only
1502
1503  Revision 1.103  2004/06/08 10:54:46  rurban
1504  better acl dump representation, read back acl and owner
1505
1506  Revision 1.102  2004/06/06 16:58:51  rurban
1507  added more required ActionPages for foreign languages
1508  install now english ActionPages if no localized are found. (again)
1509  fixed default anon user level to be 0, instead of -1
1510    (wrong "required administrator to view this page"...)
1511
1512  Revision 1.101  2004/06/04 20:32:53  rurban
1513  Several locale related improvements suggested by Pierrick Meignen
1514  LDAP fix by John Cole
1515  reenable admin check without ENABLE_PAGEPERM in the admin plugins
1516
1517  Revision 1.100  2004/05/02 21:26:38  rurban
1518  limit user session data (HomePageHandle and auth_dbi have to invalidated anyway)
1519    because they will not survive db sessions, if too large.
1520  extended action=upgrade
1521  some WikiTranslation button work
1522  revert WIKIAUTH_UNOBTAINABLE (need it for main.php)
1523  some temp. session debug statements
1524
1525  Revision 1.99  2004/05/02 15:10:07  rurban
1526  new finally reliable way to detect if /index.php is called directly
1527    and if to include lib/main.php
1528  new global AllActionPages
1529  SetupWiki now loads all mandatory pages: HOME_PAGE, action pages, and warns if not.
1530  WikiTranslation what=buttons for Carsten to create the missing MacOSX buttons
1531  PageGroupTestOne => subpages
1532  renamed PhpWikiRss to PhpWikiRecentChanges
1533  more docs, default configs, ...
1534
1535  Revision 1.98  2004/04/29 23:25:12  rurban
1536  re-ordered locale init (as in 1.3.9)
1537  fixed loadfile with subpages, and merge/restore anyway
1538    (sf.net bug #844188)
1539
1540  Revision 1.96  2004/04/19 23:13:03  zorloc
1541  Connect the rest of PhpWiki to the IniConfig system.  Also the keyword regular expression is not a config setting
1542
1543  Revision 1.95  2004/04/18 01:11:52  rurban
1544  more numeric pagename fixes.
1545  fixed action=upload with merge conflict warnings.
1546  charset changed from constant to global (dynamic utf-8 switching)
1547
1548  Revision 1.94  2004/03/14 16:36:37  rurban
1549  dont load backup files
1550
1551  Revision 1.93  2004/02/26 03:22:05  rurban
1552  also copy css and images with XHTML Dump
1553
1554  Revision 1.92  2004/02/26 02:25:54  rurban
1555  fix empty and #-anchored links in XHTML Dumps
1556
1557  Revision 1.91  2004/02/24 17:19:37  rurban
1558  debugging helpers only
1559
1560  Revision 1.90  2004/02/24 17:09:24  rurban
1561  fixed \r\r\n with dumping on windows
1562
1563  Revision 1.88  2004/02/22 23:20:31  rurban
1564  fixed DumpHtmlToDir,
1565  enhanced sortby handling in PageList
1566    new button_heading th style (enabled),
1567  added sortby and limit support to the db backends and plugins
1568    for paging support (<<prev, next>> links on long lists)
1569
1570  Revision 1.87  2004/01/26 09:17:49  rurban
1571  * changed stored pref representation as before.
1572    the array of objects is 1) bigger and 2)
1573    less portable. If we would import packed pref
1574    objects and the object definition was changed, PHP would fail.
1575    This doesn't happen with an simple array of non-default values.
1576  * use $prefs->retrieve and $prefs->store methods, where retrieve
1577    understands the interim format of array of objects also.
1578  * simplified $prefs->get() and fixed $prefs->set()
1579  * added $user->_userid and class '_WikiUser' portability functions
1580  * fixed $user object ->_level upgrading, mostly using sessions.
1581    this fixes yesterdays problems with loosing authorization level.
1582  * fixed WikiUserNew::checkPass to return the _level
1583  * fixed WikiUserNew::isSignedIn
1584  * added explodePageList to class PageList, support sortby arg
1585  * fixed UserPreferences for WikiUserNew
1586  * fixed WikiPlugin for empty defaults array
1587  * UnfoldSubpages: added pagename arg, renamed pages arg,
1588    removed sort arg, support sortby arg
1589
1590  Revision 1.86  2003/12/02 16:18:26  carstenklapp
1591  Minor enhancement: Provide more meaningful filenames for WikiDB zip
1592  dumps & snapshots.
1593
1594  Revision 1.85  2003/11/30 18:18:13  carstenklapp
1595  Minor code optimization: use include_once instead of require_once
1596  inside functions that might not always called.
1597
1598  Revision 1.84  2003/11/26 20:47:47  carstenklapp
1599  Redo bugfix: My last refactoring broke merge-edit & overwrite
1600  functionality again, should be fixed now. Sorry.
1601
1602  Revision 1.83  2003/11/20 22:18:54  carstenklapp
1603  New feature: h1 during merge-edit displays WikiLink to original page.
1604  Internal changes: Replaced some hackish url-generation code in
1605  function SavePage (for pgsrc merge-edit) with appropriate Button()
1606  calls.
1607
1608  Revision 1.82  2003/11/18 19:48:01  carstenklapp
1609  Fixed missing gettext _() for button name.
1610
1611  Revision 1.81  2003/11/18 18:28:35  carstenklapp
1612  Bugfix: In the Load File function of PhpWikiAdministration: When doing
1613  a "Merge Edit" or "Restore Anyway", page names containing accented
1614  letters (such as locale/de/pgsrc/G%E4steBuch) would produce a file not
1615  found error (Use FilenameForPage funtion to urlencode page names).
1616
1617  Revision 1.80  2003/03/07 02:46:57  dairiki
1618  Omit checks for safe_mode before set_time_limit().  Just prefix the
1619  set_time_limit() calls with @ so that they fail silently if not
1620  supported.
1621
1622  Revision 1.79  2003/02/26 01:56:05  dairiki
1623  Only zip pages with legal pagenames.
1624
1625  Revision 1.78  2003/02/24 02:05:43  dairiki
1626  Fix "n bytes written" message when dumping HTML.
1627
1628  Revision 1.77  2003/02/21 04:12:05  dairiki
1629  Minor fixes for new cached markup.
1630
1631  Revision 1.76  2003/02/16 19:47:17  dairiki
1632  Update WikiDB timestamp when editing or deleting pages.
1633
1634  Revision 1.75  2003/02/15 03:04:30  dairiki
1635  Fix for WikiUser constructor API change.
1636
1637  Revision 1.74  2003/02/15 02:18:04  dairiki
1638  When default language was English (at least), pgsrc was being
1639  loaded twice.
1640
1641  LimitedFileSet: Fix typo/bug. ($include was being ignored.)
1642
1643  SetupWiki(): Fix bugs in loading of $GenericPages.
1644
1645  Revision 1.73  2003/01/28 21:09:17  zorloc
1646  The get_cfg_var() function should only be used when one is
1647  interested in the value from php.ini or similar. Use ini_get()
1648  instead to get the effective value of a configuration variable.
1649  -- Martin Geisler
1650
1651  Revision 1.72  2003/01/03 22:25:53  carstenklapp
1652  Cosmetic fix to "Merge Edit" & "Overwrite" buttons. Added "The PhpWiki
1653  programming team" as author when loading from pgsrc. Source
1654  reformatting.
1655
1656  Revision 1.71  2003/01/03 02:48:05  carstenklapp
1657  function SavePage: Added loadfile options for overwriting or merge &
1658  compare a loaded pgsrc file with an existing page.
1659
1660  function LoadAny: Added a general error message when unable to load a
1661  file instead of defaulting to "Bad file type".
1662
1663  */
1664
1665 // For emacs users
1666 // Local Variables:
1667 // mode: php
1668 // tab-width: 8
1669 // c-basic-offset: 4
1670 // c-hanging-comment-ender-p: nil
1671 // indent-tabs-mode: nil
1672 // End:
1673 ?>