UploadFromUrl.php

Go to the documentation of this file.

<?php
class UploadFromUrl extends UploadBase {
        protected $mAsync, $mUrl;
        protected $mIgnoreWarnings = true;

        protected $mTempPath, $mTmpHandle;

        public static function isAllowed( $user ) {
                if ( !$user->isAllowed( 'upload_by_url' ) ) {
                        return 'upload_by_url';
                }
                return parent::isAllowed( $user );
        }

        public static function isEnabled() {
                global $wgAllowCopyUploads;
                return $wgAllowCopyUploads && parent::isEnabled();
        }

        public static function isAllowedHost( $url ) {
                global $wgCopyUploadsDomains;
                if ( !count( $wgCopyUploadsDomains ) ) {
                        return true;
                }
                $parsedUrl = wfParseUrl( $url );
                if ( !$parsedUrl ) {
                        return false;
                }
                $valid = false;
                foreach( $wgCopyUploadsDomains as $domain ) {
                        if ( $parsedUrl['host'] === $domain ) {
                                $valid = true;
                                break;
                        }
                }
                return $valid;
        }

        public function initialize( $name, $url, $async = false ) {
                global $wgAllowAsyncCopyUploads;

                $this->mUrl = $url;
                $this->mAsync = $wgAllowAsyncCopyUploads ? $async : false;
                if ( $async ) {
                        throw new MWException( 'Asynchronous copy uploads are no longer possible as of r81612.' );
                }

                $tempPath = $this->mAsync ? null : $this->makeTemporaryFile();
                # File size and removeTempFile will be filled in later
                $this->initializePathInfo( $name, $tempPath, 0, false );
        }

        public function initializeFromRequest( &$request ) {
                $desiredDestName = $request->getText( 'wpDestFile' );
                if ( !$desiredDestName ) {
                        $desiredDestName = $request->getText( 'wpUploadFileURL' );
                }
                $this->initialize(
                        $desiredDestName,
                        trim( $request->getVal( 'wpUploadFileURL' ) ),
                        false
                );
        }

        public static function isValidRequest( $request ) {
                global $wgUser;

                $url = $request->getVal( 'wpUploadFileURL' );
                return !empty( $url )
                        && Http::isValidURI( $url )
                        && $wgUser->isAllowed( 'upload_by_url' );
        }

        public function getSourceType() { return 'url'; }

        public function fetchFile() {
                if ( !Http::isValidURI( $this->mUrl ) ) {
                        return Status::newFatal( 'http-invalid-url' );
                }

                if( !self::isAllowedHost( $this->mUrl ) ) {
                        return Status::newFatal( 'upload-copy-upload-invalid-domain' );
                }
                if ( !$this->mAsync ) {
                        return $this->reallyFetchFile();
                }
                return Status::newGood();
        }
        protected function makeTemporaryFile() {
                return tempnam( wfTempDir(), 'URL' );
        }

        public function saveTempFileChunk( $req, $buffer ) {
                $nbytes = fwrite( $this->mTmpHandle, $buffer );

                if ( $nbytes == strlen( $buffer ) ) {
                        $this->mFileSize += $nbytes;
                } else {
                        // Well... that's not good!
                        fclose( $this->mTmpHandle );
                        $this->mTmpHandle = false;
                }

                return $nbytes;
        }

        protected function reallyFetchFile() {
                if ( $this->mTempPath === false ) {
                        return Status::newFatal( 'tmp-create-error' );
                }

                // Note the temporary file should already be created by makeTemporaryFile()
                $this->mTmpHandle = fopen( $this->mTempPath, 'wb' );
                if ( !$this->mTmpHandle ) {
                        return Status::newFatal( 'tmp-create-error' );
                }

                $this->mRemoveTempFile = true;
                $this->mFileSize = 0;

                $options = array(
                        'followRedirects' => true
                );
                global $wgCopyUploadProxy;
                if ( $wgCopyUploadProxy !== false ) {
                        $options['proxy'] = $wgCopyUploadProxy;
                }
                $req = MWHttpRequest::factory( $this->mUrl, $options );
                $req->setCallback( array( $this, 'saveTempFileChunk' ) );
                $status = $req->execute();

                if ( $this->mTmpHandle ) {
                        // File got written ok...
                        fclose( $this->mTmpHandle );
                        $this->mTmpHandle = null;
                } else {
                        // We encountered a write error during the download...
                        return Status::newFatal( 'tmp-write-error' );
                }

                if ( !$status->isOk() ) {
                        return $status;
                }

                return $status;
        }

        public function verifyUpload() {
                if ( $this->mAsync ) {
                        return array( 'status' => UploadBase::OK );
                }
                return parent::verifyUpload();
        }

        public function checkWarnings() {
                if ( $this->mAsync ) {
                        $this->mIgnoreWarnings = false;
                        return array();
                }
                return parent::checkWarnings();
        }

        public function verifyTitlePermissions( $user ) {
                if ( $this->mAsync ) {
                        return true;
                }
                return parent::verifyTitlePermissions( $user );
        }

        public function performUpload( $comment, $pageText, $watch, $user ) {
                if ( $this->mAsync ) {
                        $sessionKey = $this->insertJob( $comment, $pageText, $watch, $user );

                        return Status::newFatal( 'async', $sessionKey );
                }

                return parent::performUpload( $comment, $pageText, $watch, $user );
        }

        protected function insertJob( $comment, $pageText, $watch, $user ) {
                $sessionKey = $this->stashSession();
                $job = new UploadFromUrlJob( $this->getTitle(), array(
                        'url' => $this->mUrl,
                        'comment' => $comment,
                        'pageText' => $pageText,
                        'watch' => $watch,
                        'userName' => $user->getName(),
                        'leaveMessage' => $this->mAsync == 'async-leavemessage',
                        'ignoreWarnings' => $this->mIgnoreWarnings,
                        'sessionId' => session_id(),
                        'sessionKey' => $sessionKey,
                ) );
                $job->initializeSessionData();
                $job->insert();
                return $sessionKey;
        }

}