Import.php

Go to the documentation of this file.

<?php
class WikiImporter {
        private $reader = null;
        private $mLogItemCallback, $mUploadCallback, $mRevisionCallback, $mPageCallback;
        private $mSiteInfoCallback, $mTargetNamespace, $mTargetRootPage, $mPageOutCallback;
        private $mNoticeCallback, $mDebug;
        private $mImportUploads, $mImageBasePath;
        private $mNoUpdates = false;

        function __construct( $source ) {
                $this->reader = new XMLReader();

                stream_wrapper_register( 'uploadsource', 'UploadSourceAdapter' );
                $id = UploadSourceAdapter::registerSource( $source );
                if (defined( 'LIBXML_PARSEHUGE' ) ) {
                        $this->reader->open( "uploadsource://$id", null, LIBXML_PARSEHUGE );
                } else {
                        $this->reader->open( "uploadsource://$id" );
                }

                // Default callbacks
                $this->setRevisionCallback( array( $this, "importRevision" ) );
                $this->setUploadCallback( array( $this, 'importUpload' ) );
                $this->setLogItemCallback( array( $this, 'importLogItem' ) );
                $this->setPageOutCallback( array( $this, 'finishImportPage' ) );
        }

        private function throwXmlError( $err ) {
                $this->debug( "FAILURE: $err" );
                wfDebug( "WikiImporter XML error: $err\n" );
        }

        private function debug( $data ) {
                if( $this->mDebug ) {
                        wfDebug( "IMPORT: $data\n" );
                }
        }

        private function warn( $data ) {
                wfDebug( "IMPORT: $data\n" );
        }

        private function notice( $msg /*, $param, ...*/ ) {
                $params = func_get_args();
                array_shift( $params );

                if ( is_callable( $this->mNoticeCallback ) ) {
                        call_user_func( $this->mNoticeCallback, $msg, $params );
                } else { # No ImportReporter -> CLI
                        echo wfMessage( $msg, $params )->text() . "\n";
                }
        }

        function setDebug( $debug ) {
                $this->mDebug = $debug;
        }

        function setNoUpdates( $noupdates ) {
                $this->mNoUpdates = $noupdates;
        }

        public function setNoticeCallback( $callback ) {
                return wfSetVar( $this->mNoticeCallback, $callback );
        }

        public function setPageCallback( $callback ) {
                $previous = $this->mPageCallback;
                $this->mPageCallback = $callback;
                return $previous;
        }

        public function setPageOutCallback( $callback ) {
                $previous = $this->mPageOutCallback;
                $this->mPageOutCallback = $callback;
                return $previous;
        }

        public function setRevisionCallback( $callback ) {
                $previous = $this->mRevisionCallback;
                $this->mRevisionCallback = $callback;
                return $previous;
        }

        public function setUploadCallback( $callback ) {
                $previous = $this->mUploadCallback;
                $this->mUploadCallback = $callback;
                return $previous;
        }

        public function setLogItemCallback( $callback ) {
                $previous = $this->mLogItemCallback;
                $this->mLogItemCallback = $callback;
                return $previous;
        }

        public function setSiteInfoCallback( $callback ) {
                $previous = $this->mSiteInfoCallback;
                $this->mSiteInfoCallback = $callback;
                return $previous;
        }

        public function setTargetNamespace( $namespace ) {
                if( is_null( $namespace ) ) {
                        // Don't override namespaces
                        $this->mTargetNamespace = null;
                } elseif( $namespace >= 0 ) {
                        // @todo FIXME: Check for validity
                        $this->mTargetNamespace = intval( $namespace );
                } else {
                        return false;
                }
        }

        public function setTargetRootPage( $rootpage ) {
                $status = Status::newGood();
                if( is_null( $rootpage ) ) {
                        // No rootpage
                        $this->mTargetRootPage = null;
                } elseif( $rootpage !== '' ) {
                        $rootpage = rtrim( $rootpage, '/' ); //avoid double slashes
                        $title = Title::newFromText( $rootpage, !is_null( $this->mTargetNamespace ) ? $this->mTargetNamespace : NS_MAIN );
                        if( !$title || $title->isExternal() ) {
                                $status->fatal( 'import-rootpage-invalid' );
                        } else {
                                if( !MWNamespace::hasSubpages( $title->getNamespace() ) ) {
                                        global $wgContLang;

                                        $displayNSText = $title->getNamespace() == NS_MAIN
                                                ? wfMessage( 'blanknamespace' )->text()
                                                : $wgContLang->getNsText( $title->getNamespace() );
                                        $status->fatal( 'import-rootpage-nosubpage', $displayNSText );
                                } else {
                                        // set namespace to 'all', so the namespace check in processTitle() can passed
                                        $this->setTargetNamespace( null );
                                        $this->mTargetRootPage = $title->getPrefixedDBKey();
                                }
                        }
                }
                return $status;
        }

        public function setImageBasePath( $dir ) {
                $this->mImageBasePath = $dir;
        }

        public function setImportUploads( $import ) {
                $this->mImportUploads = $import;
        }

