lib/loadsave.php

   1 <?php //-*-php-*-
   2 rcs_id('$Id: loadsave.php,v 1.95 2004-04-18 01:11:52 rurban Exp $');
   3
   4 /*
   5  Copyright 1999, 2000, 2001, 2002 $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 function StartLoadDump(&$request, $title, $html = '')
  29 {
  30     // FIXME: This is a hack
  31     $tmpl = Template('html', array('TITLE' => $title,
  32                                   'HEADER' => $title,
  33                                   'CONTENT' => '%BODY%'));
  34     echo ereg_replace('%BODY%.*', '', $tmpl->getExpansion($html));
  35 }
  36
  37 function EndLoadDump(&$request)
  38 {
  39     // FIXME: This is a hack
  40     $pagelink = WikiLink($request->getPage());
  41
  42     PrintXML(HTML::p(HTML::strong(_("Complete."))),
  43              HTML::p(fmt("Return to %s", $pagelink)));
  44     echo "</body></html>\n";
  45 }
  46
  47
  48 ////////////////////////////////////////////////////////////////
  49 //
  50 //  Functions for dumping.
  51 //
  52 ////////////////////////////////////////////////////////////////
  53
  54 /**
  55  * For reference see:
  56  * http://www.nacs.uci.edu/indiv/ehood/MIME/2045/rfc2045.html
  57  * http://www.faqs.org/rfcs/rfc2045.html
  58  * (RFC 1521 has been superceeded by RFC 2045 & others).
  59  *
  60  * Also see http://www.faqs.org/rfcs/rfc2822.html
  61  */
  62 function MailifyPage ($page, $nversions = 1)
  63 {
  64     $current = $page->getCurrentRevision();
  65     $head = '';
  66
  67     if (STRICT_MAILABLE_PAGEDUMPS) {
  68         $from = defined('SERVER_ADMIN') ? SERVER_ADMIN : 'foo@bar';
  69         //This is for unix mailbox format: (not RFC (2)822)
  70         // $head .= "From $from  " . CTime(time()) . "\r\n";
  71         $head .= "Subject: " . rawurlencode($page->getName()) . "\r\n";
  72         $head .= "From: $from (PhpWiki)\r\n";
  73         // RFC 2822 requires only a Date: and originator (From:)
  74         // field, however the obsolete standard RFC 822 also
  75         // requires a destination field.
  76         $head .= "To: $from (PhpWiki)\r\n";
  77     }
  78     $head .= "Date: " . Rfc2822DateTime($current->get('mtime')) . "\r\n";
  79     $head .= sprintf("Mime-Version: 1.0 (Produced by PhpWiki %s)\r\n",
  80                      PHPWIKI_VERSION);
  81
  82     // This should just be entered by hand (or by script?)
  83     // in the actual pgsrc files, since only they should have
  84     // RCS ids.
  85     //$head .= "X-Rcs-Id: \$Id\$\r\n";
  86
  87     $iter = $page->getAllRevisions();
  88     $parts = array();
  89     while ($revision = $iter->next()) {
  90         $parts[] = MimeifyPageRevision($revision);
  91         if ($nversions > 0 && count($parts) >= $nversions)
  92             break;
  93     }
  94     if (count($parts) > 1)
  95         return $head . MimeMultipart($parts);
  96     assert($parts);
  97     return $head . $parts[0];
  98 }
  99
 100 /***
 101  * Compute filename to used for storing contents of a wiki page.
 102  *
 103  * Basically we do a rawurlencode() which encodes everything except
 104  * ASCII alphanumerics and '.', '-', and '_'.
 105  *
 106  * But we also want to encode leading dots to avoid filenames like
 107  * '.', and '..'. (Also, there's no point in generating "hidden" file
 108  * names, like '.foo'.)
 109  *
 110  * @param $pagename string Pagename.
 111  * @return string Filename for page.
 112  */
 113 function FilenameForPage ($pagename)
 114 {
 115     $enc = rawurlencode($pagename);
 116     return preg_replace('/^\./', '%2e', $enc);
 117 }
 118
 119 /**
 120  * The main() function which generates a zip archive of a PhpWiki.
 121  *
 122  * If $include_archive is false, only the current version of each page
 123  * is included in the zip file; otherwise all archived versions are
 124  * included as well.
 125  */
 126 function MakeWikiZip (&$request)
 127 {
 128     if ($request->getArg('include') == 'all') {
 129         $zipname         = WIKI_NAME . _("FullDump") . date('Ymd-Hi') . '.zip';
 130         $include_archive = true;
 131     }
 132     else {
 133         $zipname         = WIKI_NAME . _("LatestSnapshot") . date('Ymd-Hi') . '.zip';
 134         $include_archive = false;
 135     }
 136
 137
 138
 139     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
 140
 141     $dbi = $request->getDbh();
 142     $pages = $dbi->getAllPages();
 143     while ($page = $pages->next()) {
 144         if (! $request->getArg('start_debug'))
 145             @set_time_limit(30); // Reset watchdog
 146
 147         $current = $page->getCurrentRevision();
 148         if ($current->getVersion() == 0)
 149             continue;
 150
 151         $wpn = new WikiPageName($page->getName());
 152         if (!$wpn->isValid())
 153             continue;
 154
 155         $attrib = array('mtime'    => $current->get('mtime'),
 156                         'is_ascii' => 1);
 157         if ($page->get('locked'))
 158             $attrib['write_protected'] = 1;
 159
 160         if ($include_archive)
 161             $content = MailifyPage($page, 0);
 162         else
 163             $content = MailifyPage($page);
 164
 165         $zip->addRegularFile( FilenameForPage($page->getName()),
 166                               $content, $attrib);
 167     }
 168     $zip->finish();
 169 }
 170
 171 function DumpToDir (&$request)
 172 {
 173     $directory = $request->getArg('directory');
 174     if (empty($directory))
 175         $request->finish(_("You must specify a directory to dump to"));
 176
 177     // see if we can access the directory the user wants us to use
 178     if (! file_exists($directory)) {
 179         if (! mkdir($directory, 0755))
 180             $request->finish(fmt("Cannot create directory '%s'", $directory));
 181         else
 182             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
 183                                 $directory));
 184     } else {
 185         $html = HTML::p(fmt("Using directory '%s'", $directory));
 186     }
 187
 188     StartLoadDump($request, _("Dumping Pages"), $html);
 189
 190     $dbi = $request->getDbh();
 191     $pages = $dbi->getAllPages();
 192
 193     while ($page = $pages->next()) {
 194         if (! $request->getArg('start_debug'))
 195           @set_time_limit(30); // Reset watchdog.
 196
 197         $filename = FilenameForPage($page->getName());
 198
 199         $msg = HTML(HTML::br(), $page->getName(), ' ... ');
 200
 201         if($page->getName() != $filename) {
 202             $msg->pushContent(HTML::small(fmt("saved as %s", $filename)),
 203                               " ... ");
 204         }
 205
 206         if ($request->getArg('include') == 'all')
 207             $data = MailifyPage($page, 0);
 208         else
 209             $data = MailifyPage($page);
 210
 211         if ( !($fd = fopen("$directory/$filename", "wb")) ) {
 212             $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
 213                                                "$directory/$filename")));
 214             $request->finish($msg);
 215         }
 216
 217         $num = fwrite($fd, $data, strlen($data));
 218         $msg->pushContent(HTML::small(fmt("%s bytes written", $num)));
 219         PrintXML($msg);
 220
 221         flush();
 222         assert($num == strlen($data));
 223         fclose($fd);
 224     }
 225
 226     EndLoadDump($request);
 227 }
 228
 229
 230 function DumpHtmlToDir (&$request)
 231 {
 232     $directory = $request->getArg('directory');
 233     if (empty($directory))
 234         $request->finish(_("You must specify a directory to dump to"));
 235
 236     // see if we can access the directory the user wants us to use
 237     if (! file_exists($directory)) {
 238         if (! mkdir($directory, 0755))
 239             $request->finish(fmt("Cannot create directory '%s'", $directory));
 240         else
 241             $html = HTML::p(fmt("Created directory '%s' for the page dump...",
 242                                 $directory));
 243     } else {
 244         $html = HTML::p(fmt("Using directory '%s'", $directory));
 245     }
 246
 247     StartLoadDump($request, _("Dumping Pages"), $html);
 248     $thispage = $request->getArg('pagename'); // for "Return to ..."
 249
 250     $dbi = $request->getDbh();
 251     $pages = $dbi->getAllPages();
 252
 253     global $HTML_DUMP_SUFFIX, $Theme;
 254     if ($HTML_DUMP_SUFFIX)
 255         $Theme->HTML_DUMP_SUFFIX = $HTML_DUMP_SUFFIX;
 256     $Theme->DUMP_MODE = 'HTML';
 257
 258     while ($page = $pages->next()) {
 259         if (! $request->getArg('start_debug'))
 260           @set_time_limit(30); // Reset watchdog.
 261
 262         $pagename = $page->getName();
 263         $request->setArg('pagename',$pagename); // Template::_basepage fix
 264         $filename = FilenameForPage($pagename) . $Theme->HTML_DUMP_SUFFIX;
 265
 266         $msg = HTML(HTML::br(), $pagename, ' ... ');
 267
 268         if($page->getName() != $filename) {
 269             $msg->pushContent(HTML::small(fmt("saved as %s", $filename)),
 270                               " ... ");
 271         }
 272
 273         $revision = $page->getCurrentRevision();
 274         $transformedContent = $revision->getTransformedContent();
 275         $template = new Template('browse', $request,
 276                                  array('revision' => $revision,
 277                                        'CONTENT' => $transformedContent));
 278
 279         $data = GeneratePageasXML($template, $pagename);
 280
 281         if ( !($fd = fopen("$directory/$filename", "wb")) ) {
 282             $msg->pushContent(HTML::strong(fmt("couldn't open file '%s' for writing",
 283                                                "$directory/$filename")));
 284             $request->finish($msg);
 285         }
 286
 287         $num = fwrite($fd, $data, strlen($data));
 288         $msg->pushContent(HTML::small(fmt("%s bytes written", $num), "\n"));
 289         PrintXML($msg);
 290
 291         flush();
 292         assert($num == strlen($data));
 293         fclose($fd);
 294     }
 295
 296     if (is_array($Theme->dumped_images)) {
 297         @mkdir("$directory/images");
 298         foreach ($Theme->dumped_images as $img_file) {
 299             if (($from = $Theme->_findFile($img_file)) and basename($from)) {
 300                 $target = "$directory/images/".basename($img_file);
 301                 if (copy($Theme->_path . $from, $target)) {
 302                     $msg = HTML(HTML::br(), HTML($from), HTML::small(fmt("... copied to %s", $target)));
 303                     PrintXML($msg);
 304                 }
 305             } else {
 306                 $msg = HTML(HTML::br(), HTML($from), HTML::small(fmt("... not found", $target)));
 307                 PrintXML($msg);
 308             }
 309         }
 310     }
 311     if (is_array($Theme->dumped_css)) {
 312       foreach ($Theme->dumped_css as $css_file) {
 313           if (($from = $Theme->_findFile(basename($css_file))) and basename($from)) {
 314               $target = "$directory/" . basename($css_file);
 315               if (copy($Theme->_path . $from, $target)) {
 316                   $msg = HTML(HTML::br(), HTML($from), HTML::small(fmt("... copied to %s", $target)));
 317                   PrintXML($msg);
 318               }
 319           } else {
 320               $msg = HTML(HTML::br(), HTML($from), HTML::small(fmt("... not found", $target)));
 321               PrintXML($msg);
 322           }
 323       }
 324     }
 325     $Theme->HTML_DUMP_SUFFIX = '';
 326     $Theme->DUMP_MODE = false;
 327
 328     $request->setArg('pagename',$thispage); // Template::_basepage fix
 329     EndLoadDump($request);
 330 }
 331
 332 /* Known problem: any plugins or other code which echo()s text will
 333  * lead to a corrupted html zip file which may produce the following
 334  * errors upon unzipping:
 335  *
 336  * warning [wikihtml.zip]:  2401 extra bytes at beginning or within zipfile
 337  * file #58:  bad zipfile offset (local header sig):  177561
 338  *  (attempting to re-compensate)
 339  *
 340  * However, the actual wiki page data should be unaffected.
 341  */
 342 function MakeWikiZipHtml (&$request)
 343 {
 344     $zipname = "wikihtml.zip";
 345     $zip = new ZipWriter("Created by PhpWiki " . PHPWIKI_VERSION, $zipname);
 346     $dbi = $request->getDbh();
 347     $pages = $dbi->getAllPages();
 348
 349     global $HTML_DUMP_SUFFIX, $Theme;
 350     if ($HTML_DUMP_SUFFIX)
 351         $Theme->HTML_DUMP_SUFFIX = $HTML_DUMP_SUFFIX;
 352
 353     while ($page = $pages->next()) {
 354         if (! $request->getArg('start_debug'))
 355             @set_time_limit(30); // Reset watchdog.
 356
 357         $current = $page->getCurrentRevision();
 358         if ($current->getVersion() == 0)
 359             continue;
 360
 361         $attrib = array('mtime'    => $current->get('mtime'),
 362                         'is_ascii' => 1);
 363         if ($page->get('locked'))
 364             $attrib['write_protected'] = 1;
 365
 366         $pagename = $page->getName();
 367         $request->setArg('pagename',$pagename); // Template::_basepage fix
 368         $filename = FilenameForPage($pagename) . $Theme->HTML_DUMP_SUFFIX;
 369         $revision = $page->getCurrentRevision();
 370
 371         $transformedContent = $revision->getTransformedContent();
 372
 373         $template = new Template('browse', $request,
 374                                  array('revision' => $revision,
 375                                        'CONTENT' => $transformedContent));
 376
 377         $data = GeneratePageasXML($template, $pagename);
 378
 379         $zip->addRegularFile( $filename, $data, $attrib);
 380     }
 381     // FIXME: Deal with images here.
 382     $zip->finish();
 383     $Theme->$HTML_DUMP_SUFFIX = '';
 384 }
 385
 386
 387 ////////////////////////////////////////////////////////////////
 388 //
 389 //  Functions for restoring.
 390 //
 391 ////////////////////////////////////////////////////////////////
 392
 393 function SavePage (&$request, $pageinfo, $source, $filename)
 394 {
 395     $pagedata    = $pageinfo['pagedata'];    // Page level meta-data.
 396     $versiondata = $pageinfo['versiondata']; // Revision level meta-data.
 397
 398     if (empty($pageinfo['pagename'])) {
 399         PrintXML(HTML::dt(HTML::strong(_("Empty pagename!"))));
 400         return;
 401     }
 402
 403     if (empty($versiondata['author_id']))
 404         $versiondata['author_id'] = $versiondata['author'];
 405
 406     $pagename = $pageinfo['pagename'];
 407     $content  = $pageinfo['content'];
 408
 409     if ($pagename ==_("InterWikiMap"))
 410         $content = _tryinsertInterWikiMap($content);
 411
 412     $dbi = $request->getDbh();
 413     $page = $dbi->getPage($pagename);
 414
 415     $current = $page->getCurrentRevision();
 416     // Try to merge if updated pgsrc contents are different. This
 417     // whole thing is hackish
 418     //
 419     // TODO: try merge unless:
 420     // if (current contents = default contents && pgsrc_version >=
 421     // pgsrc_version) then just upgrade this pgsrc
 422     $needs_merge = false;
 423     $merging = false;
 424     $overwrite = false;
 425
 426     if ($request->getArg('merge')) {
 427         $merging = true;
 428     }
 429     else if ($request->getArg('overwrite')) {
 430         $overwrite = true;
 431     }
 432
 433     if ( (! $current->hasDefaultContents())
 434          && ($current->getPackedContent() != $content)
 435          && ($merging == true) ) {
 436         include_once('lib/editpage.php');
 437         $request->setArg('pagename', $pagename);
 438         $r = $current->getVersion();
 439         $request->setArg('revision', $current->getVersion());
 440         $p = new LoadFileConflictPageEditor($request);
 441         $p->_content = $content;
 442         $p->_currentVersion = $r - 1;
 443         $p->editPage($saveFailed = true);
 444         return; //early return
 445     }
 446
 447     foreach ($pagedata as $key => $value) {
 448         if (!empty($value))
 449             $page->set($key, $value);
 450     }
 451
 452     $mesg = HTML::dd();
 453     $skip = false;
 454     if ($source)
 455         $mesg->pushContent(' ', fmt("from %s", $source));
 456
 457
 458     $current = $page->getCurrentRevision();
 459     if ($current->getVersion() == 0) {
 460         $mesg->pushContent(' ', _("new page"));
 461         $isnew = true;
 462     }
 463     else {
 464         if ( (! $current->hasDefaultContents())
 465              && ($current->getPackedContent() != $content) ) {
 466             if ($overwrite) {
 467                 $mesg->pushContent(' ',
 468                                    fmt("has edit conflicts - overwriting anyway"));
 469                 $skip = false;
 470                 if (substr_count($source, 'pgsrc')) {
 471                     $versiondata['author'] = _("The PhpWiki programming team");
 472                     // but leave authorid as userid who loaded the file
 473                 }
 474             }
 475             else {
 476                 $mesg->pushContent(' ', fmt("has edit conflicts - skipped"));
 477                 $needs_merge = true; // hackish
 478                 $skip = true;
 479             }
 480         }
 481         else if ($current->getPackedContent() == $content
 482                  && $current->get('author') == $versiondata['author']) {
 483             $mesg->pushContent(' ',
 484                                fmt("is identical to current version %d - skipped",
 485                                    $current->getVersion()));
 486             $skip = true;
 487         }
 488         $isnew = false;
 489     }
 490
 491     if (! $skip) {
 492         $new = $page->save($content, WIKIDB_FORCE_CREATE, $versiondata);
 493         $dbi->touch();
 494         $mesg->pushContent(' ', fmt("- saved to database as version %d",
 495                                     $new->getVersion()));
 496     }
 497     if ($needs_merge) {
 498         $f = $source;
 499         // hackish, $source contains needed path+filename
 500         $f = str_replace(sprintf(_("MIME file %s"), ''), '', $f);
 501         $f = str_replace(sprintf(_("Serialized file %s"), ''), '', $f);
 502         $f = str_replace(sprintf(_("plain file %s"), ''), '', $f);
 503         //check if uploaded file? they pass just the content, but the file is gone
 504         if (@stat($f)) {
 505             global $Theme;
 506             $meb = Button(array('action' => 'loadfile',
 507                                 'merge'=> true,
 508                                 'source'=> $f),
 509                           _("Merge Edit"),
 510                           _("PhpWikiAdministration"),
 511                           'wikiadmin');
 512             $owb = Button(array('action' => 'loadfile',
 513                                 'overwrite'=> true,
 514                                 'source'=> $f),
 515                           _("Restore Anyway"),
 516                           _("PhpWikiAdministration"),
 517                           'wikiunsafe');
 518             $mesg->pushContent(' ', $meb, " ", $owb);
 519         } else {
 520             $mesg->pushContent(HTML::em(_(" Sorry, cannot merge uploaded files.")));
 521         }
 522     }
 523
 524     if ($skip)
 525         PrintXML(HTML::dt(HTML::em(WikiLink($pagename))), $mesg);
 526     else
 527         PrintXML(HTML::dt(WikiLink($pagename)), $mesg);
 528     flush();
 529 }
 530
 531 function _tryinsertInterWikiMap($content) {
 532     $goback = false;
 533     if (strpos($content, "<verbatim>")) {
 534         //$error_html = " The newly loaded pgsrc already contains a verbatim block.";
 535         $goback = true;
 536     }
 537     if (!$goback && !defined('INTERWIKI_MAP_FILE')) {
 538         $error_html = sprintf(" "._("%s: not defined"), "INTERWIKI_MAP_FILE");
 539         $goback = true;
 540     }
 541     if (!$goback && !file_exists(INTERWIKI_MAP_FILE)) {
 542         $error_html = sprintf(" "._("%s: file not found"), INTERWIKI_MAP_FILE);
 543         $goback = true;
 544     }
 545
 546     if (!empty($error_html))
 547         trigger_error(_("Default InterWiki map file not loaded.")
 548                       . $error_html, E_USER_NOTICE);
 549
 550     if ($goback)
 551         return $content;
 552
 553     $filename = INTERWIKI_MAP_FILE;
 554     trigger_error(sprintf(_("Loading InterWikiMap from external file %s."),
 555                           $filename), E_USER_NOTICE);
 556
 557     $fd = fopen ($filename, "rb");
 558     $data = fread ($fd, filesize($filename));
 559     fclose ($fd);
 560     $content = $content . "\n<verbatim>\n$data</verbatim>\n";
 561     return $content;
 562 }
 563
 564 function ParseSerializedPage($text, $default_pagename, $user)
 565 {
 566     if (!preg_match('/^a:\d+:{[si]:\d+/', $text))
 567         return false;
 568
 569     $pagehash = unserialize($text);
 570
 571     // Split up pagehash into four parts:
 572     //   pagename
 573     //   content
 574     //   page-level meta-data
 575     //   revision-level meta-data
 576
 577     if (!defined('FLAG_PAGE_LOCKED'))
 578         define('FLAG_PAGE_LOCKED', 1);
 579     $pageinfo = array('pagedata'    => array(),
 580                       'versiondata' => array());
 581
 582     $pagedata = &$pageinfo['pagedata'];
 583     $versiondata = &$pageinfo['versiondata'];
 584
 585     // Fill in defaults.
 586     if (empty($pagehash['pagename']))
 587         $pagehash['pagename'] = $default_pagename;
 588     if (empty($pagehash['author'])) {
 589         $pagehash['author'] = $user->getId();
 590     }
 591
 592     foreach ($pagehash as $key => $value) {
 593         switch($key) {
 594             case 'pagename':
 595             case 'version':
 596             case 'hits':
 597                 $pageinfo[$key] = $value;
 598                 break;
 599             case 'content':
 600                 $pageinfo[$key] = join("\n", $value);
 601                 break;
 602             case 'flags':
 603                 if (($value & FLAG_PAGE_LOCKED) != 0)
 604                     $pagedata['locked'] = 'yes';
 605                 break;
 606             case 'created':
 607                 $pagedata[$key] = $value;
 608                 break;
 609             case 'lastmodified':
 610                 $versiondata['mtime'] = $value;
 611                 break;
 612             case 'author':
 613             case 'author_id':
 614             case 'summary':
 615                 $versiondata[$key] = $value;
 616                 break;
 617         }
 618     }
 619     return $pageinfo;
 620 }
 621
 622 function SortByPageVersion ($a, $b) {
 623     return $a['version'] - $b['version'];
 624 }
 625
 626 function LoadFile (&$request, $filename, $text = false, $mtime = false)
 627 {
 628     if (!is_string($text)) {
 629         // Read the file.
 630         $stat  = stat($filename);
 631         $mtime = $stat[9];
 632         $text  = implode("", file($filename));
 633     }
 634
 635     if (! $request->getArg('start_debug'))
 636         @set_time_limit(30); // Reset watchdog.
 637
 638     // FIXME: basename("filewithnoslashes") seems to return garbage sometimes.
 639     $basename = basename("/dummy/" . $filename);
 640
 641     if (!$mtime)
 642         $mtime = time();    // Last resort.
 643
 644     $default_pagename = rawurldecode($basename);
 645
 646     if ( ($parts = ParseMimeifiedPages($text)) ) {
 647         usort($parts, 'SortByPageVersion');
 648         foreach ($parts as $pageinfo)
 649             SavePage($request, $pageinfo, sprintf(_("MIME file %s"),
 650                                                   $filename), $basename);
 651     }
 652     else if ( ($pageinfo = ParseSerializedPage($text, $default_pagename,
 653                                                $request->getUser())) ) {
 654         SavePage($request, $pageinfo, sprintf(_("Serialized file %s"),
 655                                               $filename), $basename);
 656     }
 657     else {
 658         $user = $request->getUser();
 659
 660         // Assume plain text file.
 661         $pageinfo = array('pagename' => $default_pagename,
 662                           'pagedata' => array(),
 663                           'versiondata'
 664                           => array('author' => $user->getId()),
 665                           'content'  => preg_replace('/[ \t\r]*\n/', "\n",
 666                                                      chop($text))
 667                           );
 668         SavePage($request, $pageinfo, sprintf(_("plain file %s"), $filename),
 669                  $basename);
 670     }
 671 }
 672
 673 function LoadZip (&$request, $zipfile, $files = false, $exclude = false) {
 674     $zip = new ZipReader($zipfile);
 675     while (list ($fn, $data, $attrib) = $zip->readFile()) {
 676         // FIXME: basename("filewithnoslashes") seems to return
 677         // garbage sometimes.
 678         $fn = basename("/dummy/" . $fn);
 679         if ( ($files && !in_array($fn, $files))
 680              || ($exclude && in_array($fn, $exclude)) ) {
 681             PrintXML(HTML::dt(WikiLink($fn)),
 682                      HTML::dd(_("Skipping")));
 683             continue;
 684         }
 685
 686         LoadFile($request, $fn, $data, $attrib['mtime']);
 687     }
 688 }
 689
 690 function LoadDir (&$request, $dirname, $files = false, $exclude = false) {
 691     $fileset = new LimitedFileSet($dirname, $files, $exclude);
 692
 693     if (($skiplist = $fileset->getSkippedFiles())) {
 694         PrintXML(HTML::dt(HTML::strong(_("Skipping"))));
 695         $list = HTML::ul();
 696         foreach ($skiplist as $file)
 697             $list->pushContent(HTML::li(WikiLink($file)));
 698         PrintXML(HTML::dd($list));
 699     }
 700
 701     // Defer HomePage loading until the end. If anything goes wrong
 702     // the pages can still be loaded again.
 703     $files = $fileset->getFiles();
 704     if (in_array(HOME_PAGE, $files)) {
 705         $files = array_diff($files, array(HOME_PAGE));
 706         $files[] = HOME_PAGE;
 707     }
 708     foreach ($files as $file) {
 709         if (substr($file,-1,1) != '~') // refuse to load backup files
 710             LoadFile($request, "$dirname/$file");
 711     }
 712 }
 713
 714 class LimitedFileSet extends FileSet {
 715     function LimitedFileSet($dirname, $_include, $exclude) {
 716         $this->_includefiles = $_include;
 717         $this->_exclude = $exclude;
 718         $this->_skiplist = array();
 719         parent::FileSet($dirname);
 720     }
 721
 722     function _filenameSelector($fn) {
 723         $incl = &$this->_includefiles;
 724         $excl = &$this->_exclude;
 725
 726         if ( ($incl && !in_array($fn, $incl))
 727              || ($excl && in_array($fn, $excl)) ) {
 728             $this->_skiplist[] = $fn;
 729             return false;
 730         } else {
 731             return true;
 732         }
 733     }
 734
 735     function getSkippedFiles () {
 736         return $this->_skiplist;
 737     }
 738 }
 739
 740
 741 function IsZipFile ($filename_or_fd)
 742 {
 743     // See if it looks like zip file
 744     if (is_string($filename_or_fd))
 745     {
 746         $fd    = fopen($filename_or_fd, "rb");
 747         $magic = fread($fd, 4);
 748         fclose($fd);
 749     }
 750     else
 751     {
 752         $fpos  = ftell($filename_or_fd);
 753         $magic = fread($filename_or_fd, 4);
 754         fseek($filename_or_fd, $fpos);
 755     }
 756
 757     return $magic == ZIP_LOCHEAD_MAGIC || $magic == ZIP_CENTHEAD_MAGIC;
 758 }
 759
 760
 761 function LoadAny (&$request, $file_or_dir, $files = false, $exclude = false)
 762 {
 763     // Try urlencoded filename for accented characters.
 764     if (!file_exists($file_or_dir)) {
 765         // Make sure there are slashes first to avoid confusing phps
 766         // with broken dirname or basename functions.
 767         // FIXME: windows uses \ and :
 768         if (is_integer(strpos($file_or_dir, "/"))) {
 769             $file_or_dir = FindFile($file_or_dir);
 770             // Panic
 771             if (!file_exists($file_or_dir))
 772                 $file_or_dir = dirname($file_or_dir) . "/"
 773                     . urlencode(basename($file_or_dir));
 774         } else {
 775             // This is probably just a file.
 776             $file_or_dir = urlencode($file_or_dir);
 777         }
 778     }
 779
 780     $type = filetype($file_or_dir);
 781     if ($type == 'link') {
 782         // For symbolic links, use stat() to determine
 783         // the type of the underlying file.
 784         list(,,$mode) = stat($file_or_dir);
 785         $type = ($mode >> 12) & 017;
 786         if ($type == 010)
 787             $type = 'file';
 788         elseif ($type == 004)
 789             $type = 'dir';
 790     }
 791
 792     if (! $type) {
 793         $request->finish(fmt("Unable to load: %s", $file_or_dir));
 794     }
 795     else if ($type == 'dir') {
 796         LoadDir($request, $file_or_dir, $files, $exclude);
 797     }
 798     else if ($type != 'file' && !preg_match('/^(http|ftp):/', $file_or_dir))
 799     {
 800         $request->finish(fmt("Bad file type: %s", $type));
 801     }
 802     else if (IsZipFile($file_or_dir)) {
 803         LoadZip($request, $file_or_dir, $files, $exclude);
 804     }
 805     else /* if (!$files || in_array(basename($file_or_dir), $files)) */
 806     {
 807         LoadFile($request, $file_or_dir);
 808     }
 809 }
 810
 811 function LoadFileOrDir (&$request)
 812 {
 813     $source = $request->getArg('source');
 814     StartLoadDump($request, fmt("Loading '%s'", HTML(dirname($source),
 815                                                      "/",
 816                                                      WikiLink(basename($source),
 817                                                               'auto'))));
 818     echo "<dl>\n";
 819     LoadAny($request, $source);
 820     echo "</dl>\n";
 821     EndLoadDump($request);
 822 }
 823
 824 function SetupWiki (&$request)
 825 {
 826     global $GenericPages, $LANG;
 827
 828
 829     //FIXME: This is a hack (err, "interim solution")
 830     // This is a bogo-bogo-login:  Login without
 831     // saving login information in session state.
 832     // This avoids logging in the unsuspecting
 833     // visitor as "The PhpWiki programming team".
 834     //
 835     // This really needs to be cleaned up...
 836     // (I'm working on it.)
 837     $real_user = $request->_user;
 838     if (ENABLE_USER_NEW)
 839         $request->_user = new _BogoUser(_("The PhpWiki programming team"));
 840
 841     else
 842         $request->_user = new WikiUser($request, _("The PhpWiki programming team"),
 843                                        WIKIAUTH_BOGO);
 844
 845     StartLoadDump($request, _("Loading up virgin wiki"));
 846     echo "<dl>\n";
 847
 848     $pgsrc = FindLocalizedFile(WIKI_PGSRC);
 849     $default_pgsrc = FindFile(DEFAULT_WIKI_PGSRC);
 850
 851     if ($default_pgsrc != $pgsrc)
 852         LoadAny($request, $default_pgsrc, $GenericPages);
 853
 854     LoadAny($request, $pgsrc);
 855
 856     echo "</dl>\n";
 857     EndLoadDump($request);
 858 }
 859
 860 function LoadPostFile (&$request)
 861 {
 862     $upload = $request->getUploadedFile('file');
 863
 864     if (!$upload)
 865         $request->finish(_("No uploaded file to upload?")); // FIXME: more concise message
 866
 867
 868     // Dump http headers.
 869     StartLoadDump($request, sprintf(_("Uploading %s"), $upload->getName()));
 870     echo "<dl>\n";
 871
 872     $fd = $upload->open();
 873     if (IsZipFile($fd))
 874         LoadZip($request, $fd, false, array(_("RecentChanges")));
 875     else
 876         LoadFile($request, $upload->getName(), $upload->getContents());
 877
 878     echo "</dl>\n";
 879     EndLoadDump($request);
 880 }
 881
 882 /**
 883  $Log: not supported by cvs2svn $
 884  Revision 1.94  2004/03/14 16:36:37  rurban
 885  dont load backup files
 886
 887  Revision 1.93  2004/02/26 03:22:05  rurban
 888  also copy css and images with XHTML Dump
 889
 890  Revision 1.92  2004/02/26 02:25:54  rurban
 891  fix empty and #-anchored links in XHTML Dumps
 892
 893  Revision 1.91  2004/02/24 17:19:37  rurban
 894  debugging helpers only
 895
 896  Revision 1.90  2004/02/24 17:09:24  rurban
 897  fixed \r\r\n with dumping on windows
 898
 899  Revision 1.88  2004/02/22 23:20:31  rurban
 900  fixed DumpHtmlToDir,
 901  enhanced sortby handling in PageList
 902    new button_heading th style (enabled),
 903  added sortby and limit support to the db backends and plugins
 904    for paging support (<<prev, next>> links on long lists)
 905
 906  Revision 1.87  2004/01/26 09:17:49  rurban
 907  * changed stored pref representation as before.
 908    the array of objects is 1) bigger and 2)
 909    less portable. If we would import packed pref
 910    objects and the object definition was changed, PHP would fail.
 911    This doesn't happen with an simple array of non-default values.
 912  * use $prefs->retrieve and $prefs->store methods, where retrieve
 913    understands the interim format of array of objects also.
 914  * simplified $prefs->get() and fixed $prefs->set()
 915  * added $user->_userid and class '_WikiUser' portability functions
 916  * fixed $user object ->_level upgrading, mostly using sessions.
 917    this fixes yesterdays problems with loosing authorization level.
 918  * fixed WikiUserNew::checkPass to return the _level
 919  * fixed WikiUserNew::isSignedIn
 920  * added explodePageList to class PageList, support sortby arg
 921  * fixed UserPreferences for WikiUserNew
 922  * fixed WikiPlugin for empty defaults array
 923  * UnfoldSubpages: added pagename arg, renamed pages arg,
 924    removed sort arg, support sortby arg
 925
 926  Revision 1.86  2003/12/02 16:18:26  carstenklapp
 927  Minor enhancement: Provide more meaningful filenames for WikiDB zip
 928  dumps & snapshots.
 929
 930  Revision 1.85  2003/11/30 18:18:13  carstenklapp
 931  Minor code optimization: use include_once instead of require_once
 932  inside functions that might not always called.
 933
 934  Revision 1.84  2003/11/26 20:47:47  carstenklapp
 935  Redo bugfix: My last refactoring broke merge-edit & overwrite
 936  functionality again, should be fixed now. Sorry.
 937
 938  Revision 1.83  2003/11/20 22:18:54  carstenklapp
 939  New feature: h1 during merge-edit displays WikiLink to original page.
 940  Internal changes: Replaced some hackish url-generation code in
 941  function SavePage (for pgsrc merge-edit) with appropriate Button()
 942  calls.
 943
 944  Revision 1.82  2003/11/18 19:48:01  carstenklapp
 945  Fixed missing gettext _() for button name.
 946
 947  Revision 1.81  2003/11/18 18:28:35  carstenklapp
 948  Bugfix: In the Load File function of PhpWikiAdministration: When doing
 949  a "Merge Edit" or "Restore Anyway", page names containing accented
 950  letters (such as locale/de/pgsrc/G%E4steBuch) would produce a file not
 951  found error (Use FilenameForPage funtion to urlencode page names).
 952
 953  Revision 1.80  2003/03/07 02:46:57  dairiki
 954  Omit checks for safe_mode before set_time_limit().  Just prefix the
 955  set_time_limit() calls with @ so that they fail silently if not
 956  supported.
 957
 958  Revision 1.79  2003/02/26 01:56:05  dairiki
 959  Only zip pages with legal pagenames.
 960
 961  Revision 1.78  2003/02/24 02:05:43  dairiki
 962  Fix "n bytes written" message when dumping HTML.
 963
 964  Revision 1.77  2003/02/21 04:12:05  dairiki
 965  Minor fixes for new cached markup.
 966
 967  Revision 1.76  2003/02/16 19:47:17  dairiki
 968  Update WikiDB timestamp when editing or deleting pages.
 969
 970  Revision 1.75  2003/02/15 03:04:30  dairiki
 971  Fix for WikiUser constructor API change.
 972
 973  Revision 1.74  2003/02/15 02:18:04  dairiki
 974  When default language was English (at least), pgsrc was being
 975  loaded twice.
 976
 977  LimitedFileSet: Fix typo/bug. ($include was being ignored.)
 978
 979  SetupWiki(): Fix bugs in loading of $GenericPages.
 980
 981  Revision 1.73  2003/01/28 21:09:17  zorloc
 982  The get_cfg_var() function should only be used when one is
 983  interested in the value from php.ini or similar. Use ini_get()
 984  instead to get the effective value of a configuration variable.
 985  -- Martin Geisler
 986
 987  Revision 1.72  2003/01/03 22:25:53  carstenklapp
 988  Cosmetic fix to "Merge Edit" & "Overwrite" buttons. Added "The PhpWiki
 989  programming team" as author when loading from pgsrc. Source
 990  reformatting.
 991
 992  Revision 1.71  2003/01/03 02:48:05  carstenklapp
 993  function SavePage: Added loadfile options for overwriting or merge &
 994  compare a loaded pgsrc file with an existing page.
 995
 996  function LoadAny: Added a general error message when unable to load a
 997  file instead of defaulting to "Bad file type".
 998
 999  */
1000
1001 // For emacs users
1002 // Local Variables:
1003 // mode: php
1004 // tab-width: 8
1005 // c-basic-offset: 4
1006 // c-hanging-comment-ender-p: nil
1007 // indent-tabs-mode: nil
1008 // End:
1009 ?>