includes/Import.php

   1 <?php
   2 /**
   3  * MediaWiki page data importer
   4  * Copyright (C) 2003,2005 Brion Vibber <brion@pobox.com>
   5  * http://www.mediawiki.org/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  * http://www.gnu.org/copyleft/gpl.html
  21  *
  22  * @file
  23  * @ingroup SpecialPage
  24  */
  25
  26 /**
  27  *
  28  * @ingroup SpecialPage
  29  */
  30 class WikiRevision {
  31         var $title = null;
  32         var $id = 0;
  33         var $timestamp = "20010115000000";
  34         var $user = 0;
  35         var $user_text = "";
  36         var $text = "";
  37         var $comment = "";
  38         var $minor = false;
  39         var $type = "";
  40         var $action = "";
  41         var $params = "";
  42
  43         function setTitle( $title ) {
  44                 if( is_object( $title ) ) {
  45                         $this->title = $title;
  46                 } elseif( is_null( $title ) ) {
  47                         throw new MWException( "WikiRevision given a null title in import. You may need to adjust \$wgLegalTitleChars." );
  48                 } else {
  49                         throw new MWException( "WikiRevision given non-object title in import." );
  50                 }
  51         }
  52
  53         function setID( $id ) {
  54                 $this->id = $id;
  55         }
  56
  57         function setTimestamp( $ts ) {
  58                 # 2003-08-05T18:30:02Z
  59                 $this->timestamp = wfTimestamp( TS_MW, $ts );
  60         }
  61
  62         function setUsername( $user ) {
  63                 $this->user_text = $user;
  64         }
  65
  66         function setUserIP( $ip ) {
  67                 $this->user_text = $ip;
  68         }
  69
  70         function setText( $text ) {
  71                 $this->text = $text;
  72         }
  73
  74         function setComment( $text ) {
  75                 $this->comment = $text;
  76         }
  77
  78         function setMinor( $minor ) {
  79                 $this->minor = (bool)$minor;
  80         }
  81
  82         function setSrc( $src ) {
  83                 $this->src = $src;
  84         }
  85
  86         function setFilename( $filename ) {
  87                 $this->filename = $filename;
  88         }
  89
  90         function setSize( $size ) {
  91                 $this->size = intval( $size );
  92         }
  93
  94         function setType( $type ) {
  95                 $this->type = $type;
  96         }
  97
  98         function setAction( $action ) {
  99                 $this->action = $action;
 100         }
 101
 102         function setParams( $params ) {
 103                 $this->params = $params;
 104         }
 105
 106         function getTitle() {
 107                 return $this->title;
 108         }
 109
 110         function getID() {
 111                 return $this->id;
 112         }
 113
 114         function getTimestamp() {
 115                 return $this->timestamp;
 116         }
 117
 118         function getUser() {
 119                 return $this->user_text;
 120         }
 121
 122         function getText() {
 123                 return $this->text;
 124         }
 125
 126         function getComment() {
 127                 return $this->comment;
 128         }
 129
 130         function getMinor() {
 131                 return $this->minor;
 132         }
 133
 134         function getSrc() {
 135                 return $this->src;
 136         }
 137
 138         function getFilename() {
 139                 return $this->filename;
 140         }
 141
 142         function getSize() {
 143                 return $this->size;
 144         }
 145
 146         function getType() {
 147                 return $this->type;
 148         }
 149
 150         function getAction() {
 151                 return $this->action;
 152         }
 153
 154         function getParams() {
 155                 return $this->params;
 156         }
 157
 158         function importOldRevision() {
 159                 $dbw = wfGetDB( DB_MASTER );
 160
 161                 # Sneak a single revision into place
 162                 $user = User::newFromName( $this->getUser() );
 163                 if( $user ) {
 164                         $userId = intval( $user->getId() );
 165                         $userText = $user->getName();
 166                 } else {
 167                         $userId = 0;
 168                         $userText = $this->getUser();
 169                 }
 170
 171                 // avoid memory leak...?
 172                 $linkCache = LinkCache::singleton();
 173                 $linkCache->clear();
 174
 175                 $article = new Article( $this->title );
 176                 $pageId = $article->getId();
 177                 if( $pageId == 0 ) {
 178                         # must create the page...
 179                         $pageId = $article->insertOn( $dbw );
 180                         $created = true;
 181                 } else {
 182                         $created = false;
 183
 184                         $prior = $dbw->selectField( 'revision', '1',
 185                                 array( 'rev_page' => $pageId,
 186                                         'rev_timestamp' => $dbw->timestamp( $this->timestamp ),
 187                                         'rev_user_text' => $userText,
 188                                         'rev_comment'   => $this->getComment() ),
 189                                 __METHOD__
 190                         );
 191                         if( $prior ) {
 192                                 // FIXME: this could fail slightly for multiple matches :P
 193                                 wfDebug( __METHOD__ . ": skipping existing revision for [[" .
 194                                         $this->title->getPrefixedText() . "]], timestamp " . $this->timestamp . "\n" );
 195                                 return false;
 196                         }
 197                 }
 198
 199                 # FIXME: Use original rev_id optionally (better for backups)
 200                 # Insert the row
 201                 $revision = new Revision( array(
 202                         'page'       => $pageId,
 203                         'text'       => $this->getText(),
 204                         'comment'    => $this->getComment(),
 205                         'user'       => $userId,
 206                         'user_text'  => $userText,
 207                         'timestamp'  => $this->timestamp,
 208                         'minor_edit' => $this->minor,
 209                         ) );
 210                 $revId = $revision->insertOn( $dbw );
 211                 $changed = $article->updateIfNewerOn( $dbw, $revision );
 212
 213                 # To be on the safe side...
 214                 $tempTitle = $GLOBALS['wgTitle'];
 215                 $GLOBALS['wgTitle'] = $this->title;
 216
 217                 if( $created ) {
 218                         wfDebug( __METHOD__ . ": running onArticleCreate\n" );
 219                         Article::onArticleCreate( $this->title );
 220
 221                         wfDebug( __METHOD__ . ": running create updates\n" );
 222                         $article->createUpdates( $revision );
 223
 224                 } elseif( $changed ) {
 225                         wfDebug( __METHOD__ . ": running onArticleEdit\n" );
 226                         Article::onArticleEdit( $this->title, 'skiptransclusions' ); // leave templatelinks for editUpdates()
 227
 228                         wfDebug( __METHOD__ . ": running edit updates\n" );
 229                         $article->editUpdates(
 230                                 $this->getText(),
 231                                 $this->getComment(),
 232                                 $this->minor,
 233                                 $this->timestamp,
 234                                 $revId );
 235                 }
 236                 $GLOBALS['wgTitle'] = $tempTitle;
 237
 238                 return true;
 239         }
 240
 241         function importLogItem() {
 242                 $dbw = wfGetDB( DB_MASTER );
 243                 # FIXME: this will not record autoblocks
 244                 if( !$this->getTitle() ) {
 245                         wfDebug( __METHOD__ . ": skipping invalid {$this->type}/{$this->action} log time, timestamp " .
 246                                 $this->timestamp . "\n" );
 247                         return;
 248                 }
 249                 # Check if it exists already
 250                 // FIXME: use original log ID (better for backups)
 251                 $prior = $dbw->selectField( 'logging', '1',
 252                         array( 'log_type' => $this->getType(),
 253                                 'log_action'    => $this->getAction(),
 254                                 'log_timestamp' => $dbw->timestamp( $this->timestamp ),
 255                                 'log_namespace' => $this->getTitle()->getNamespace(),
 256                                 'log_title'     => $this->getTitle()->getDBkey(),
 257                                 'log_comment'   => $this->getComment(),
 258                                 #'log_user_text' => $this->user_text,
 259                                 'log_params'    => $this->params ),
 260                         __METHOD__
 261                 );
 262                 // FIXME: this could fail slightly for multiple matches :P
 263                 if( $prior ) {
 264                         wfDebug( __METHOD__ . ": skipping existing item for Log:{$this->type}/{$this->action}, timestamp " .
 265                                 $this->timestamp . "\n" );
 266                         return false;
 267                 }
 268                 $log_id = $dbw->nextSequenceValue( 'log_log_id_seq' );
 269                 $data = array(
 270                         'log_id' => $log_id,
 271                         'log_type' => $this->type,
 272                         'log_action' => $this->action,
 273                         'log_timestamp' => $dbw->timestamp( $this->timestamp ),
 274                         'log_user' => User::idFromName( $this->user_text ),
 275                         #'log_user_text' => $this->user_text,
 276                         'log_namespace' => $this->getTitle()->getNamespace(),
 277                         'log_title' => $this->getTitle()->getDBkey(),
 278                         'log_comment' => $this->getComment(),
 279                         'log_params' => $this->params
 280                 );
 281                 $dbw->insert( 'logging', $data, __METHOD__ );
 282         }
 283
 284         function importUpload() {
 285                 wfDebug( __METHOD__ . ": STUB\n" );
 286
 287                 /**
 288                         // from file revert...
 289                         $source = $this->file->getArchiveVirtualUrl( $this->oldimage );
 290                         $comment = $wgRequest->getText( 'wpComment' );
 291                         // TODO: Preserve file properties from database instead of reloading from file
 292                         $status = $this->file->upload( $source, $comment, $comment );
 293                         if( $status->isGood() ) {
 294                 */
 295
 296                 /**
 297                         // from file upload...
 298                 $this->mLocalFile = wfLocalFile( $nt );
 299                 $this->mDestName = $this->mLocalFile->getName();
 300                 //....
 301                         $status = $this->mLocalFile->upload( $this->mTempPath, $this->mComment, $pageText,
 302                         File::DELETE_SOURCE, $this->mFileProps );
 303                         if ( !$status->isGood() ) {
 304                                 $resultDetails = array( 'internal' => $status->getWikiText() );
 305                 */
 306
 307                 // @fixme upload() uses $wgUser, which is wrong here
 308                 // it may also create a page without our desire, also wrong potentially.
 309                 // and, it will record a *current* upload, but we might want an archive version here
 310
 311                 $file = wfLocalFile( $this->getTitle() );
 312                 if( !$file ) {
 313                         var_dump( $file );
 314                         wfDebug( "IMPORT: Bad file. :(\n" );
 315                         return false;
 316                 }
 317
 318                 $source = $this->downloadSource();
 319                 if( !$source ) {
 320                         wfDebug( "IMPORT: Could not fetch remote file. :(\n" );
 321                         return false;
 322                 }
 323
 324                 $status = $file->upload( $source,
 325                         $this->getComment(),
 326                         $this->getComment(), // Initial page, if none present...
 327                         File::DELETE_SOURCE,
 328                         false, // props...
 329                         $this->getTimestamp() );
 330
 331                 if( $status->isGood() ) {
 332                         // yay?
 333                         wfDebug( "IMPORT: is ok?\n" );
 334                         return true;
 335                 }
 336
 337                 wfDebug( "IMPORT: is bad? " . $status->getXml() . "\n" );
 338                 return false;
 339
 340         }
 341
 342         function downloadSource() {
 343                 global $wgEnableUploads;
 344                 if( !$wgEnableUploads ) {
 345                         return false;
 346                 }
 347
 348                 $tempo = tempnam( wfTempDir(), 'download' );
 349                 $f = fopen( $tempo, 'wb' );
 350                 if( !$f ) {
 351                         wfDebug( "IMPORT: couldn't write to temp file $tempo\n" );
 352                         return false;
 353                 }
 354
 355                 // @fixme!
 356                 $src = $this->getSrc();
 357                 $data = Http::get( $src );
 358                 if( !$data ) {
 359                         wfDebug( "IMPORT: couldn't fetch source $src\n" );
 360                         fclose( $f );
 361                         unlink( $tempo );
 362                         return false;
 363                 }
 364
 365                 fwrite( $f, $data );
 366                 fclose( $f );
 367
 368                 return $tempo;
 369         }
 370
 371 }
 372
 373 /**
 374  * implements Special:Import
 375  * @ingroup SpecialPage
 376  */
 377 class WikiImporter {
 378         var $mDebug = false;
 379         var $mSource = null;
 380         var $mPageCallback = null;
 381         var $mPageOutCallback = null;
 382         var $mRevisionCallback = null;
 383         var $mLogItemCallback = null;
 384         var $mUploadCallback = null;
 385         var $mTargetNamespace = null;
 386         var $lastfield;
 387         var $tagStack = array();
 388
 389         function __construct( $source ) {
 390                 $this->setRevisionCallback( array( $this, "importRevision" ) );
 391                 $this->setUploadCallback( array( $this, "importUpload" ) );
 392                 $this->setLogItemCallback( array( $this, "importLogItem" ) );
 393                 $this->mSource = $source;
 394         }
 395
 396         function throwXmlError( $err ) {
 397                 $this->debug( "FAILURE: $err" );
 398                 wfDebug( "WikiImporter XML error: $err\n" );
 399         }
 400
 401         # --------------
 402
 403         function doImport() {
 404                 if( empty( $this->mSource ) ) {
 405                         return new WikiErrorMsg( "importnotext" );
 406                 }
 407
 408                 $parser = xml_parser_create( "UTF-8" );
 409
 410                 # case folding violates XML standard, turn it off
 411                 xml_parser_set_option( $parser, XML_OPTION_CASE_FOLDING, false );
 412
 413                 xml_set_object( $parser, $this );
 414                 xml_set_element_handler( $parser, "in_start", "" );
 415
 416                 $offset = 0; // for context extraction on error reporting
 417                 do {
 418                         $chunk = $this->mSource->readChunk();
 419                         if( !xml_parse( $parser, $chunk, $this->mSource->atEnd() ) ) {
 420                                 wfDebug( "WikiImporter::doImport encountered XML parsing error\n" );
 421                                 return new WikiXmlError( $parser, wfMsgHtml( 'import-parse-failure' ), $chunk, $offset );
 422                         }
 423                         $offset += strlen( $chunk );
 424                 } while( $chunk !== false && !$this->mSource->atEnd() );
 425                 xml_parser_free( $parser );
 426
 427                 return true;
 428         }
 429
 430         function debug( $data ) {
 431                 if( $this->mDebug ) {
 432                         wfDebug( "IMPORT: $data\n" );
 433                 }
 434         }
 435
 436         function notice( $data ) {
 437                 global $wgCommandLineMode;
 438                 if( $wgCommandLineMode ) {
 439                         print "$data\n";
 440                 } else {
 441                         global $wgOut;
 442                         $wgOut->addHTML( "<li>" . htmlspecialchars( $data ) . "</li>\n" );
 443                 }
 444         }
 445
 446         /**
 447          * Set debug mode...
 448          */
 449         function setDebug( $debug ) {
 450                 $this->mDebug = $debug;
 451         }
 452
 453         /**
 454          * Sets the action to perform as each new page in the stream is reached.
 455          * @param $callback callback
 456          * @return callback
 457          */
 458         function setPageCallback( $callback ) {
 459                 $previous = $this->mPageCallback;
 460                 $this->mPageCallback = $callback;
 461                 return $previous;
 462         }
 463
 464         /**
 465          * Sets the action to perform as each page in the stream is completed.
 466          * Callback accepts the page title (as a Title object), a second object
 467          * with the original title form (in case it's been overridden into a
 468          * local namespace), and a count of revisions.
 469          *
 470          * @param $callback callback
 471          * @return callback
 472          */
 473         function setPageOutCallback( $callback ) {
 474                 $previous = $this->mPageOutCallback;
 475                 $this->mPageOutCallback = $callback;
 476                 return $previous;
 477         }
 478
 479         /**
 480          * Sets the action to perform as each page revision is reached.
 481          * @param $callback callback
 482          * @return callback
 483          */
 484         function setRevisionCallback( $callback ) {
 485                 $previous = $this->mRevisionCallback;
 486                 $this->mRevisionCallback = $callback;
 487                 return $previous;
 488         }
 489
 490         /**
 491          * Sets the action to perform as each file upload version is reached.
 492          * @param $callback callback
 493          * @return callback
 494          */
 495         function setUploadCallback( $callback ) {
 496                 $previous = $this->mUploadCallback;
 497                 $this->mUploadCallback = $callback;
 498                 return $previous;
 499         }
 500
 501         /**
 502          * Sets the action to perform as each log item reached.
 503          * @param $callback callback
 504          * @return callback
 505          */
 506         function setLogItemCallback( $callback ) {
 507                 $previous = $this->mLogItemCallback;
 508                 $this->mLogItemCallback = $callback;
 509                 return $previous;
 510         }
 511
 512         /**
 513          * Set a target namespace to override the defaults
 514          */
 515         function setTargetNamespace( $namespace ) {
 516                 if( is_null( $namespace ) ) {
 517                         // Don't override namespaces
 518                         $this->mTargetNamespace = null;
 519                 } elseif( $namespace >= 0 ) {
 520                         // FIXME: Check for validity
 521                         $this->mTargetNamespace = intval( $namespace );
 522                 } else {
 523                         return false;
 524                 }
 525         }
 526
 527         /**
 528          * Default per-revision callback, performs the import.
 529          * @param $revision WikiRevision
 530          * @private
 531          */
 532         function importRevision( $revision ) {
 533                 $dbw = wfGetDB( DB_MASTER );
 534                 return $dbw->deadlockLoop( array( $revision, 'importOldRevision' ) );
 535         }
 536
 537         /**
 538          * Default per-revision callback, performs the import.
 539          * @param $revision WikiRevision
 540          * @private
 541          */
 542         function importLogItem( $rev ) {
 543                 $dbw = wfGetDB( DB_MASTER );
 544                 return $dbw->deadlockLoop( array( $rev, 'importLogItem' ) );
 545         }
 546
 547         /**
 548          * Dummy for now...
 549          */
 550         function importUpload( $revision ) {
 551                 //$dbw = wfGetDB( DB_MASTER );
 552                 //return $dbw->deadlockLoop( array( $revision, 'importUpload' ) );
 553                 return false;
 554         }
 555
 556         /**
 557          * Alternate per-revision callback, for debugging.
 558          * @param $revision WikiRevision
 559          * @private
 560          */
 561         function debugRevisionHandler( &$revision ) {
 562                 $this->debug( "Got revision:" );
 563                 if( is_object( $revision->title ) ) {
 564                         $this->debug( "-- Title: " . $revision->title->getPrefixedText() );
 565                 } else {
 566                         $this->debug( "-- Title: <invalid>" );
 567                 }
 568                 $this->debug( "-- User: " . $revision->user_text );
 569                 $this->debug( "-- Timestamp: " . $revision->timestamp );
 570                 $this->debug( "-- Comment: " . $revision->comment );
 571                 $this->debug( "-- Text: " . $revision->text );
 572         }
 573
 574         /**
 575          * Notify the callback function when a new <page> is reached.
 576          * @param $title Title
 577          * @private
 578          */
 579         function pageCallback( $title ) {
 580                 if( is_callable( $this->mPageCallback ) ) {
 581                         call_user_func( $this->mPageCallback, $title );
 582                 }
 583         }
 584
 585         /**
 586          * Notify the callback function when a </page> is closed.
 587          * @param $title Title
 588          * @param $origTitle Title
 589          * @param $revisionCount int
 590          * @param $successCount Int: number of revisions for which callback returned true
 591          * @private
 592          */
 593         function pageOutCallback( $title, $origTitle, $revisionCount, $successCount ) {
 594                 if( is_callable( $this->mPageOutCallback ) ) {
 595                         call_user_func( $this->mPageOutCallback, $title, $origTitle,
 596                                 $revisionCount, $successCount );
 597                 }
 598         }
 599
 600         # XML parser callbacks from here out -- beware!
 601         function donothing( $parser, $x, $y="" ) {
 602                 #$this->debug( "donothing" );
 603         }
 604
 605         function in_start( $parser, $name, $attribs ) {
 606                 $this->debug( "in_start $name" );
 607                 if( $name != "mediawiki" ) {
 608                         return $this->throwXMLerror( "Expected <mediawiki>, got <$name>" );
 609                 }
 610                 xml_set_element_handler( $parser, "in_mediawiki", "out_mediawiki" );
 611         }
 612
 613         function in_mediawiki( $parser, $name, $attribs ) {
 614                 $this->debug( "in_mediawiki $name" );
 615                 if( $name == 'siteinfo' ) {
 616                         xml_set_element_handler( $parser, "in_siteinfo", "out_siteinfo" );
 617                 } elseif( $name == 'page' ) {
 618                         $this->push( $name );
 619                         $this->workRevisionCount = 0;
 620                         $this->workSuccessCount = 0;
 621                         $this->uploadCount = 0;
 622                         $this->uploadSuccessCount = 0;
 623                         xml_set_element_handler( $parser, "in_page", "out_page" );
 624                 } elseif( $name == 'logitem' ) {
 625                         $this->push( $name );
 626                         $this->workRevision = new WikiRevision;
 627                         xml_set_element_handler( $parser, "in_logitem", "out_logitem" );
 628                 } else {
 629                         return $this->throwXMLerror( "Expected <page>, got <$name>" );
 630                 }
 631         }
 632         function out_mediawiki( $parser, $name ) {
 633                 $this->debug( "out_mediawiki $name" );
 634                 if( $name != "mediawiki" ) {
 635                         return $this->throwXMLerror( "Expected </mediawiki>, got </$name>" );
 636                 }
 637                 xml_set_element_handler( $parser, "donothing", "donothing" );
 638         }
 639
 640
 641         function in_siteinfo( $parser, $name, $attribs ) {
 642                 // no-ops for now
 643                 $this->debug( "in_siteinfo $name" );
 644                 switch( $name ) {
 645                 case "sitename":
 646                 case "base":
 647                 case "generator":
 648                 case "case":
 649                 case "namespaces":
 650                 case "namespace":
 651                         break;
 652                 default:
 653                         return $this->throwXMLerror( "Element <$name> not allowed in <siteinfo>." );
 654                 }
 655         }
 656
 657         function out_siteinfo( $parser, $name ) {
 658                 if( $name == "siteinfo" ) {
 659                         xml_set_element_handler( $parser, "in_mediawiki", "out_mediawiki" );
 660                 }
 661         }
 662
 663
 664         function in_page( $parser, $name, $attribs ) {
 665                 $this->debug( "in_page $name" );
 666                 switch( $name ) {
 667                 case "id":
 668                 case "title":
 669                 case "restrictions":
 670                         $this->appendfield = $name;
 671                         $this->appenddata = "";
 672                         xml_set_element_handler( $parser, "in_nothing", "out_append" );
 673                         xml_set_character_data_handler( $parser, "char_append" );
 674                         break;
 675                 case "revision":
 676                         $this->push( "revision" );
 677                         if( is_object( $this->pageTitle ) ) {
 678                                 $this->workRevision = new WikiRevision;
 679                                 $this->workRevision->setTitle( $this->pageTitle );
 680                                 $this->workRevisionCount++;
 681                         } else {
 682                                 // Skipping items due to invalid page title
 683                                 $this->workRevision = null;
 684                         }
 685                         xml_set_element_handler( $parser, "in_revision", "out_revision" );
 686                         break;
 687                 case "upload":
 688                         $this->push( "upload" );
 689                         if( is_object( $this->pageTitle ) ) {
 690                                 $this->workRevision = new WikiRevision;
 691                                 $this->workRevision->setTitle( $this->pageTitle );
 692                                 $this->uploadCount++;
 693                         } else {
 694                                 // Skipping items due to invalid page title
 695                                 $this->workRevision = null;
 696                         }
 697                         xml_set_element_handler( $parser, "in_upload", "out_upload" );
 698                         break;
 699                 default:
 700                         return $this->throwXMLerror( "Element <$name> not allowed in a <page>." );
 701                 }
 702         }
 703
 704         function out_page( $parser, $name ) {
 705                 $this->debug( "out_page $name" );
 706                 $this->pop();
 707                 if( $name != "page" ) {
 708                         return $this->throwXMLerror( "Expected </page>, got </$name>" );
 709                 }
 710                 xml_set_element_handler( $parser, "in_mediawiki", "out_mediawiki" );
 711
 712                 $this->pageOutCallback( $this->pageTitle, $this->origTitle,
 713                         $this->workRevisionCount, $this->workSuccessCount );
 714
 715                 $this->workTitle = null;
 716                 $this->workRevision = null;
 717                 $this->workRevisionCount = 0;
 718                 $this->workSuccessCount = 0;
 719                 $this->pageTitle = null;
 720                 $this->origTitle = null;
 721         }
 722
 723         function in_nothing( $parser, $name, $attribs ) {
 724                 $this->debug( "in_nothing $name" );
 725                 return $this->throwXMLerror( "No child elements allowed here; got <$name>" );
 726         }
 727
 728         function char_append( $parser, $data ) {
 729                 $this->debug( "char_append '$data'" );
 730                 $this->appenddata .= $data;
 731         }
 732
 733         function out_append( $parser, $name ) {
 734                 $this->debug( "out_append $name" );
 735                 if( $name != $this->appendfield ) {
 736                         return $this->throwXMLerror( "Expected </{$this->appendfield}>, got </$name>" );
 737                 }
 738
 739                 switch( $this->appendfield ) {
 740                 case "title":
 741                         $this->workTitle = $this->appenddata;
 742                         $this->origTitle = Title::newFromText( $this->workTitle );
 743                         if( !is_null( $this->mTargetNamespace ) && !is_null( $this->origTitle ) ) {
 744                                 $this->pageTitle = Title::makeTitle( $this->mTargetNamespace,
 745                                         $this->origTitle->getDBkey() );
 746                         } else {
 747                                 $this->pageTitle = Title::newFromText( $this->workTitle );
 748                         }
 749                         if( is_null( $this->pageTitle ) ) {
 750                                 // Invalid page title? Ignore the page
 751                                 $this->notice( "Skipping invalid page title '$this->workTitle'" );
 752                         } else {
 753                                 $this->pageCallback( $this->workTitle );
 754                         }
 755                         break;
 756                 case "id":
 757                         if ( $this->parentTag() == 'revision' || $this->parentTag() == 'logitem' ) {
 758                                 if( $this->workRevision )
 759                                         $this->workRevision->setID( $this->appenddata );
 760                         }
 761                         break;
 762                 case "text":
 763                         if( $this->workRevision )
 764                                 $this->workRevision->setText( $this->appenddata );
 765                         break;
 766                 case "username":
 767                         if( $this->workRevision )
 768                                 $this->workRevision->setUsername( $this->appenddata );
 769                         break;
 770                 case "ip":
 771                         if( $this->workRevision )
 772                                 $this->workRevision->setUserIP( $this->appenddata );
 773                         break;
 774                 case "timestamp":
 775                         if( $this->workRevision )
 776                                 $this->workRevision->setTimestamp( $this->appenddata );
 777                         break;
 778                 case "comment":
 779                         if( $this->workRevision )
 780                                 $this->workRevision->setComment( $this->appenddata );
 781                         break;
 782                 case "type":
 783                         if( $this->workRevision )
 784                                 $this->workRevision->setType( $this->appenddata );
 785                         break;
 786                 case "action":
 787                         if( $this->workRevision )
 788                                 $this->workRevision->setAction( $this->appenddata );
 789                         break;
 790                 case "logtitle":
 791                         if( $this->workRevision )
 792                                 $this->workRevision->setTitle( Title::newFromText( $this->appenddata ) );
 793                         break;
 794                 case "params":
 795                         if( $this->workRevision )
 796                                 $this->workRevision->setParams( $this->appenddata );
 797                         break;
 798                 case "minor":
 799                         if( $this->workRevision )
 800                                 $this->workRevision->setMinor( true );
 801                         break;
 802                 case "filename":
 803                         if( $this->workRevision )
 804                                 $this->workRevision->setFilename( $this->appenddata );
 805                         break;
 806                 case "src":
 807                         if( $this->workRevision )
 808                                 $this->workRevision->setSrc( $this->appenddata );
 809                         break;
 810                 case "size":
 811                         if( $this->workRevision )
 812                                 $this->workRevision->setSize( intval( $this->appenddata ) );
 813                         break;
 814                 default:
 815                         $this->debug( "Bad append: {$this->appendfield}" );
 816                 }
 817                 $this->appendfield = "";
 818                 $this->appenddata = "";
 819
 820                 $parent = $this->parentTag();
 821                 xml_set_element_handler( $parser, "in_$parent", "out_$parent" );
 822                 xml_set_character_data_handler( $parser, "donothing" );
 823         }
 824
 825         function in_revision( $parser, $name, $attribs ) {
 826                 $this->debug( "in_revision $name" );
 827                 switch( $name ) {
 828                 case "id":
 829                 case "timestamp":
 830                 case "comment":
 831                 case "minor":
 832                 case "text":
 833                         $this->appendfield = $name;
 834                         xml_set_element_handler( $parser, "in_nothing", "out_append" );
 835                         xml_set_character_data_handler( $parser, "char_append" );
 836                         break;
 837                 case "contributor":
 838                         $this->push( "contributor" );
 839                         xml_set_element_handler( $parser, "in_contributor", "out_contributor" );
 840                         break;
 841                 default:
 842                         return $this->throwXMLerror( "Element <$name> not allowed in a <revision>." );
 843                 }
 844         }
 845
 846         function out_revision( $parser, $name ) {
 847                 $this->debug( "out_revision $name" );
 848                 $this->pop();
 849                 if( $name != "revision" ) {
 850                         return $this->throwXMLerror( "Expected </revision>, got </$name>" );
 851                 }
 852                 xml_set_element_handler( $parser, "in_page", "out_page" );
 853
 854                 if( $this->workRevision ) {
 855                         $ok = call_user_func_array( $this->mRevisionCallback,
 856                                 array( $this->workRevision, $this ) );
 857                         if( $ok ) {
 858                                 $this->workSuccessCount++;
 859                         }
 860                 }
 861         }
 862
 863         function in_logitem( $parser, $name, $attribs ) {
 864                 $this->debug( "in_logitem $name" );
 865                 switch( $name ) {
 866                 case "id":
 867                 case "timestamp":
 868                 case "comment":
 869                 case "type":
 870                 case "action":
 871                 case "logtitle":
 872                 case "params":
 873                         $this->appendfield = $name;
 874                         xml_set_element_handler( $parser, "in_nothing", "out_append" );
 875                         xml_set_character_data_handler( $parser, "char_append" );
 876                         break;
 877                 case "contributor":
 878                         $this->push( "contributor" );
 879                         xml_set_element_handler( $parser, "in_contributor", "out_contributor" );
 880                         break;
 881                 default:
 882                         return $this->throwXMLerror( "Element <$name> not allowed in a <revision>." );
 883                 }
 884         }
 885
 886         function out_logitem( $parser, $name ) {
 887                 $this->debug( "out_logitem $name" );
 888                 $this->pop();
 889                 if( $name != "logitem" ) {
 890                         return $this->throwXMLerror( "Expected </logitem>, got </$name>" );
 891                 }
 892                 xml_set_element_handler( $parser, "in_mediawiki", "out_mediawiki" );
 893
 894                 if( $this->workRevision ) {
 895                         $ok = call_user_func_array( $this->mLogItemCallback,
 896                                 array( $this->workRevision, $this ) );
 897                         if( $ok ) {
 898                                 $this->workSuccessCount++;
 899                         }
 900                 }
 901         }
 902
 903         function in_upload( $parser, $name, $attribs ) {
 904                 $this->debug( "in_upload $name" );
 905                 switch( $name ) {
 906                 case "timestamp":
 907                 case "comment":
 908                 case "text":
 909                 case "filename":
 910                 case "src":
 911                 case "size":
 912                         $this->appendfield = $name;
 913                         xml_set_element_handler( $parser, "in_nothing", "out_append" );
 914                         xml_set_character_data_handler( $parser, "char_append" );
 915                         break;
 916                 case "contributor":
 917                         $this->push( "contributor" );
 918                         xml_set_element_handler( $parser, "in_contributor", "out_contributor" );
 919                         break;
 920                 default:
 921                         return $this->throwXMLerror( "Element <$name> not allowed in an <upload>." );
 922                 }
 923         }
 924
 925         function out_upload( $parser, $name ) {
 926                 $this->debug( "out_revision $name" );
 927                 $this->pop();
 928                 if( $name != "upload" ) {
 929                         return $this->throwXMLerror( "Expected </upload>, got </$name>" );
 930                 }
 931                 xml_set_element_handler( $parser, "in_page", "out_page" );
 932
 933                 if( $this->workRevision ) {
 934                         $ok = call_user_func_array( $this->mUploadCallback,
 935                                 array( $this->workRevision, $this ) );
 936                         if( $ok ) {
 937                                 $this->workUploadSuccessCount++;
 938                         }
 939                 }
 940         }
 941
 942         function in_contributor( $parser, $name, $attribs ) {
 943                 $this->debug( "in_contributor $name" );
 944                 switch( $name ) {
 945                 case "username":
 946                 case "ip":
 947                 case "id":
 948                         $this->appendfield = $name;
 949                         xml_set_element_handler( $parser, "in_nothing", "out_append" );
 950                         xml_set_character_data_handler( $parser, "char_append" );
 951                         break;
 952                 default:
 953                         $this->throwXMLerror( "Invalid tag <$name> in <contributor>" );
 954                 }
 955         }
 956
 957         function out_contributor( $parser, $name ) {
 958                 $this->debug( "out_contributor $name" );
 959                 $this->pop();
 960                 if( $name != "contributor" ) {
 961                         return $this->throwXMLerror( "Expected </contributor>, got </$name>" );
 962                 }
 963                 $parent = $this->parentTag();
 964                 xml_set_element_handler( $parser, "in_$parent", "out_$parent" );
 965         }
 966
 967         private function push( $name ) {
 968                 array_push( $this->tagStack, $name );
 969                 $this->debug( "PUSH $name" );
 970         }
 971
 972         private function pop() {
 973                 $name = array_pop( $this->tagStack );
 974                 $this->debug( "POP $name" );
 975                 return $name;
 976         }
 977
 978         private function parentTag() {
 979                 $name = $this->tagStack[count( $this->tagStack ) - 1];
 980                 $this->debug( "PARENT $name" );
 981                 return $name;
 982         }
 983
 984 }
 985
 986 /**
 987  * @todo document (e.g. one-sentence class description).
 988  * @ingroup SpecialPage
 989  */
 990 class ImportStringSource {
 991         function __construct( $string ) {
 992                 $this->mString = $string;
 993                 $this->mRead = false;
 994         }
 995
 996         function atEnd() {
 997                 return $this->mRead;
 998         }
 999
1000         function readChunk() {
1001                 if( $this->atEnd() ) {
1002                         return false;
1003                 } else {
1004                         $this->mRead = true;
1005                         return $this->mString;
1006                 }
1007         }
1008 }
1009
1010 /**
1011  * @todo document (e.g. one-sentence class description).
1012  * @ingroup SpecialPage
1013  */
1014 class ImportStreamSource {
1015         function __construct( $handle ) {
1016                 $this->mHandle = $handle;
1017         }
1018
1019         function atEnd() {
1020                 return feof( $this->mHandle );
1021         }
1022
1023         function readChunk() {
1024                 return fread( $this->mHandle, 32768 );
1025         }
1026
1027         static function newFromFile( $filename ) {
1028                 $file = @fopen( $filename, 'rt' );
1029                 if( !$file ) {
1030                         return new WikiErrorMsg( "importcantopen" );
1031                 }
1032                 return new ImportStreamSource( $file );
1033         }
1034
1035         static function newFromUpload( $fieldname = "xmlimport" ) {
1036                 $upload =& $_FILES[$fieldname];
1037
1038                 if( !isset( $upload ) || !$upload['name'] ) {
1039                         return new WikiErrorMsg( 'importnofile' );
1040                 }
1041                 if( !empty( $upload['error'] ) ) {
1042                         switch($upload['error']){
1043                                 case 1: # The uploaded file exceeds the upload_max_filesize directive in php.ini.
1044                                         return new WikiErrorMsg( 'importuploaderrorsize' );
1045                                 case 2: # The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form.
1046                                         return new WikiErrorMsg( 'importuploaderrorsize' );
1047                                 case 3: # The uploaded file was only partially uploaded
1048                                         return new WikiErrorMsg( 'importuploaderrorpartial' );
1049                             case 6: #Missing a temporary folder. Introduced in PHP 4.3.10 and PHP 5.0.3.
1050                                 return new WikiErrorMsg( 'importuploaderrortemp' );
1051                             # case else: # Currently impossible
1052                         }
1053
1054                 }
1055                 $fname = $upload['tmp_name'];
1056                 if( is_uploaded_file( $fname ) ) {
1057                         return ImportStreamSource::newFromFile( $fname );
1058                 } else {
1059                         return new WikiErrorMsg( 'importnofile' );
1060                 }
1061         }
1062
1063         static function newFromURL( $url, $method = 'GET' ) {
1064                 wfDebug( __METHOD__ . ": opening $url\n" );
1065                 # Use the standard HTTP fetch function; it times out
1066                 # quicker and sorts out user-agent problems which might
1067                 # otherwise prevent importing from large sites, such
1068                 # as the Wikimedia cluster, etc.
1069                 $data = Http::request( $method, $url );
1070                 if( $data !== false ) {
1071                         $file = tmpfile();
1072                         fwrite( $file, $data );
1073                         fflush( $file );
1074                         fseek( $file, 0 );
1075                         return new ImportStreamSource( $file );
1076                 } else {
1077                         return new WikiErrorMsg( 'importcantopen' );
1078                 }
1079         }
1080
1081         public static function newFromInterwiki( $interwiki, $page, $history=false ) {
1082                 if( $page == '' ) {
1083                         return new WikiErrorMsg( 'import-noarticle' );
1084                 }
1085                 $link = Title::newFromText( "$interwiki:Special:Export/$page" );
1086                 if( is_null( $link ) || $link->getInterwiki() == '' ) {
1087                         return new WikiErrorMsg( 'importbadinterwiki' );
1088                 } else {
1089                         $params = $history ? 'history=1' : '';
1090                         $url = $link->getFullUrl( $params );
1091                         # For interwikis, use POST to avoid redirects.
1092                         return ImportStreamSource::newFromURL( $url, "POST" );
1093                 }
1094         }
1095 }