        public function importRevision( $revision ) {
                $dbw = wfGetDB( DB_MASTER );
                return $dbw->deadlockLoop( array( $revision, 'importOldRevision' ) );
        }

        public function importLogItem( $rev ) {
                $dbw = wfGetDB( DB_MASTER );
                return $dbw->deadlockLoop( array( $rev, 'importLogItem' ) );
        }

        public function importUpload( $revision ) {
                $dbw = wfGetDB( DB_MASTER );
                return $dbw->deadlockLoop( array( $revision, 'importUpload' ) );
        }

        public function finishImportPage( $title, $origTitle, $revCount, $sRevCount, $pageInfo ) {
                $args = func_get_args();
                return wfRunHooks( 'AfterImportPage', $args );
        }

        public function debugRevisionHandler( &$revision ) {
                $this->debug( "Got revision:" );
                if( is_object( $revision->title ) ) {
                        $this->debug( "-- Title: " . $revision->title->getPrefixedText() );
                } else {
                        $this->debug( "-- Title: <invalid>" );
                }
                $this->debug( "-- User: " . $revision->user_text );
                $this->debug( "-- Timestamp: " . $revision->timestamp );
                $this->debug( "-- Comment: " . $revision->comment );
                $this->debug( "-- Text: " . $revision->text );
        }

        function pageCallback( $title ) {
                if( isset( $this->mPageCallback ) ) {
                        call_user_func( $this->mPageCallback, $title );
                }
        }

        private function pageOutCallback( $title, $origTitle, $revCount, $sucCount, $pageInfo ) {
                if( isset( $this->mPageOutCallback ) ) {
                        $args = func_get_args();
                        call_user_func_array( $this->mPageOutCallback, $args );
                }
        }

        private function revisionCallback( $revision ) {
                if ( isset( $this->mRevisionCallback ) ) {
                        return call_user_func_array( $this->mRevisionCallback,
                                        array( $revision, $this ) );
                } else {
                        return false;
                }
        }

        private function logItemCallback( $revision ) {
                if ( isset( $this->mLogItemCallback ) ) {
                        return call_user_func_array( $this->mLogItemCallback,
                                        array( $revision, $this ) );
                } else {
                        return false;
                }
        }

        private function nodeContents() {
                if( $this->reader->isEmptyElement ) {
                        return "";
                }
                $buffer = "";
                while( $this->reader->read() ) {
                        switch( $this->reader->nodeType ) {
                        case XmlReader::TEXT:
                        case XmlReader::SIGNIFICANT_WHITESPACE:
                                $buffer .= $this->reader->value;
                                break;
                        case XmlReader::END_ELEMENT:
                                return $buffer;
                        }
                }

                $this->reader->close();
                return '';
        }

        # --------------

        private function dumpElement() {
                static $lookup = null;
                if (!$lookup) {
                        $xmlReaderConstants = array(
                                "NONE",
                                "ELEMENT",
                                "ATTRIBUTE",
                                "TEXT",
                                "CDATA",
                                "ENTITY_REF",
                                "ENTITY",
                                "PI",
                                "COMMENT",
                                "DOC",
                                "DOC_TYPE",
                                "DOC_FRAGMENT",
                                "NOTATION",
                                "WHITESPACE",
                                "SIGNIFICANT_WHITESPACE",
                                "END_ELEMENT",
                                "END_ENTITY",
                                "XML_DECLARATION",
                                );
                        $lookup = array();

                        foreach( $xmlReaderConstants as $name ) {
                                $lookup[constant("XmlReader::$name")] = $name;
                        }
                }

                print( var_dump(
                        $lookup[$this->reader->nodeType],
                        $this->reader->name,
                        $this->reader->value
                )."\n\n" );
        }

        public function doImport() {
                $this->reader->read();

                if ( $this->reader->name != 'mediawiki' ) {
                        throw new MWException( "Expected <mediawiki> tag, got ".
                                $this->reader->name );
                }
                $this->debug( "<mediawiki> tag is correct." );

                $this->debug( "Starting primary dump processing loop." );

                $keepReading = $this->reader->read();
                $skip = false;
                while ( $keepReading ) {
                        $tag = $this->reader->name;
                        $type = $this->reader->nodeType;

                        if ( !wfRunHooks( 'ImportHandleToplevelXMLTag', $this ) ) {
                                // Do nothing
                        } elseif ( $tag == 'mediawiki' && $type == XmlReader::END_ELEMENT ) {
                                break;
                        } elseif ( $tag == 'siteinfo' ) {
                                $this->handleSiteInfo();
                        } elseif ( $tag == 'page' ) {
                                $this->handlePage();
                        } elseif ( $tag == 'logitem' ) {
                                $this->handleLogItem();
                        } elseif ( $tag != '#text' ) {
                                $this->warn( "Unhandled top-level XML tag $tag" );

                                $skip = true;
                        }

                        if ($skip) {
                                $keepReading = $this->reader->next();
                                $skip = false;
                                $this->debug( "Skip" );
                        } else {
                                $keepReading = $this->reader->read();
                        }
                }

                return true;
        }

