UploadBase.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Upload;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\Api\ApiMessage;
use MediaWiki\Api\ApiResult;
use MediaWiki\Api\ApiUpload;
use MediaWiki\FileRepo\File\ArchivedFile;
use MediaWiki\FileRepo\File\File;
use MediaWiki\FileRepo\File\LocalFile;
use MediaWiki\FileRepo\FileRepo;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Request\WebRequest;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use MediaWiki\Upload\Exception\UploadStashException;
use MediaWiki\User\User;
use MediaWiki\User\UserIdentity;
use MediaWiki\Utils\MWFileProps;
use Wikimedia\FileBackend\FileBackend;
use Wikimedia\FileBackend\FSFile\FSFile;
use Wikimedia\FileBackend\FSFile\TempFSFile;
use Wikimedia\Message\ListType;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\ObjectCache\BagOStuff;
use Wikimedia\Rdbms\IDBAccessObject;
 
abstract class UploadBase {
    use ProtectedHookAccessorTrait;
 
    protected $mTempPath;
    protected $tempFileObj;
    protected $mDesiredDestName;
    protected $mDestName;
    protected $mRemoveTempFile;
    protected $mSourceType;
    protected $mTitle = false;
    protected $mTitleError = 0;
    protected $mFilteredName;
    protected $mFinalExtension;
    protected $mLocalFile;
    protected $mStashFile;
    protected $mFileSize;
    protected $mFileProps;
    protected $mBlackListedExtensions;
 
    private UploadVerification $uploadVerification;
 
    public const SUCCESS = 0;
    public const OK = 0;
    public const EMPTY_FILE = 3;
    public const MIN_LENGTH_PARTNAME = 4;
    public const ILLEGAL_FILENAME = 5;
    public const FILETYPE_MISSING = 8;
    public const FILETYPE_BADTYPE = 9;
    public const VERIFICATION_ERROR = 10;
    public const FILE_TOO_LARGE = 12;
    public const WINDOWS_NONASCII_FILENAME = 13;
    public const FILENAME_TOO_LONG = 14;
 
    private const CODE_TO_STATUS = [
        self::EMPTY_FILE => 'empty-file',
        self::FILE_TOO_LARGE => 'file-too-large',
        self::FILETYPE_MISSING => 'filetype-missing',
        self::FILETYPE_BADTYPE => 'filetype-banned',
        self::MIN_LENGTH_PARTNAME => 'filename-tooshort',
        self::ILLEGAL_FILENAME => 'illegal-filename',
        self::VERIFICATION_ERROR => 'verification-error',
        self::WINDOWS_NONASCII_FILENAME => 'windows-nonascii-filename',
        self::FILENAME_TOO_LONG => 'filename-toolong',
    ];
 
    private const CORE_UPLOAD_HANDLERS = [
        'Stash' => UploadFromStash::class,
        'File' => UploadFromFile::class,
        'Url' => UploadFromUrl::class,
    ];
 
    public function getVerificationErrorCode( $error ) {
        return self::CODE_TO_STATUS[$error] ?? 'unknown-error';
    }
 
    public static function isEnabled() {
        $enableUploads = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::EnableUploads );
 
