lib/loadsave.php

   1 <?php //-*-php-*-
   2 rcs_id('$Id: loadsave.php,v 1.96 2004-04-19 23:13:03 zorloc 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 $Theme;
 254     if (defined('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 $Theme;
 350     if (defined('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.95  2004/04/18 01:11:52  rurban
 885  more numeric pagename fixes.
 886  fixed action=upload with merge conflict warnings.
 887  charset changed from constant to global (dynamic utf-8 switching)
 888
 889  Revision 1.94  2004/03/14 16:36:37  rurban
 890  dont load backup files
 891
 892  Revision 1.93  2004/02/26 03:22:05  rurban
 893  also copy css and images with XHTML Dump
 894
 895  Revision 1.92  2004/02/26 02:25:54  rurban
 896  fix empty and #-anchored links in XHTML Dumps
 897
 898  Revision 1.91  2004/02/24 17:19:37  rurban
 899  debugging helpers only
 900
 901  Revision 1.90  2004/02/24 17:09:24  rurban
 902  fixed \r\r\n with dumping on windows
 903
 904  Revision 1.88  2004/02/22 23:20:31  rurban
 905  fixed DumpHtmlToDir,
 906  enhanced sortby handling in PageList
 907    new button_heading th style (enabled),
 908  added sortby and limit support to the db backends and plugins
 909    for paging support (<<prev, next>> links on long lists)
 910
 911  Revision 1.87  2004/01/26 09:17:49  rurban
 912  * changed stored pref representation as before.
 913    the array of objects is 1) bigger and 2)
 914    less portable. If we would import packed pref
 915    objects and the object definition was changed, PHP would fail.
 916    This doesn't happen with an simple array of non-default values.
 917  * use $prefs->retrieve and $prefs->store methods, where retrieve
 918    understands the interim format of array of objects also.
 919  * simplified $prefs->get() and fixed $prefs->set()
 920  * added $user->_userid and class '_WikiUser' portability functions
 921  * fixed $user object ->_level upgrading, mostly using sessions.
 922    this fixes yesterdays problems with loosing authorization level.
 923  * fixed WikiUserNew::checkPass to return the _level
 924  * fixed WikiUserNew::isSignedIn
 925  * added explodePageList to class PageList, support sortby arg
 926  * fixed UserPreferences for WikiUserNew
 927  * fixed WikiPlugin for empty defaults array
 928  * UnfoldSubpages: added pagename arg, renamed pages arg,
 929    removed sort arg, support sortby arg
 930
 931  Revision 1.86  2003/12/02 16:18:26  carstenklapp
 932  Minor enhancement: Provide more meaningful filenames for WikiDB zip
 933  dumps & snapshots.
 934
 935  Revision 1.85  2003/11/30 18:18:13  carstenklapp
 936  Minor code optimization: use include_once instead of require_once
 937  inside functions that might not always called.
 938
 939  Revision 1.84  2003/11/26 20:47:47  carstenklapp
 940  Redo bugfix: My last refactoring broke merge-edit & overwrite
 941  functionality again, should be fixed now. Sorry.
 942
 943  Revision 1.83  2003/11/20 22:18:54  carstenklapp
 944  New feature: h1 during merge-edit displays WikiLink to original page.
 945  Internal changes: Replaced some hackish url-generation code in
 946  function SavePage (for pgsrc merge-edit) with appropriate Button()
 947  calls.
 948
 949  Revision 1.82  2003/11/18 19:48:01  carstenklapp
 950  Fixed missing gettext _() for button name.
 951
 952  Revision 1.81  2003/11/18 18:28:35  carstenklapp
 953  Bugfix: In the Load File function of PhpWikiAdministration: When doing
 954  a "Merge Edit" or "Restore Anyway", page names containing accented
 955  letters (such as locale/de/pgsrc/G%E4steBuch) would produce a file not
 956  found error (Use FilenameForPage funtion to urlencode page names).
 957
 958  Revision 1.80  2003/03/07 02:46:57  dairiki
 959  Omit checks for safe_mode before set_time_limit().  Just prefix the
 960  set_time_limit() calls with @ so that they fail silently if not
 961  supported.
 962
 963  Revision 1.79  2003/02/26 01:56:05  dairiki
 964  Only zip pages with legal pagenames.
 965
 966  Revision 1.78  2003/02/24 02:05:43  dairiki
 967  Fix "n bytes written" message when dumping HTML.
 968
 969  Revision 1.77  2003/02/21 04:12:05  dairiki
 970  Minor fixes for new cached markup.
 971
 972  Revision 1.76  2003/02/16 19:47:17  dairiki
 973  Update WikiDB timestamp when editing or deleting pages.
 974
 975  Revision 1.75  2003/02/15 03:04:30  dairiki
 976  Fix for WikiUser constructor API change.
 977
 978  Revision 1.74  2003/02/15 02:18:04  dairiki
 979  When default language was English (at least), pgsrc was being
 980  loaded twice.
 981
 982  LimitedFileSet: Fix typo/bug. ($include was being ignored.)
 983
 984  SetupWiki(): Fix bugs in loading of $GenericPages.
 985
 986  Revision 1.73  2003/01/28 21:09:17  zorloc
 987  The get_cfg_var() function should only be used when one is
 988  interested in the value from php.ini or similar. Use ini_get()
 989  instead to get the effective value of a configuration variable.
 990  -- Martin Geisler
 991
 992  Revision 1.72  2003/01/03 22:25:53  carstenklapp
 993  Cosmetic fix to "Merge Edit" & "Overwrite" buttons. Added "The PhpWiki
 994  programming team" as author when loading from pgsrc. Source
 995  reformatting.
 996
 997  Revision 1.71  2003/01/03 02:48:05  carstenklapp
 998  function SavePage: Added loadfile options for overwriting or merge &
 999  compare a loaded pgsrc file with an existing page.
1000
1001  function LoadAny: Added a general error message when unable to load a
1002  file instead of defaulting to "Bad file type".
1003
1004  */
1005
1006 // For emacs users
1007 // Local Variables:
1008 // mode: php
1009 // tab-width: 8
1010 // c-basic-offset: 4
1011 // c-hanging-comment-ender-p: nil
1012 // indent-tabs-mode: nil
1013 // End:
1014 ?>