        private function handleSiteInfo() {
                // Site info is useful, but not actually used for dump imports.
                // Includes a quick short-circuit to save performance.
                if ( ! $this->mSiteInfoCallback ) {
                        $this->reader->next();
                        return true;
                }
                throw new MWException( "SiteInfo tag is not yet handled, do not set mSiteInfoCallback" );
        }

        private function handleLogItem() {
                $this->debug( "Enter log item handler." );
                $logInfo = array();

                // Fields that can just be stuffed in the pageInfo object
                $normalFields = array( 'id', 'comment', 'type', 'action', 'timestamp',
                                        'logtitle', 'params' );

                while ( $this->reader->read() ) {
                        if ( $this->reader->nodeType == XmlReader::END_ELEMENT &&
                                        $this->reader->name == 'logitem') {
                                break;
                        }

                        $tag = $this->reader->name;

                        if ( !wfRunHooks( 'ImportHandleLogItemXMLTag',
                                                $this, $logInfo ) ) {
                                // Do nothing
                        } elseif ( in_array( $tag, $normalFields ) ) {
                                $logInfo[$tag] = $this->nodeContents();
                        } elseif ( $tag == 'contributor' ) {
                                $logInfo['contributor'] = $this->handleContributor();
                        } elseif ( $tag != '#text' ) {
                                $this->warn( "Unhandled log-item XML tag $tag" );
                        }
                }

                $this->processLogItem( $logInfo );
        }

        private function processLogItem( $logInfo ) {
                $revision = new WikiRevision;

                $revision->setID( $logInfo['id'] );
                $revision->setType( $logInfo['type'] );
                $revision->setAction( $logInfo['action'] );
                $revision->setTimestamp( $logInfo['timestamp'] );
                $revision->setParams( $logInfo['params'] );
                $revision->setTitle( Title::newFromText( $logInfo['logtitle'] ) );
                $revision->setNoUpdates( $this->mNoUpdates );

                if ( isset( $logInfo['comment'] ) ) {
                        $revision->setComment( $logInfo['comment'] );
                }

                if ( isset( $logInfo['contributor']['ip'] ) ) {
                        $revision->setUserIP( $logInfo['contributor']['ip'] );
                }
                if ( isset( $logInfo['contributor']['username'] ) ) {
                        $revision->setUserName( $logInfo['contributor']['username'] );
                }

                return $this->logItemCallback( $revision );
        }

        private function handlePage() {
                // Handle page data.
                $this->debug( "Enter page handler." );
                $pageInfo = array( 'revisionCount' => 0, 'successfulRevisionCount' => 0 );

                // Fields that can just be stuffed in the pageInfo object
                $normalFields = array( 'title', 'id', 'redirect', 'restrictions' );

                $skip = false;
                $badTitle = false;

                while ( $skip ? $this->reader->next() : $this->reader->read() ) {
                        if ( $this->reader->nodeType == XmlReader::END_ELEMENT &&
                                        $this->reader->name == 'page') {
                                break;
                        }

                        $tag = $this->reader->name;

                        if ( $badTitle ) {
                                // The title is invalid, bail out of this page
                                $skip = true;
                        } elseif ( !wfRunHooks( 'ImportHandlePageXMLTag', array( $this,
                                                &$pageInfo ) ) ) {
                                // Do nothing
                        } elseif ( in_array( $tag, $normalFields ) ) {
                                $pageInfo[$tag] = $this->nodeContents();
                                if ( $tag == 'title' ) {
                                        $title = $this->processTitle( $pageInfo['title'] );

                                        if ( !$title ) {
                                                $badTitle = true;
                                                $skip = true;
                                        }

                                        $this->pageCallback( $title );
                                        list( $pageInfo['_title'], $origTitle ) = $title;
                                }
                        } elseif ( $tag == 'revision' ) {
                                $this->handleRevision( $pageInfo );
                        } elseif ( $tag == 'upload' ) {
                                $this->handleUpload( $pageInfo );
                        } elseif ( $tag != '#text' ) {
                                $this->warn( "Unhandled page XML tag $tag" );
                                $skip = true;
                        }
                }

                $this->pageOutCallback( $pageInfo['_title'], $origTitle,
                                        $pageInfo['revisionCount'],
                                        $pageInfo['successfulRevisionCount'],
                                        $pageInfo );
        }

        private function handleRevision( &$pageInfo ) {
                $this->debug( "Enter revision handler" );
                $revisionInfo = array();

                $normalFields = array( 'id', 'timestamp', 'comment', 'minor', 'model', 'format', 'text' );

                $skip = false;

                while ( $skip ? $this->reader->next() : $this->reader->read() ) {
                        if ( $this->reader->nodeType == XmlReader::END_ELEMENT &&
                                        $this->reader->name == 'revision') {
                                break;
                        }

                        $tag = $this->reader->name;

                        if ( !wfRunHooks( 'ImportHandleRevisionXMLTag', $this,
                                                $pageInfo, $revisionInfo ) ) {
                                // Do nothing
                        } elseif ( in_array( $tag, $normalFields ) ) {
                                $revisionInfo[$tag] = $this->nodeContents();
                        } elseif ( $tag == 'contributor' ) {
                                $revisionInfo['contributor'] = $this->handleContributor();
                        } elseif ( $tag != '#text' ) {
                                $this->warn( "Unhandled revision XML tag $tag" );
                                $skip = true;
                        }
                }

                $pageInfo['revisionCount']++;
                if ( $this->processRevision( $pageInfo, $revisionInfo ) ) {
                        $pageInfo['successfulRevisionCount']++;
                }
        }