        return $enableUploads && wfIniGetBool( 'file_uploads' );
    }
 
    public static function isAllowed( Authority $performer ) {
        foreach ( [ 'upload', 'edit' ] as $permission ) {
            if ( !$performer->isAllowed( $permission ) ) {
                return $permission;
            }
        }
 
        return true;
    }
 
    public static function isThrottled( $user ) {
        wfDeprecated( __METHOD__, '1.41' );
        return $user->pingLimiter( 'upload' );
    }
 
    public static function createFromRequest( &$request, $type = null ) {
        $type = $type ?: $request->getVal( 'wpSourceType', 'File' );
 
        if ( !$type ) {
            return null;
        }
 
        // Get the upload class
        $type = ucfirst( $type );
 
        // Give hooks the chance to handle this request
        $className = null;
        ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
            // @phan-suppress-next-line PhanTypeMismatchArgument Type mismatch on pass-by-ref args
            ->onUploadCreateFromRequest( $type, $className );
        if ( $className === null ) {
            if ( !isset( self::CORE_UPLOAD_HANDLERS[$type] ) ) {
                wfDebug( __METHOD__ . ": no class name for $type" );
                return null;
            }
            $className = self::CORE_UPLOAD_HANDLERS[$type];
            wfDebug( __METHOD__ . ": class name: $className" );
        }
 
        if ( !$className::isEnabled() || !$className::isValidRequest( $request ) ) {
            return null;
        }
 
        $handler = new $className;
 
        $handler->initializeFromRequest( $request );
 
        return $handler;
    }
 
    public static function isValidRequest( $request ) {
        return false;
    }
 
    public function getDesiredDestName() {
        return $this->mDesiredDestName;
    }
 
    public function __construct() {
        $this->uploadVerification = MediaWikiServices::getInstance()->getUploadVerification();
    }
 
    public function getSourceType() {
        return null;
    }
 
    public function initializePathInfo( $name, $tempPath, $fileSize, $removeTempFile = false ) {
        $this->mDesiredDestName = $name;
        if ( FileBackend::isStoragePath( $tempPath ) ) {
            throw new InvalidArgumentException( __METHOD__ . " given storage path `$tempPath`." );
        }
 
        $this->setTempFile( $tempPath, $fileSize );
        $this->mRemoveTempFile = $removeTempFile;
    }
 
    abstract public function initializeFromRequest( &$request );
 
    protected function setTempFile( $tempPath, $fileSize = null ) {
        $this->mTempPath = $tempPath ?? '';
        $this->mFileSize = $fileSize ?: null;
        $this->mFileProps = null;
        if ( $this->mTempPath !== '' && file_exists( $this->mTempPath ) ) {
            $this->tempFileObj = new TempFSFile( $this->mTempPath );
            if ( !$fileSize ) {
                $this->mFileSize = filesize( $this->mTempPath );
            }
        } else {
            $this->tempFileObj = null;
        }
    }
 
    public function fetchFile() {
        return Status::newGood();
    }
 
    public function canFetchFile() {
        return Status::newGood();
    }
 
    public function isEmptyFile() {
        return !$this->mFileSize;
    }
 
    public function getFileSize() {
        return $this->mFileSize;
    }
 
    public function getTempFileSha1Base36() {
        // Use cached version if we already have it.
        if ( $this->mFileProps && is_string( $this->mFileProps['sha1'] ) ) {
            return $this->mFileProps['sha1'];
        }
        return $this->mTempPath !== '' ? FSFile::getSha1Base36FromPath( $this->mTempPath ) : false;
    }
 
    public function getRealPath( $srcPath ) {
        $repo = MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo();
        if ( FileRepo::isVirtualUrl( $srcPath ) ) {
            $tmpFile = $repo->getLocalCopy( $srcPath );
            if ( $tmpFile ) {
                $tmpFile->bind( $this ); // keep alive with $this
            }
            $path = $tmpFile ? $tmpFile->getPath() : false;
        } else {
            $path = $srcPath;
        }
 
        return $path;
    }
 
    public function verifyUpload() {
        if ( $this->isEmptyFile() ) {
            return [ 'status' => self::EMPTY_FILE ];
        }
 
        $maxSize = self::getMaxUploadSize( $this->getSourceType() );
        if ( $this->mFileSize > $maxSize ) {
            return [
                'status' => self::FILE_TOO_LARGE,
                'max' => $maxSize,
            ];
        }
 
        $verification = $this->verifyFile();
        if ( $verification !== true ) {
            return [
                'status' => self::VERIFICATION_ERROR,
                'details' => $verification
            ];
        }
 
        $result = $this->validateName();
        if ( $result !== true ) {
            return $result;
        }
 
        return [ 'status' => self::OK ];
    }
 
    public function validateName() {
        $nt = $this->getTitle();
        if ( $nt === null ) {
            $result = [ 'status' => $this->mTitleError ];
            if ( $this->mTitleError === self::ILLEGAL_FILENAME ) {
                $result['filtered'] = $this->mFilteredName;
            }
            if ( $this->mTitleError === self::FILETYPE_BADTYPE ) {
                $result['finalExt'] = $this->mFinalExtension;
                if ( count( $this->mBlackListedExtensions ) ) {
                    $result['blacklistedExt'] = $this->mBlackListedExtensions;
                }
            }
 
            return $result;
        }
        $this->mDestName = $this->getLocalFile()->getName();
 
        return true;
    }
 
    protected function verifyMimeType( $mime ) {
        $verifyMimeType = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::VerifyMimeType );
        if ( $verifyMimeType ) {
            wfDebug( "mime: <$mime> extension: <{$this->mFinalExtension}>" );
            $mimeTypeExclusions = MediaWikiServices::getInstance()->getMainConfig()
                ->get( MainConfigNames::MimeTypeExclusions );
            if ( self::checkFileExtension( $mime, $mimeTypeExclusions ) ) {
                return [ 'filetype-badmime', $mime ];
            }
        }
 
        return true;
    }
 
    protected function verifyFile() {
        $status = $this->verifyPartialFile();
        if ( $status !== true ) {
            return $status;
        }
 
        $res = $this->uploadVerification->verifyFile(
            $this->mTempPath,
            (string)$this->mFinalExtension,
            $this->getFileProps()
        );
        if ( $res !== true ) {
            return $res;
        }
 
        $error = true;
        $mime = $this->getFileProps()['mime'];
        $this->getHookRunner()->onUploadVerifyFile( $this, $mime, $error );
        if ( $error !== true ) {
            if ( !is_array( $error ) ) {
                $error = [ $error ];
            }
            return $error;
        }
 
        return true;
    }
 
    protected function getFileProps(): array {
        // Force $this->mFinalExtension to be populated.
        $this->getTitle();
 
        if ( !is_array( $this->mFileProps ) ) {
            $mwProps = new MWFileProps( MediaWikiServices::getInstance()->getMimeAnalyzer() );
            $this->mFileProps = $mwProps->getPropsFromPath( $this->mTempPath, $this->mFinalExtension );
        }
        return $this->mFileProps;
    }
 
    protected function verifyPartialFile() {
        // Needed to set mFinalExtension.
        $this->getTitle();
        return $this->uploadVerification->verifyPartialFile(
            $this->mTempPath,
            (string)$this->mFinalExtension,
            $this->getFileProps()
        );
    }
 
    public function authorizeUpload( Authority $performer ): PermissionStatus {
        $status = PermissionStatus::newEmpty();
 
        $nt = $this->getTitle();
        if ( $nt === null ) {
            throw new LogicException( __METHOD__ . ' must only be called with valid title' );
        }
 
        // Return early when one of the permission checks fails, to avoid duplicate messages
        // when the user can neither edit nor upload, e.g. due to protection (T428124).
        // If the user can't upload at all, don't display additional errors about re-uploading.
        if ( !$performer->authorizeWrite( 'edit', $nt, $status ) ) {
            return $status;
        }
        if ( !$performer->authorizeWrite( 'upload', $nt, $status ) ) {
            return $status;
        }
 
        $overwriteError = $this->checkOverwrite( $performer );
        if ( $overwriteError !== true ) {
            $status->fatal( ...$overwriteError );
        }
 
        return $status;
    }
 
    public function checkWarnings( Authority $performer ): array {
        $warnings = [];
 
        $localFile = $this->getLocalFile();
        $localFile->load( IDBAccessObject::READ_LATEST );
        $filename = $localFile->getName();
        $hash = $this->getTempFileSha1Base36();
 
        $badFileName = $this->checkBadFileName( $filename, $this->mDesiredDestName );
        if ( $badFileName !== null ) {
            $warnings['badfilename'] = $badFileName;
        }
 
        $unwantedFileExtensionDetails = $this->checkUnwantedFileExtensions( (string)$this->mFinalExtension );
        if ( $unwantedFileExtensionDetails !== null ) {
            $warnings['filetype-unwanted-type'] = $unwantedFileExtensionDetails;
        }
 
        $fileSizeWarnings = $this->checkFileSize( $this->mFileSize );
        if ( $fileSizeWarnings ) {
            $warnings = array_merge( $warnings, $fileSizeWarnings );
        }
 
        $localFileExistsWarnings = $this->checkLocalFileExists( $localFile, $hash );
        if ( $localFileExistsWarnings ) {
            $warnings = array_merge( $warnings, $localFileExistsWarnings );
        }
 
        if ( $this->checkLocalFileWasDeleted( $localFile ) ) {
            $warnings['was-deleted'] = $filename;
        }
 
        // If a file with the same name exists locally then the local file has already been tested
        // for duplication of content
        $ignoreLocalDupes = isset( $warnings['exists'] );
        $dupes = $this->checkAgainstExistingDupes( $hash, $ignoreLocalDupes );
        if ( $dupes ) {
            $warnings['duplicate'] = $dupes;
        }
 
        $archivedDupes = $this->checkAgainstArchiveDupes( $hash, $performer );
        if ( $archivedDupes !== null ) {
            $warnings['duplicate-archive'] = $archivedDupes;
        }
 
        return $warnings;
    }
 
    public static function makeWarningsSerializable( $warnings ) {
        array_walk_recursive( $warnings, static function ( &$param, $key ) {
            if ( $param instanceof File ) {
                $param = [
                    'fileName' => $param->getName(),
                    'timestamp' => $param->getTimestamp()
                ];
            } elseif ( $param instanceof MessageParam ) {
                // Do nothing (T390001)
            } elseif ( is_object( $param ) ) {
                throw new InvalidArgumentException(
                    'UploadBase::makeWarningsSerializable: ' .
                    'Unexpected object of class ' . get_class( $param ) );
            }
        } );
        return $warnings;
    }
 
    public static function unserializeWarnings( $warnings ) {
        foreach ( $warnings as $key => $value ) {
            if ( is_array( $value ) ) {
                if ( isset( $value['fileName'] ) && isset( $value['timestamp'] ) ) {
                    $warnings[$key] = MediaWikiServices::getInstance()->getRepoGroup()->findFile(
                        $value['fileName'],
                        [ 'time' => $value['timestamp'] ]
                    );
                } else {
                    $warnings[$key] = self::unserializeWarnings( $value );
                }
            }
        }
        return $warnings;
    }
 
    private function checkBadFileName( $filename, $desiredFileName ) {
        $comparableName = str_replace( ' ', '_', $desiredFileName );
        $comparableName = Title::capitalize( $comparableName, NS_FILE );
 
        if ( $desiredFileName != $filename && $comparableName != $filename ) {
            return $filename;
        }
 
        return null;
    }
 
    private function checkUnwantedFileExtensions( $fileExtension ) {
        $checkFileExtensions = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::CheckFileExtensions );
        $fileExtensions = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::FileExtensions );
        if ( $checkFileExtensions ) {
            $extensions = array_unique( $fileExtensions );
            if ( !self::checkFileExtension( $fileExtension, $extensions ) ) {
                return [
                    $fileExtension,
                    Message::listParam( $extensions, ListType::COMMA ),
                    count( $extensions )
                ];
            }
        }
 
        return null;
    }
 
    private function checkFileSize( $fileSize ) {
        $uploadSizeWarning = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::UploadSizeWarning );
 
        $warnings = [];
 
        if ( $uploadSizeWarning && $fileSize !== null && $fileSize > $uploadSizeWarning ) {
            $warnings['large-file'] = [
                Message::sizeParam( $uploadSizeWarning ),
                Message::sizeParam( $fileSize ),
            ];
        }
 
        if ( $fileSize === 0 ) {
            $warnings['empty-file'] = true;
        }
 
        return $warnings;
    }
 
    private function checkLocalFileExists( LocalFile $localFile, $hash ) {
        $warnings = [];
 
        $exists = self::getExistsWarning( $localFile );
        if ( $exists !== false ) {
            $warnings['exists'] = $exists;
 
            // check if file is an exact duplicate of current file version
            if ( $hash !== false && $hash === $localFile->getSha1() ) {
                $warnings['no-change'] = $localFile;
            }
 
            // check if file is an exact duplicate of older versions of this file
            $history = $localFile->getHistory();
            foreach ( $history as $oldFile ) {
                if ( $hash === $oldFile->getSha1() ) {
                    $warnings['duplicate-version'][] = $oldFile;
                }
            }
        }
 
        return $warnings;
    }
 
    private function checkLocalFileWasDeleted( LocalFile $localFile ): bool {
        return $localFile->wasDeleted() && !$localFile->exists();
    }
 
    private function checkAgainstExistingDupes( $hash, $ignoreLocalDupes ) {
        if ( $hash === false ) {
            return [];
        }
        $dupes = MediaWikiServices::getInstance()->getRepoGroup()->findBySha1( $hash );
        $title = $this->getTitle();
        foreach ( $dupes as $key => $dupe ) {
            if (
                ( $dupe instanceof LocalFile ) &&
                $ignoreLocalDupes &&
                $title->equals( $dupe->getTitle() )
            ) {
                unset( $dupes[$key] );
            }
        }
 
        return $dupes;
    }
 
    private function checkAgainstArchiveDupes( $hash, Authority $performer ) {
        if ( $hash === false ) {
            return null;
        }
        $archivedFile = new ArchivedFile( null, 0, '', $hash );
        if ( $archivedFile->getID() > 0 ) {
            if ( $archivedFile->userCan( File::DELETED_FILE, $performer ) ) {
                return $archivedFile->getName();
            }
            return '';
        }
 
        return null;
    }
 
    public function performUpload(
        $comment, $pageText, $watch, $user, $tags = [], ?string $watchlistExpiry = null
    ) {
        $this->getLocalFile()->load( IDBAccessObject::READ_LATEST );
        $props = $this->mFileProps;
 
        $error = null;
        $this->getHookRunner()->onUploadVerifyUpload( $this, $user, $props, $comment, $pageText, $error );
        if ( $error ) {
            if ( !is_array( $error ) ) {
                $error = [ $error ];
            }
            return Status::newFatal( ...$error );
        }
 
        $status = $this->getLocalFile()->upload(
            $this->mTempPath,
            $comment,
            $pageText !== false ? $pageText : '',
            File::DELETE_SOURCE,
            $props,
            false,
            $user,
            $tags
        );
 
        if ( $status->isGood() ) {
            if ( $watch ) {
                MediaWikiServices::getInstance()->getWatchlistManager()->addWatchIgnoringRights(
                    $user,
                    $this->getLocalFile()->getTitle(),
                    $watchlistExpiry
                );
            }
            $this->getHookRunner()->onUploadComplete( $this );
 
            $this->postProcessUpload();
        }
 
        return $status;
    }
 
    public function postProcessUpload() {
    }
 
    public function getTitle() {
        if ( $this->mTitle !== false ) {
            return $this->mTitle;
        }
        if ( !is_string( $this->mDesiredDestName ) ) {
            $this->mTitleError = self::ILLEGAL_FILENAME;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
        /* Assume that if a user specified File:Something.jpg, this is an error
         * and that the namespace prefix needs to be stripped of.
         */
        $title = Title::newFromText( $this->mDesiredDestName );
        if ( $title && $title->getNamespace() === NS_FILE ) {
            $this->mFilteredName = $title->getDBkey();
        } else {
            $this->mFilteredName = $this->mDesiredDestName;
        }
 
        # oi_archive_name is max 255 bytes, which include a timestamp and an
        # exclamation mark, so restrict file name to 240 bytes.
        if ( strlen( $this->mFilteredName ) > 240 ) {
            $this->mTitleError = self::FILENAME_TOO_LONG;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
 
        $this->mFilteredName = wfStripIllegalFilenameChars( $this->mFilteredName );
        /* Normalize to title form before we do any further processing */
        $nt = Title::makeTitleSafe( NS_FILE, $this->mFilteredName );
        if ( $nt === null ) {
            $this->mTitleError = self::ILLEGAL_FILENAME;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
        $this->mFilteredName = $nt->getDBkey();
 
        [ $partname, $ext ] = self::splitExtensions( $this->mFilteredName );
 
        if ( $ext !== [] ) {
            $this->mFinalExtension = trim( end( $ext ) );
        } else {
            $this->mFinalExtension = '';
 
            // No extension, try guessing one from the temporary file
            // FIXME: Sometimes we mTempPath isn't set yet here, possibly due to an unrealistic
            // or incomplete test case in UploadBaseTest (T272328)
            if ( $this->mTempPath !== null ) {
                $magic = MediaWikiServices::getInstance()->getMimeAnalyzer();
                $mime = $magic->guessMimeType( $this->mTempPath );
                if ( $mime !== 'unknown/unknown' ) {
                    # Get a space separated list of extensions
                    $mimeExt = $magic->getExtensionFromMimeTypeOrNull( $mime );
                    if ( $mimeExt !== null ) {
                        # Set the extension to the canonical extension
                        $this->mFinalExtension = $mimeExt;
 
                        # Fix up the other variables
                        $this->mFilteredName .= ".{$this->mFinalExtension}";
                        $nt = Title::makeTitleSafe( NS_FILE, $this->mFilteredName );
                        $ext = [ $this->mFinalExtension ];
                    }
                }
            }
        }
 
        // Don't allow users to override the list of prohibited file extensions (check file extension)
        $config = MediaWikiServices::getInstance()->getMainConfig();
        $checkFileExtensions = $config->get( MainConfigNames::CheckFileExtensions );
        $strictFileExtensions = $config->get( MainConfigNames::StrictFileExtensions );
        $fileExtensions = $config->get( MainConfigNames::FileExtensions );
        $prohibitedFileExtensions = $config->get( MainConfigNames::ProhibitedFileExtensions );
 
        $badList = self::checkFileExtensionList( $ext, $prohibitedFileExtensions );
 
        if ( $this->mFinalExtension == '' ) {
            $this->mTitleError = self::FILETYPE_MISSING;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
 
        if ( $badList ||
            ( $checkFileExtensions && $strictFileExtensions &&
                !self::checkFileExtension( $this->mFinalExtension, $fileExtensions ) )
        ) {
            $this->mBlackListedExtensions = $badList;
            $this->mTitleError = self::FILETYPE_BADTYPE;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
 
        // Windows may be broken with special characters, see T3780
        if ( !preg_match( '/^[\x0-\x7f]*$/', $nt->getText() )
            && !MediaWikiServices::getInstance()->getRepoGroup()
                ->getLocalRepo()->backendSupportsUnicodePaths()
        ) {
            $this->mTitleError = self::WINDOWS_NONASCII_FILENAME;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
 
        # If there was more than one file "extension", reassemble the base
        # filename to prevent bogus complaints about length
        if ( count( $ext ) > 1 ) {
            $iterations = count( $ext ) - 1;
            for ( $i = 0; $i < $iterations; $i++ ) {
                $partname .= '.' . $ext[$i];
            }
        }
 
        if ( strlen( $partname ) < 1 ) {
            $this->mTitleError = self::MIN_LENGTH_PARTNAME;
            $this->mTitle = null;
 
            return $this->mTitle;
        }
 
        $this->mTitle = $nt;
 
        return $this->mTitle;
    }
 
    public function getLocalFile() {
        if ( $this->mLocalFile === null ) {
            $nt = $this->getTitle();
            $this->mLocalFile = $nt === null
                ? null
                : MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo()->newFile( $nt );
        }
 
        return $this->mLocalFile;
    }
 
    public function getStashFile() {
        return $this->mStashFile;
    }
 
    public function tryStashFile( User $user, $isPartial = false ) {
        if ( !$isPartial ) {
            $error = $this->runUploadStashFileHook( $user );
            if ( $error ) {
                return Status::newFatal( ...$error );
            }
        }
        try {
            $file = $this->doStashFile( $user );
            return Status::newGood( $file );
        } catch ( UploadStashException $e ) {
            return Status::newFatal( 'uploadstash-exception', get_class( $e ), $e->getMessage() );
        }
    }
 
    public function skipStashFileAttempt(): bool {
        return $this->getStashFile() !== null;
    }
 
    protected function runUploadStashFileHook( User $user ) {
        $props = $this->mFileProps;
        $error = null;
        $this->getHookRunner()->onUploadStashFile( $this, $user, $props, $error );
        if ( $error && !is_array( $error ) ) {
            $error = [ $error ];
        }
        return $error;
    }
 
    protected function doStashFile( ?User $user = null ) {
        $stash = MediaWikiServices::getInstance()->getRepoGroup()
            ->getLocalRepo()->getUploadStash( $user );
        $file = $stash->stashFile( $this->mTempPath, $this->getSourceType(), $this->mFileProps );
        $this->mStashFile = $file;
 
        return $file;
    }
 
    public function cleanupTempFile() {
        if ( $this->mRemoveTempFile && $this->tempFileObj ) {
            // Delete when all relevant TempFSFile handles go out of scope
            wfDebug( __METHOD__ . ": Marked temporary file '{$this->mTempPath}' for removal" );
            $this->tempFileObj->autocollect();
        }
    }
 
    public function getTempPath() {
        return $this->mTempPath;
    }
 
    public static function splitExtensions( $filename ) {
        $bits = explode( '.', $filename );
        $basename = array_shift( $bits );
 
        return [ $basename, $bits ];
    }
 
    public static function checkFileExtension( $ext, $list ) {
        return in_array( strtolower( $ext ?? '' ), $list, true );
    }
 
    public static function checkFileExtensionList( $ext, $list ) {
        return array_intersect( array_map( 'strtolower', $ext ), $list );
    }
 
    public static function verifyExtension( $mime, $extension ) {
        wfDeprecated( __METHOD__, '1.45' );
        // External callers should probably be using verifyFile and not this method.
        $verify = MediaWikiServices::getInstance()->getUploadVerification();
        return $verify->verifyExtension( $mime, $extension );
    }
 
    public static function detectScript( $file, $mime, $extension ) {
        wfDeprecated( __METHOD__, '1.45' );
        // When replacing usage of this in extensions, use UploadVerification::verifyFile.
        // detectScript is unlikely to be the method you want.
        $verify = MediaWikiServices::getInstance()->getUploadVerification();
        return $verify->detectScript( $file, $mime, $extension );
    }
 
    public static function detectVirus( $file ) {
        wfDeprecated( __METHOD__, '1.45' );
        $uploadVerification = MediaWikiServices::getInstance()->getUploadVerification();
        return $uploadVerification->detectVirus( $file );
    }
 
    private function checkOverwrite( Authority $performer ) {
        // First check whether the local file can be overwritten
        $file = $this->getLocalFile();
        $file->load( IDBAccessObject::READ_LATEST );
        if ( $file->exists() ) {
            if ( !self::userCanReUpload( $performer, $file ) ) {
                return [ 'fileexists-forbidden', $file->getName() ];
            }
 
            return true;
        }
 
        $services = MediaWikiServices::getInstance();
 
        /* Check shared conflicts: if the local file does not exist, but
         * RepoGroup::findFile finds a file, it exists in a shared repository.
         */
        $file = $services->getRepoGroup()->findFile( $this->getTitle(), [ 'latest' => true ] );
        if ( $file && !$performer->isAllowed( 'reupload-shared' ) ) {
            return [ 'fileexists-shared-forbidden', $file->getName() ];
        }
 
        return true;
    }
 
    public static function userCanReUpload( Authority $performer, File $img ) {
        if ( $performer->isAllowed( 'reupload' ) ) {
            return true; // non-conditional
        }
 
        if ( !$performer->isAllowed( 'reupload-own' ) ) {
            return false;
        }
 
        if ( !( $img instanceof LocalFile ) ) {
            return false;
        }
 
        return $performer->getUser()->equals( $img->getUploader( File::RAW ) );
    }
 
    public static function getExistsWarning( $file ) {
        if ( $file->exists() ) {
            return [ 'warning' => 'exists', 'file' => $file ];
        }
 
        if ( $file->getTitle()->getArticleID() ) {
            return [ 'warning' => 'page-exists', 'file' => $file ];
        }
 
        $n = strrpos( $file->getName(), '.' );
        if ( $n > 0 ) {
            $partname = substr( $file->getName(), 0, $n );
            $extension = substr( $file->getName(), $n + 1 );
        } else {
            $partname = $file->getName();
            $extension = '';
        }
        $normalizedExtension = File::normalizeExtension( $extension );
        $localRepo = MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo();
 
        if ( $normalizedExtension != $extension ) {
            // We're not using the normalized form of the extension.
            // Normal form is lowercase, using most common of alternate
            // extensions (e.g. 'jpg' rather than 'JPEG').
 
            // Check for another file using the normalized form...
            $nt_lc = Title::makeTitle( NS_FILE, "{$partname}.{$normalizedExtension}" );
            $file_lc = $localRepo->newFile( $nt_lc );
 
            if ( $file_lc->exists() ) {
                return [
                    'warning' => 'exists-normalized',
                    'file' => $file,
                    'normalizedFile' => $file_lc
                ];
            }
        }
 
        // Check for files with the same name but a different extension
        $similarFiles = $localRepo->findFilesByPrefix( "{$partname}.", 1 );
        if ( count( $similarFiles ) ) {
            return [
                'warning' => 'exists-normalized',
                'file' => $file,
                'normalizedFile' => $similarFiles[0],
            ];
        }
 
        if ( self::isThumbName( $file->getName() ) ) {
            // Check for filenames like 50px- or 180px-, these are mostly thumbnails
            $nt_thb = Title::newFromText(
                substr( $partname, strpos( $partname, '-' ) + 1 ) . '.' . $extension,
                NS_FILE
            );
            $file_thb = $localRepo->newFile( $nt_thb );
            if ( $file_thb->exists() ) {
                return [
                    'warning' => 'thumb',
                    'file' => $file,
                    'thumbFile' => $file_thb
                ];
            }
 
            // The file does not exist, but we just don't like the name
            return [
                'warning' => 'thumb-name',
                'file' => $file,
                'thumbFile' => $file_thb
            ];
        }
 
        foreach ( self::getFilenamePrefixBlacklist() as $prefix ) {
            if ( str_starts_with( $partname, $prefix ) ) {
                return [
                    'warning' => 'bad-prefix',
                    'file' => $file,
                    'prefix' => $prefix
                ];
            }
        }
 
        return false;
    }
 
    public static function isThumbName( $filename ) {
        $n = strrpos( $filename, '.' );
        $partname = $n ? substr( $filename, 0, $n ) : $filename;
 
        return (
                substr( $partname, 3, 3 ) === 'px-' ||
                substr( $partname, 2, 3 ) === 'px-'
            ) && preg_match( "/[0-9]{2}/", substr( $partname, 0, 2 ) );
    }
 
    public static function getFilenamePrefixBlacklist() {
        $list = [];
        $message = wfMessage( 'filename-prefix-blacklist' )->inContentLanguage();
        if ( !$message->isDisabled() ) {
            $lines = explode( "\n", $message->plain() );
            foreach ( $lines as $line ) {
                // Remove comment lines
                $comment = substr( trim( $line ), 0, 1 );
                if ( $comment === '#' || $comment == '' ) {
                    continue;
                }
                // Remove additional comments after a prefix
                $comment = strpos( $line, '#' );
                if ( $comment > 0 ) {
                    $line = substr( $line, 0, $comment - 1 );
                }
                $list[] = trim( $line );
            }
        }
 
        return $list;
    }
 
    public function getImageInfo( $result = null ) {
        $apiUpload = ApiUpload::getDummyInstance();
        return $apiUpload->getUploadImageInfo( $this );
    }
 
    public function convertVerifyErrorToStatus( array $error ): UploadVerificationStatus {
        switch ( $error['status'] ) {
            case self::MIN_LENGTH_PARTNAME:
                return UploadVerificationStatus::newFatal( 'filename-tooshort' )
                    ->setRecoverableError( true )
                    ->setInvalidParameter( 'filename' );
 
            case self::ILLEGAL_FILENAME:
                return UploadVerificationStatus::newFatal( 'illegal-filename' )
                    ->setRecoverableError( true )
                    ->setInvalidParameter( 'filename' )
                    ->setApiData( [ 'filename' => $error['filtered'] ] );
 
            case self::FILENAME_TOO_LONG:
                return UploadVerificationStatus::newFatal( 'filename-toolong' )
                    ->setRecoverableError( true )
                    ->setInvalidParameter( 'filename' );
 
            case self::FILETYPE_MISSING:
                return UploadVerificationStatus::newFatal( 'filetype-missing' )
                    ->setRecoverableError( true )
                    ->setInvalidParameter( 'filename' );
 
            case self::WINDOWS_NONASCII_FILENAME:
                return UploadVerificationStatus::newFatal( 'windows-nonascii-filename' )
                    ->setRecoverableError( true )
                    ->setInvalidParameter( 'filename' );
 
            case self::EMPTY_FILE:
                return UploadVerificationStatus::newFatal( 'empty-file' );
 
            case self::FILE_TOO_LARGE:
                return UploadVerificationStatus::newFatal( 'file-too-large' );
 
            case self::FILETYPE_BADTYPE:
                $extensions = array_unique( MediaWikiServices::getInstance()
                    ->getMainConfig()->get( MainConfigNames::FileExtensions ) );
                $extradata = [
                    'filetype' => $error['finalExt'],
                    'allowed' => array_values( $extensions ),
                ];
                ApiResult::setIndexedTagName( $extradata['allowed'], 'ext' );
                if ( isset( $error['blacklistedExt'] ) ) {
                    $bannedTypes = $error['blacklistedExt'];
                    $extradata['blacklisted'] = array_values( $bannedTypes );
                    ApiResult::setIndexedTagName( $extradata['blacklisted'], 'ext' );
                } else {
                    $bannedTypes = [ $error['finalExt'] ];
                }
                '@phan-var string[] $bannedTypes';
                return UploadVerificationStatus::newFatal(
                    'filetype-banned-type',
                    Message::listParam( $bannedTypes, ListType::COMMA ),
                    Message::listParam( $extensions, ListType::COMMA ),
                    count( $extensions ),
                    // Add PLURAL support for the first parameter. This results
                    // in a bit unlogical parameter sequence, but does not break
                    // old translations
                    count( $bannedTypes )
                )
                    ->setApiCode( 'filetype-banned' )
                    ->setApiData( $extradata );
 
            case self::VERIFICATION_ERROR:
                $msg = ApiMessage::create( $error['details'], 'verification-error' );
                if ( $error['details'][0] instanceof MessageSpecifier ) {
                    $apiDetails = [ $msg->getKey(), ...$msg->getParams() ];
                } else {
                    $apiDetails = $error['details'];
                }
                ApiResult::setIndexedTagName( $apiDetails, 'detail' );
                $msg->setApiData( $msg->getApiData() + [ 'details' => $apiDetails ] );
                return UploadVerificationStatus::newFatal( $msg );
 
            default:
                // @codeCoverageIgnoreStart
                return UploadVerificationStatus::newFatal( 'upload-unknownerror-nocode' )
                    ->setApiCode( 'unknown-error' )
                    ->setApiData( [ 'details' => [ 'code' => $error['status'] ] ] );
                // @codeCoverageIgnoreEnd
        }
    }
 
    public static function getMaxUploadSize( $forType = null ) {
        $maxUploadSize = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::MaxUploadSize );
 
        if ( is_array( $maxUploadSize ) ) {
            if ( $forType !== null && isset( $maxUploadSize[$forType] ) ) {
                return $maxUploadSize[$forType];
            }
            return $maxUploadSize['*'];
        }
        return intval( $maxUploadSize );
    }
 
    public static function getMaxPhpUploadSize() {
        $phpMaxFileSize = wfShorthandToInteger(
            ini_get( 'upload_max_filesize' ),
            PHP_INT_MAX
        );
        $phpMaxPostSize = wfShorthandToInteger(
            ini_get( 'post_max_size' ),
            PHP_INT_MAX
        ) ?: PHP_INT_MAX;
        return min( $phpMaxFileSize, $phpMaxPostSize );
    }
 
    public static function getSessionStatus( UserIdentity $user, $statusKey ) {
        $store = self::getUploadSessionStore();
        $key = self::getUploadSessionKey( $store, $user, $statusKey );
 
        return $store->get( $key );
    }
 
    public static function setSessionStatus( UserIdentity $user, $statusKey, $value ) {
        $store = self::getUploadSessionStore();
        $key = self::getUploadSessionKey( $store, $user, $statusKey );
        $logger = LoggerFactory::getInstance( 'upload' );
 
        if ( is_array( $value ) && ( $value['result'] ?? '' ) === 'Failure' ) {
            $logger->info( 'Upload session {key} for {user} set to failure {status} at {stage}',
                [
                    'result' => $value['result'] ?? '',
                    'stage' => $value['stage'] ?? 'unknown',
                    'user' => $user->getName(),
                    'status' => (string)( $value['status'] ?? '-' ),
                    'filekey' => $value['filekey'] ?? '',
                    'key' => $statusKey
                ]
            );
        } elseif ( is_array( $value ) ) {
            $logger->debug( 'Upload session {key} for {user} changed {status} at {stage}',
                [
                    'result' => $value['result'] ?? '',
                    'stage' => $value['stage'] ?? 'unknown',
                    'user' => $user->getName(),
                    'status' => (string)( $value['status'] ?? '-' ),
                    'filekey' => $value['filekey'] ?? '',
                    'key' => $statusKey
                ]
            );
        } else {
            $logger->debug( "Upload session {key} deleted for {user}",
                [
                    'value' => $value,
                    'key' => $statusKey,
                    'user' => $user->getName()
                ]
            );
        }
 
        if ( $value === false ) {
            $store->delete( $key );
        } else {
            $store->set( $key, $value, $store::TTL_DAY );
        }
    }
 
    private static function getUploadSessionKey( BagOStuff $store, UserIdentity $user, $statusKey ) {
        return $store->makeKey(
            'uploadstatus',
            $user->isRegistered() ? $user->getId() : md5( $user->getName() ),
            $statusKey
        );
    }
 
    private static function getUploadSessionStore() {
        return MediaWikiServices::getInstance()->getMainObjectStash();
    }
}
 
class_alias( UploadBase::class, 'UploadBase' );