lib/loadsave.php

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