        private function processRevision( $pageInfo, $revisionInfo ) {
                $revision = new WikiRevision;

                if( isset( $revisionInfo['id'] ) ) {
                        $revision->setID( $revisionInfo['id'] );
                }
                if ( isset( $revisionInfo['text'] ) ) {
                        $revision->setText( $revisionInfo['text'] );
                }
                if ( isset( $revisionInfo['model'] ) ) {
                        $revision->setModel( $revisionInfo['model'] );
                }
                if ( isset( $revisionInfo['format'] ) ) {
                        $revision->setFormat( $revisionInfo['format'] );
                }
                $revision->setTitle( $pageInfo['_title'] );

                if ( isset( $revisionInfo['timestamp'] ) ) {
                        $revision->setTimestamp( $revisionInfo['timestamp'] );
                } else {
                        $revision->setTimestamp( wfTimestampNow() );
                }

                if ( isset( $revisionInfo['comment'] ) ) {
                        $revision->setComment( $revisionInfo['comment'] );
                }

                if ( isset( $revisionInfo['minor'] ) ) {
                        $revision->setMinor( true );
                }
                if ( isset( $revisionInfo['contributor']['ip'] ) ) {
                        $revision->setUserIP( $revisionInfo['contributor']['ip'] );
                }
                if ( isset( $revisionInfo['contributor']['username'] ) ) {
                        $revision->setUserName( $revisionInfo['contributor']['username'] );
                }
                $revision->setNoUpdates( $this->mNoUpdates );

                return $this->revisionCallback( $revision );
        }

        private function handleUpload( &$pageInfo ) {
                $this->debug( "Enter upload handler" );
                $uploadInfo = array();

                $normalFields = array( 'timestamp', 'comment', 'filename', 'text',
                                        'src', 'size', 'sha1base36', 'archivename', 'rel' );

                $skip = false;

                while ( $skip ? $this->reader->next() : $this->reader->read() ) {
                        if ( $this->reader->nodeType == XmlReader::END_ELEMENT &&
                                        $this->reader->name == 'upload') {
                                break;
                        }

                        $tag = $this->reader->name;

                        if ( !wfRunHooks( 'ImportHandleUploadXMLTag', $this,
                                                $pageInfo ) ) {
                                // Do nothing
                        } elseif ( in_array( $tag, $normalFields ) ) {
                                $uploadInfo[$tag] = $this->nodeContents();
                        } elseif ( $tag == 'contributor' ) {
                                $uploadInfo['contributor'] = $this->handleContributor();
                        } elseif ( $tag == 'contents' ) {
                                $contents = $this->nodeContents();
                                $encoding = $this->reader->getAttribute( 'encoding' );
                                if ( $encoding === 'base64' ) {
                                        $uploadInfo['fileSrc'] = $this->dumpTemp( base64_decode( $contents ) );
                                        $uploadInfo['isTempSrc'] = true;
                                }
                        } elseif ( $tag != '#text' ) {
                                $this->warn( "Unhandled upload XML tag $tag" );
                                $skip = true;
                        }
                }

                if ( $this->mImageBasePath && isset( $uploadInfo['rel'] ) ) {
                        $path = "{$this->mImageBasePath}/{$uploadInfo['rel']}";
                        if ( file_exists( $path ) ) {
                                $uploadInfo['fileSrc'] = $path;
                                $uploadInfo['isTempSrc'] = false;
                        }
                }

                if ( $this->mImportUploads ) {
                        return $this->processUpload( $pageInfo, $uploadInfo );
                }
        }

        private function dumpTemp( $contents ) {
                $filename = tempnam( wfTempDir(), 'importupload' );
                file_put_contents( $filename, $contents );
                return $filename;
        }

        private function processUpload( $pageInfo, $uploadInfo ) {
                $revision = new WikiRevision;
                $text = isset( $uploadInfo['text'] ) ? $uploadInfo['text'] : '';

                $revision->setTitle( $pageInfo['_title'] );
                $revision->setID( $pageInfo['id'] );
                $revision->setTimestamp( $uploadInfo['timestamp'] );
                $revision->setText( $text );
                $revision->setFilename( $uploadInfo['filename'] );
                if ( isset( $uploadInfo['archivename'] ) ) {
                        $revision->setArchiveName( $uploadInfo['archivename'] );
                }
                $revision->setSrc( $uploadInfo['src'] );
                if ( isset( $uploadInfo['fileSrc'] ) ) {
                        $revision->setFileSrc( $uploadInfo['fileSrc'],
                                !empty( $uploadInfo['isTempSrc'] ) );
                }
                if ( isset( $uploadInfo['sha1base36'] ) ) {
                        $revision->setSha1Base36( $uploadInfo['sha1base36'] );
                }
                $revision->setSize( intval( $uploadInfo['size'] ) );
                $revision->setComment( $uploadInfo['comment'] );

                if ( isset( $uploadInfo['contributor']['ip'] ) ) {
                        $revision->setUserIP( $uploadInfo['contributor']['ip'] );
                }
                if ( isset( $uploadInfo['contributor']['username'] ) ) {
                        $revision->setUserName( $uploadInfo['contributor']['username'] );
                }
                $revision->setNoUpdates( $this->mNoUpdates );

                return call_user_func( $this->mUploadCallback, $revision );
        }

        private function handleContributor() {
                $fields = array( 'id', 'ip', 'username' );
                $info = array();

                while ( $this->reader->read() ) {
                        if ( $this->reader->nodeType == XmlReader::END_ELEMENT &&
                                        $this->reader->name == 'contributor') {
                                break;
                        }

                        $tag = $this->reader->name;

                        if ( in_array( $tag, $fields ) ) {
                                $info[$tag] = $this->nodeContents();
                        }
                }

                return $info;
        }

        private function processTitle( $text ) {
                global $wgCommandLineMode;

                $workTitle = $text;
                $origTitle = Title::newFromText( $workTitle );

                if( !is_null( $this->mTargetNamespace ) && !is_null( $origTitle ) ) {
                        # makeTitleSafe, because $origTitle can have a interwiki (different setting of interwiki map)
                        # and than dbKey can begin with a lowercase char
                        $title = Title::makeTitleSafe( $this->mTargetNamespace,
                                $origTitle->getDBkey() );
                } else {
                        if( !is_null( $this->mTargetRootPage ) ) {
                                $workTitle = $this->mTargetRootPage . '/' . $workTitle;
                        }
                        $title = Title::newFromText( $workTitle );
                }

                if( is_null( $title ) ) {
                        # Invalid page title? Ignore the page
                        $this->notice( 'import-error-invalid', $workTitle );
                        return false;
                } elseif( $title->isExternal() ) {
                        $this->notice( 'import-error-interwiki', $title->getPrefixedText() );
                        return false;
                } elseif( !$title->canExist() ) {
                        $this->notice( 'import-error-special', $title->getPrefixedText() );
                        return false;
                } elseif( !$title->userCan( 'edit' ) && !$wgCommandLineMode ) {
                        # Do not import if the importing wiki user cannot edit this page
                        $this->notice( 'import-error-edit', $title->getPrefixedText() );
                        return false;
                } elseif( !$title->exists() && !$title->userCan( 'create' ) && !$wgCommandLineMode ) {
                        # Do not import if the importing wiki user cannot create this page
                        $this->notice( 'import-error-create', $title->getPrefixedText() );
                        return false;
                }

                return array( $title, $origTitle );
        }
}

class UploadSourceAdapter {
        static $sourceRegistrations = array();

        private $mSource;
        private $mBuffer;
        private $mPosition;

        static function registerSource( $source ) {
                $id = wfRandomString();

                self::$sourceRegistrations[$id] = $source;

                return $id;
        }

        function stream_open( $path, $mode, $options, &$opened_path ) {
                $url = parse_url($path);
                $id = $url['host'];

                if ( !isset( self::$sourceRegistrations[$id] ) ) {
                        return false;
                }

                $this->mSource = self::$sourceRegistrations[$id];

                return true;
        }

        function stream_read( $count ) {
                $return = '';
                $leave = false;

                while ( !$leave && !$this->mSource->atEnd() &&
                                strlen($this->mBuffer) < $count ) {
                        $read = $this->mSource->readChunk();

                        if ( !strlen($read) ) {
                                $leave = true;
                        }

                        $this->mBuffer .= $read;
                }

                if ( strlen($this->mBuffer) ) {
                        $return = substr( $this->mBuffer, 0, $count );
                        $this->mBuffer = substr( $this->mBuffer, $count );
                }

                $this->mPosition += strlen($return);

                return $return;
        }

        function stream_write( $data ) {
                return false;
        }

        function stream_tell() {
                return $this->mPosition;
        }

        function stream_eof() {
                return $this->mSource->atEnd();
        }

        function url_stat() {
                $result = array();

                $result['dev'] = $result[0] = 0;
                $result['ino'] = $result[1] = 0;
                $result['mode'] = $result[2] = 0;
                $result['nlink'] = $result[3] = 0;
                $result['uid'] = $result[4] = 0;
                $result['gid'] = $result[5] = 0;
                $result['rdev'] = $result[6] = 0;
                $result['size'] = $result[7] = 0;
                $result['atime'] = $result[8] = 0;
                $result['mtime'] = $result[9] = 0;
                $result['ctime'] = $result[10] = 0;
                $result['blksize'] = $result[11] = 0;
                $result['blocks'] = $result[12] = 0;

                return $result;
        }
}

class XMLReader2 extends XMLReader {

        function nodeContents() {
                if( $this->isEmptyElement ) {
                        return "";
                }
                $buffer = "";
                while( $this->read() ) {
                        switch( $this->nodeType ) {
                        case XmlReader::TEXT:
                        case XmlReader::SIGNIFICANT_WHITESPACE:
                                $buffer .= $this->value;
                                break;
                        case XmlReader::END_ELEMENT:
                                return $buffer;
                        }
                }
                return $this->close();
        }
}

class WikiRevision {
        var $importer = null;

        var $title = null;
        var $id = 0;
        var $timestamp = "20010115000000";
        var $user = 0;
        var $user_text = "";
        var $model = null;
        var $format = null;
        var $text = "";
        var $content = null;
        var $comment = "";
        var $minor = false;
        var $type = "";
        var $action = "";
        var $params = "";
        var $fileSrc = '';
        var $sha1base36 = false;
        var $isTemp = false;
        var $archiveName = '';
        var $fileIsTemp;
        private $mNoUpdates = false;

        function setTitle( $title ) {
                if( is_object( $title ) ) {
                        $this->title = $title;
                } elseif( is_null( $title ) ) {
                        throw new MWException( "WikiRevision given a null title in import. You may need to adjust \$wgLegalTitleChars." );
                } else {
                        throw new MWException( "WikiRevision given non-object title in import." );
                }
        }

        function setID( $id ) {
                $this->id = $id;
        }

        function setTimestamp( $ts ) {
                # 2003-08-05T18:30:02Z
                $this->timestamp = wfTimestamp( TS_MW, $ts );
        }

        function setUsername( $user ) {
                $this->user_text = $user;
        }

        function setUserIP( $ip ) {
                $this->user_text = $ip;
        }

        function setModel( $model ) {
                $this->model = $model;
        }

        function setFormat( $format ) {
                $this->format = $format;
        }

        function setText( $text ) {
                $this->text = $text;
        }

        function setComment( $text ) {
                $this->comment = $text;
        }

        function setMinor( $minor ) {
                $this->minor = (bool)$minor;
        }

        function setSrc( $src ) {
                $this->src = $src;
        }

        function setFileSrc( $src, $isTemp ) {
                $this->fileSrc = $src;
                $this->fileIsTemp = $isTemp;
        }

        function setSha1Base36( $sha1base36 ) {
                $this->sha1base36 = $sha1base36;
        }

        function setFilename( $filename ) {
                $this->filename = $filename;
        }

        function setArchiveName( $archiveName ) {
                $this->archiveName = $archiveName;
        }

        function setSize( $size ) {
                $this->size = intval( $size );
        }

        function setType( $type ) {
                $this->type = $type;
        }

        function setAction( $action ) {
                $this->action = $action;
        }

        function setParams( $params ) {
                $this->params = $params;
        }

        public function setNoUpdates( $noupdates ) {
                $this->mNoUpdates = $noupdates;
        }

        function getTitle() {
                return $this->title;
        }

        function getID() {
                return $this->id;
        }

        function getTimestamp() {
                return $this->timestamp;
        }

        function getUser() {
                return $this->user_text;
        }

        function getText() {
                ContentHandler::deprecated( __METHOD__, '1.21' );

                return $this->text;
        }

        function getContent() {
                if ( is_null( $this->content ) ) {
                        $this->content =
                                ContentHandler::makeContent(
                                        $this->text,
                                        $this->getTitle(),
                                        $this->getModel(),
                                        $this->getFormat()
                                );
                }

                return $this->content;
        }

        function getModel() {
                if ( is_null( $this->model ) ) {
                        $this->model = $this->getTitle()->getContentModel();
                }

                return $this->model;
        }

        function getFormat() {
                if ( is_null( $this->model ) ) {
                        $this->format = ContentHandler::getForTitle( $this->getTitle() )->getDefaultFormat();
                }

                return $this->format;
        }

        function getComment() {
                return $this->comment;
        }

        function getMinor() {
                return $this->minor;
        }

        function getSrc() {
                return $this->src;
        }

        function getSha1() {
                if ( $this->sha1base36 ) {
                        return wfBaseConvert( $this->sha1base36, 36, 16 );
                }
                return false;
        }

        function getFileSrc() {
                return $this->fileSrc;
        }

        function isTempSrc() {
                return $this->isTemp;
        }

        function getFilename() {
                return $this->filename;
        }

        function getArchiveName() {
                return $this->archiveName;
        }

        function getSize() {
                return $this->size;
        }

        function getType() {
                return $this->type;
        }

        function getAction() {
                return $this->action;
        }

        function getParams() {
                return $this->params;
        }

        function importOldRevision() {
                $dbw = wfGetDB( DB_MASTER );

                # Sneak a single revision into place
                $user = User::newFromName( $this->getUser() );
                if( $user ) {
                        $userId = intval( $user->getId() );
                        $userText = $user->getName();
                        $userObj = $user;
                } else {
                        $userId = 0;
                        $userText = $this->getUser();
                        $userObj = new User;
                }

                // avoid memory leak...?
                $linkCache = LinkCache::singleton();
                $linkCache->clear();

                $page = WikiPage::factory( $this->title );
                if( !$page->exists() ) {
                        # must create the page...
                        $pageId = $page->insertOn( $dbw );
                        $created = true;
                        $oldcountable = null;
                } else {
                        $pageId = $page->getId();
                        $created = false;

                        $prior = $dbw->selectField( 'revision', '1',
                                array( 'rev_page' => $pageId,
                                        'rev_timestamp' => $dbw->timestamp( $this->timestamp ),
                                        'rev_user_text' => $userText,
                                        'rev_comment'   => $this->getComment() ),
                                __METHOD__
                        );
                        if( $prior ) {
                                // @todo FIXME: This could fail slightly for multiple matches :P
                                wfDebug( __METHOD__ . ": skipping existing revision for [[" .
                                        $this->title->getPrefixedText() . "]], timestamp " . $this->timestamp . "\n" );
                                return false;
                        }
                        $oldcountable = $page->isCountable();
                }

                # @todo FIXME: Use original rev_id optionally (better for backups)
                # Insert the row
                $revision = new Revision( array(
                        'title'      => $this->title,
                        'page'       => $pageId,
                        'content_model'  => $this->getModel(),
                        'content_format' => $this->getFormat(),
                        'text'       => $this->getContent()->serialize( $this->getFormat() ), //XXX: just set 'content' => $this->getContent()?
                        'comment'    => $this->getComment(),
                        'user'       => $userId,
                        'user_text'  => $userText,
                        'timestamp'  => $this->timestamp,
                        'minor_edit' => $this->minor,
                        ) );
                $revision->insertOn( $dbw );
                $changed = $page->updateIfNewerOn( $dbw, $revision );

                if ( $changed !== false && !$this->mNoUpdates ) {
                        wfDebug( __METHOD__ . ": running updates\n" );
                        $page->doEditUpdates( $revision, $userObj, array( 'created' => $created, 'oldcountable' => $oldcountable ) );
                }

                return true;
        }

        function importLogItem() {
                $dbw = wfGetDB( DB_MASTER );
                # @todo FIXME: This will not record autoblocks
                if( !$this->getTitle() ) {
                        wfDebug( __METHOD__ . ": skipping invalid {$this->type}/{$this->action} log time, timestamp " .
                                $this->timestamp . "\n" );
                        return;
                }
                # Check if it exists already
                // @todo FIXME: Use original log ID (better for backups)
                $prior = $dbw->selectField( 'logging', '1',
                        array( 'log_type' => $this->getType(),
                                'log_action'    => $this->getAction(),
                                'log_timestamp' => $dbw->timestamp( $this->timestamp ),
                                'log_namespace' => $this->getTitle()->getNamespace(),
                                'log_title'     => $this->getTitle()->getDBkey(),
                                'log_comment'   => $this->getComment(),
                                #'log_user_text' => $this->user_text,
                                'log_params'    => $this->params ),
                        __METHOD__
                );
                // @todo FIXME: This could fail slightly for multiple matches :P
                if( $prior ) {
                        wfDebug( __METHOD__ . ": skipping existing item for Log:{$this->type}/{$this->action}, timestamp " .
                                $this->timestamp . "\n" );
                        return;
                }
                $log_id = $dbw->nextSequenceValue( 'logging_log_id_seq' );
                $data = array(
                        'log_id' => $log_id,
                        'log_type' => $this->type,
                        'log_action' => $this->action,
                        'log_timestamp' => $dbw->timestamp( $this->timestamp ),
                        'log_user' => User::idFromName( $this->user_text ),
                        #'log_user_text' => $this->user_text,
                        'log_namespace' => $this->getTitle()->getNamespace(),
                        'log_title' => $this->getTitle()->getDBkey(),
                        'log_comment' => $this->getComment(),
                        'log_params' => $this->params
                );
                $dbw->insert( 'logging', $data, __METHOD__ );
        }

        function importUpload() {
                # Construct a file
                $archiveName = $this->getArchiveName();
                if ( $archiveName ) {
                        wfDebug( __METHOD__ . "Importing archived file as $archiveName\n" );
                        $file = OldLocalFile::newFromArchiveName( $this->getTitle(),
                                RepoGroup::singleton()->getLocalRepo(), $archiveName );
                } else {
                        $file = wfLocalFile( $this->getTitle() );
                        wfDebug( __METHOD__ . 'Importing new file as ' . $file->getName() . "\n" );
                        if ( $file->exists() && $file->getTimestamp() > $this->getTimestamp() ) {
                                $archiveName = $file->getTimestamp() . '!' . $file->getName();
                                $file = OldLocalFile::newFromArchiveName( $this->getTitle(),
                                        RepoGroup::singleton()->getLocalRepo(), $archiveName );
                                wfDebug( __METHOD__ . "File already exists; importing as $archiveName\n" );
                        }
                }
                if( !$file ) {
                        wfDebug( __METHOD__ . ': Bad file for ' . $this->getTitle() . "\n" );
                        return false;
                }

                # Get the file source or download if necessary
                $source = $this->getFileSrc();
                $flags = $this->isTempSrc() ? File::DELETE_SOURCE : 0;
                if ( !$source ) {
                        $source = $this->downloadSource();
                        $flags |= File::DELETE_SOURCE;
                }
                if( !$source ) {
                        wfDebug( __METHOD__ . ": Could not fetch remote file.\n" );
                        return false;
                }
                $sha1 = $this->getSha1();
                if ( $sha1 && ( $sha1 !== sha1_file( $source ) ) ) {
                        if ( $flags & File::DELETE_SOURCE ) {
                                # Broken file; delete it if it is a temporary file
                                unlink( $source );
                        }
                        wfDebug( __METHOD__ . ": Corrupt file $source.\n" );
                        return false;
                }

                $user = User::newFromName( $this->user_text );

                # Do the actual upload
                if ( $archiveName ) {
                        $status = $file->uploadOld( $source, $archiveName,
                                $this->getTimestamp(), $this->getComment(), $user, $flags );
                } else {
                        $status = $file->upload( $source, $this->getComment(), $this->getComment(),
                                $flags, false, $this->getTimestamp(), $user );
                }

                if ( $status->isGood() ) {
                        wfDebug( __METHOD__ . ": Succesful\n" );
                        return true;
                } else {
                        wfDebug( __METHOD__ . ': failed: ' . $status->getXml() . "\n" );
                        return false;
                }
        }

        function downloadSource() {
                global $wgEnableUploads;
                if( !$wgEnableUploads ) {
                        return false;
                }

                $tempo = tempnam( wfTempDir(), 'download' );
                $f = fopen( $tempo, 'wb' );
                if( !$f ) {
                        wfDebug( "IMPORT: couldn't write to temp file $tempo\n" );
                        return false;
                }

                // @todo FIXME!
                $src = $this->getSrc();
                $data = Http::get( $src );
                if( !$data ) {
                        wfDebug( "IMPORT: couldn't fetch source $src\n" );
                        fclose( $f );
                        unlink( $tempo );
                        return false;
                }

                fwrite( $f, $data );
                fclose( $f );

                return $tempo;
        }

}

class ImportStringSource {
        function __construct( $string ) {
                $this->mString = $string;
                $this->mRead = false;
        }

        function atEnd() {
                return $this->mRead;
        }

        function readChunk() {
                if( $this->atEnd() ) {
                        return false;
                }
                $this->mRead = true;
                return $this->mString;
        }
}

class ImportStreamSource {
        function __construct( $handle ) {
                $this->mHandle = $handle;
        }

        function atEnd() {
                return feof( $this->mHandle );
        }

        function readChunk() {
                return fread( $this->mHandle, 32768 );
        }

        static function newFromFile( $filename ) {
                wfSuppressWarnings();
                $file = fopen( $filename, 'rt' );
                wfRestoreWarnings();
                if( !$file ) {
                        return Status::newFatal( "importcantopen" );
                }
                return Status::newGood( new ImportStreamSource( $file ) );
        }

        static function newFromUpload( $fieldname = "xmlimport" ) {
                $upload =& $_FILES[$fieldname];

                if( !isset( $upload ) || !$upload['name'] ) {
                        return Status::newFatal( 'importnofile' );
                }
                if( !empty( $upload['error'] ) ) {
                        switch($upload['error']){
                                case 1: # The uploaded file exceeds the upload_max_filesize directive in php.ini.
                                        return Status::newFatal( 'importuploaderrorsize' );
                                case 2: # The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form.
                                        return Status::newFatal( 'importuploaderrorsize' );
                                case 3: # The uploaded file was only partially uploaded
                                        return Status::newFatal( 'importuploaderrorpartial' );
                                case 6: #Missing a temporary folder.
                                        return Status::newFatal( 'importuploaderrortemp' );
                                # case else: # Currently impossible
                        }

                }
                $fname = $upload['tmp_name'];
                if( is_uploaded_file( $fname ) ) {
                        return ImportStreamSource::newFromFile( $fname );
                } else {
                        return Status::newFatal( 'importnofile' );
                }
        }

        static function newFromURL( $url, $method = 'GET' ) {
                wfDebug( __METHOD__ . ": opening $url\n" );
                # Use the standard HTTP fetch function; it times out
                # quicker and sorts out user-agent problems which might
                # otherwise prevent importing from large sites, such
                # as the Wikimedia cluster, etc.
                $data = Http::request( $method, $url, array( 'followRedirects' => true ) );
                if( $data !== false ) {
                        $file = tmpfile();
                        fwrite( $file, $data );
                        fflush( $file );
                        fseek( $file, 0 );
                        return Status::newGood( new ImportStreamSource( $file ) );
                } else {
                        return Status::newFatal( 'importcantopen' );
                }
        }

        public static function newFromInterwiki( $interwiki, $page, $history = false, $templates = false, $pageLinkDepth = 0 ) {
                if( $page == '' ) {
                        return Status::newFatal( 'import-noarticle' );
                }
                $link = Title::newFromText( "$interwiki:Special:Export/$page" );
                if( is_null( $link ) || $link->getInterwiki() == '' ) {
                        return Status::newFatal( 'importbadinterwiki' );
                } else {
                        $params = array();
                        if ( $history ) $params['history'] = 1;
                        if ( $templates ) $params['templates'] = 1;
                        if ( $pageLinkDepth ) $params['pagelink-depth'] = $pageLinkDepth;
                        $url = $link->getFullUrl( $params );
                        # For interwikis, use POST to avoid redirects.
                        return ImportStreamSource::newFromURL( $url, "POST" );
                }
        }
}