GlobalFunctions.php

Go to the documentation of this file.

<?php
use MediaWiki\Debug\MWDebug;
use MediaWiki\Exception\ProcOpenError;
use MediaWiki\FileRepo\File\File;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\Request\WebRequest;
use MediaWiki\Shell\Shell;
use MediaWiki\Title\Title;
use MediaWiki\Utils\UrlUtils;
use Wikimedia\AtEase\AtEase;
use Wikimedia\FileBackend\FileBackend;
use Wikimedia\FileBackend\FSFile\TempFSFile;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\ParamValidator\TypeDef\ExpiryDef;
use Wikimedia\RequestTimeout\RequestTimeout;
use Wikimedia\Timestamp\ConvertibleTimestamp;
 
function wfLoadExtension( $ext, $path = null ) {
    if ( !$path ) {
        global $wgExtensionDirectory;
        $path = "$wgExtensionDirectory/$ext/extension.json";
    }
    ExtensionRegistry::getInstance()->queue( $path );
}
 
function wfLoadExtensions( array $exts ) {
    global $wgExtensionDirectory;
    $registry = ExtensionRegistry::getInstance();
    foreach ( $exts as $ext ) {
        $registry->queue( "$wgExtensionDirectory/$ext/extension.json" );
    }
}
 
function wfLoadSkin( $skin, $path = null ) {
    if ( !$path ) {
        global $wgStyleDirectory;
        $path = "$wgStyleDirectory/$skin/skin.json";
    }
    ExtensionRegistry::getInstance()->queue( $path );
}
 
function wfLoadSkins( array $skins ) {
    global $wgStyleDirectory;
    $registry = ExtensionRegistry::getInstance();
    foreach ( $skins as $skin ) {
        $registry->queue( "$wgStyleDirectory/$skin/skin.json" );
    }
}
 
function wfArrayDiff2( $arr1, $arr2 ) {
    wfDeprecated( __FUNCTION__, '1.43' );
    $comparator = static function ( $a, $b ): int {
        if ( is_string( $a ) && is_string( $b ) ) {
            return strcmp( $a, $b );
        }
        if ( !is_array( $a ) && !is_array( $b ) ) {
            throw new InvalidArgumentException(
                'This function assumes that array elements are all strings or all arrays'
            );
        }
        if ( count( $a ) !== count( $b ) ) {
            return count( $a ) <=> count( $b );
        } else {
            reset( $a );
            reset( $b );
            while ( key( $a ) !== null && key( $b ) !== null ) {
                $valueA = current( $a );
                $valueB = current( $b );
                $cmp = strcmp( $valueA, $valueB );
                if ( $cmp !== 0 ) {
                    return $cmp;
                }
                next( $a );
                next( $b );
            }
            return 0;
        }
    };
    return array_udiff( $arr1, $arr2, $comparator );
}
 
function wfMergeErrorArrays( ...$args ) {
    wfDeprecated( __FUNCTION__, '1.43' );
    $out = [];
    foreach ( $args as $errors ) {
        foreach ( $errors as $params ) {
            $originalParams = $params;
            if ( $params[0] instanceof MessageSpecifier ) {
                $params = [ $params[0]->getKey(), ...$params[0]->getParams() ];
            }
            # @todo FIXME: Sometimes get nested arrays for $params,
            # which leads to E_NOTICEs
            $spec = implode( "\t", $params );
            $out[$spec] = $originalParams;
        }
    }
    return array_values( $out );
}
 
function wfArrayInsertAfter( array $array, array $insert, $after ) {
    // Find the offset of the element to insert after.
    $keys = array_keys( $array );
    $offsetByKey = array_flip( $keys );
 
    if ( !\array_key_exists( $after, $offsetByKey ) ) {
        return $array;
    }
    $offset = $offsetByKey[$after];
 
    // Insert at the specified offset
    $before = array_slice( $array, 0, $offset + 1, true );
    $after = array_slice( $array, $offset + 1, count( $array ) - $offset, true );
 
    $output = $before + $insert + $after;
 
    return $output;
}
 
function wfObjectToArray( $objOrArray, $recursive = true ) {
    $array = [];
    if ( is_object( $objOrArray ) ) {
        $objOrArray = get_object_vars( $objOrArray );
    }
    foreach ( $objOrArray as $key => $value ) {
        if ( $recursive && ( is_object( $value ) || is_array( $value ) ) ) {
            $value = wfObjectToArray( $value );
        }
 
        $array[$key] = $value;
    }
 
    return $array;
}
 
function wfRandom() {
    // The maximum random value is "only" 2^31-1, so get two random
    // values to reduce the chance of dupes
    $max = mt_getrandmax() + 1;
    $rand = number_format( ( mt_rand() * $max + mt_rand() ) / $max / $max, 12, '.', '' );
    return $rand;
}
 
function wfRandomString( $length = 32 ) {
    $str = '';
    for ( $n = 0; $n < $length; $n += 7 ) {
        $str .= sprintf( '%07x', mt_rand() & 0xfffffff );
    }
    return substr( $str, 0, $length );
}
 
function wfUrlencode( $s ) {
    static $needle;
 
    if ( $s === null ) {
        // Reset $needle for testing.
        $needle = null;
        return '';
    }
 
    if ( $needle === null ) {
        $needle = [ '%3B', '%40', '%24', '%21', '%2A', '%28', '%29', '%2C', '%2F', '%7E' ];
        if ( !isset( $_SERVER['SERVER_SOFTWARE'] ) ||
            !str_contains( $_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS/7' )
        ) {
            $needle[] = '%3A';
        }
    }
 
    $s = urlencode( $s );
    $s = str_ireplace(
        $needle,
        [ ';', '@', '$', '!', '*', '(', ')', ',', '/', '~', ':' ],
        $s
    );
 
    return $s;
}
 
function wfArrayToCgi( $array1, $array2 = null, $prefix = '' ) {
    if ( $array2 !== null ) {
        $array1 += $array2;
    }
 
    $cgi = '';
    foreach ( $array1 as $key => $value ) {
        if ( $value !== null && $value !== false ) {
            if ( $cgi != '' ) {
                $cgi .= '&';
            }
            if ( $prefix !== '' ) {
                $key = $prefix . "[$key]";
            }
            if ( is_array( $value ) ) {
                $firstTime = true;
                foreach ( $value as $k => $v ) {
                    $cgi .= $firstTime ? '' : '&';
                    if ( is_array( $v ) ) {
                        $cgi .= wfArrayToCgi( $v, null, $key . "[$k]" );
                    } else {
                        $cgi .= urlencode( $key . "[$k]" ) . '=' . urlencode( $v );
                    }
                    $firstTime = false;
                }
            } else {
                if ( is_object( $value ) ) {
                    $value = $value->__toString();
                }
                $cgi .= urlencode( $key ) . '=' . urlencode( $value );
            }
        }
    }
    return $cgi;
}
 
function wfCgiToArray( $query ) {
    if ( isset( $query[0] ) && $query[0] == '?' ) {
        $query = substr( $query, 1 );
    }
    $bits = explode( '&', $query );
    $ret = [];
    foreach ( $bits as $bit ) {
        if ( $bit === '' ) {
            continue;
        }
        if ( strpos( $bit, '=' ) === false ) {
            // Pieces like &qwerty become 'qwerty' => '' (at least this is what php does)
            $key = $bit;
            $value = '';
        } else {
            [ $key, $value ] = explode( '=', $bit );
        }
        $key = urldecode( $key );
        $value = urldecode( $value );
        if ( strpos( $key, '[' ) !== false ) {
            $keys = array_reverse( explode( '[', $key ) );
            $key = array_pop( $keys );
            $temp = $value;
            foreach ( $keys as $k ) {
                $k = substr( $k, 0, -1 );
                $temp = [ $k => $temp ];
            }
            if ( isset( $ret[$key] ) && is_array( $ret[$key] ) ) {
                $ret[$key] = array_merge( $ret[$key], $temp );
            } else {
                $ret[$key] = $temp;
            }
        } else {
            $ret[$key] = $value;
        }
    }
    return $ret;
}
 
function wfAppendQuery( $url, $query ) {
    if ( is_array( $query ) ) {
        $query = wfArrayToCgi( $query );
    }
    if ( $query != '' ) {
        // Remove the fragment, if there is one
        $fragment = false;
        $hashPos = strpos( $url, '#' );
        if ( $hashPos !== false ) {
            $fragment = substr( $url, $hashPos );
            $url = substr( $url, 0, $hashPos );
        }
 
        // Add parameter
        if ( strpos( $url, '?' ) === false ) {
            $url .= '?';
        } else {
            $url .= '&';
        }
        $url .= $query;
 
        // Put the fragment back
        if ( $fragment !== false ) {
            $url .= $fragment;
        }
    }
    return $url;
}
 
function wfGetUrlUtils(): UrlUtils {
    global $wgServer, $wgCanonicalServer, $wgInternalServer, $wgRequest, $wgHttpsPort,
        $wgUrlProtocols;
 
    if ( MediaWikiServices::hasInstance() ) {
        $services = MediaWikiServices::getInstance();
        if ( $services->hasService( 'UrlUtils' ) ) {
            return $services->getUrlUtils();
        }
    }
 
    return new UrlUtils( [
        // UrlUtils throws if the relevant $wg(|Canonical|Internal) variable is null, but the old
        // implementations implicitly converted it to an empty string (presumably by mistake).
        // Preserve the old behavior for compatibility.
        UrlUtils::SERVER => $wgServer ?? '',
        UrlUtils::CANONICAL_SERVER => $wgCanonicalServer ?? '',
        UrlUtils::INTERNAL_SERVER => $wgInternalServer ?? '',
        UrlUtils::FALLBACK_PROTOCOL => $wgRequest ? $wgRequest->getProtocol()
            : WebRequest::detectProtocol(),
        UrlUtils::HTTPS_PORT => $wgHttpsPort,
        UrlUtils::VALID_PROTOCOLS => $wgUrlProtocols,
    ] );
}
 
function wfExpandUrl( $url, $defaultProto = PROTO_CURRENT ) {
    return wfGetUrlUtils()->expand( (string)$url, $defaultProto ) ?? false;
}
 
function wfGetServerUrl( $proto ) {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return wfGetUrlUtils()->getServer( $proto ) ?? '';
}
 
function wfAssembleUrl( $urlParts ) {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return UrlUtils::assemble( (array)$urlParts );
}
 
function wfUrlProtocols( $includeProtocolRelative = true ) {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return $includeProtocolRelative ? wfGetUrlUtils()->validProtocols() :
        wfGetUrlUtils()->validAbsoluteProtocols();
}
 
function wfUrlProtocolsWithoutProtRel() {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return wfGetUrlUtils()->validAbsoluteProtocols();
}
 
function wfParseUrl( $url ) {
    return wfGetUrlUtils()->parse( (string)$url ) ?? false;
}
 
function wfExpandIRI( $url ) {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return wfGetUrlUtils()->expandIRI( (string)$url ) ?? '';
}
 
function wfMatchesDomainList( $url, $domains ) {
    wfDeprecated( __FUNCTION__, '1.39' );
 
    return wfGetUrlUtils()->matchesDomainList( (string)$url, (array)$domains );
}
 
function wfDebug( $text, $dest = 'all', array $context = [] ) {
    global $wgDebugRawPage, $wgDebugLogPrefix;
 
    if ( !$wgDebugRawPage && wfIsDebugRawPage() ) {
        return;
    }
 
    $text = trim( $text );
 
    if ( $wgDebugLogPrefix !== '' ) {
        $context['prefix'] = $wgDebugLogPrefix;
    }
    $context['private'] = ( $dest === false || $dest === 'private' );
 
    $logger = LoggerFactory::getInstance( 'wfDebug' );
    $logger->debug( $text, $context );
}
 
function wfIsDebugRawPage() {
    static $cache;
    if ( $cache !== null ) {
        return $cache;
    }
    // Check for raw action using $_GET not $wgRequest, since the latter might not be initialised yet
    // phpcs:ignore MediaWiki.Usage.SuperGlobalsUsage.SuperGlobals
    if ( ( isset( $_GET['action'] ) && $_GET['action'] == 'raw' )
        || MW_ENTRY_POINT === 'load'
    ) {
        $cache = true;
    } else {
        $cache = false;
    }
    return $cache;
}
 
function wfDebugLog(
    $logGroup, $text, $dest = 'all', array $context = []
) {
    $text = trim( $text );
 
    $logger = LoggerFactory::getInstance( $logGroup );
    $context['private'] = ( $dest === false || $dest === 'private' );
    $logger->info( $text, $context );
}
 
function wfLogDBError( $text, array $context = [] ) {
    $logger = LoggerFactory::getInstance( 'wfLogDBError' );
    $logger->error( trim( $text ), $context );
}
 
function wfDeprecated( $function, $version = false, $component = false, $callerOffset = 2 ) {
    if ( !is_string( $version ) && $version !== false ) {
        throw new InvalidArgumentException(
            "MediaWiki version must either be a string or false. " .
            "Example valid version: '1.33'"
        );
    }
 
    MWDebug::deprecated( $function, $version, $component, $callerOffset + 1 );
}
 
function wfDeprecatedMsg( $msg, $version = false, $component = false, $callerOffset = 2 ) {
    MWDebug::deprecatedMsg( $msg, $version, $component,
        $callerOffset === false ? false : $callerOffset + 1 );
}
 
function wfWarn( $msg, $callerOffset = 1, $level = E_USER_NOTICE ) {
    MWDebug::warning( $msg, $callerOffset + 1, $level, 'auto' );
}
 
function wfLogWarning( $msg, $callerOffset = 1, $level = E_USER_WARNING ) {
    MWDebug::warning( $msg, $callerOffset + 1, $level, 'production' );
}
 
function wfMessage( $key, ...$params ) {
    if ( is_array( $key ) ) {
        // Fallback keys are not allowed in message specifiers
        $message = wfMessageFallback( ...$key );
    } else {
        $message = Message::newFromSpecifier( $key );
    }
 
    // We call Message::params() to reduce code duplication
    if ( $params ) {
        $message->params( ...$params );
    }
 
    return $message;
}
 
function wfMessageFallback( ...$keys ) {
    return Message::newFallbackSequence( ...$keys );
}
 
function wfMsgReplaceArgs( $message, $args ) {
    # Fix windows line-endings
    # Some messages are split with explode("\n", $msg)
    $message = str_replace( "\r", '', $message );
 
    // Replace arguments
    if ( is_array( $args ) && $args ) {
        if ( is_array( $args[0] ) ) {
            $args = array_values( $args[0] );
        }
        $replacementKeys = [];
        foreach ( $args as $n => $param ) {
            $replacementKeys['$' . ( $n + 1 )] = $param;
        }
        $message = strtr( $message, $replacementKeys );
    }
 
    return $message;
}
 
function wfHostname() {
    // Hostname overriding
    global $wgOverrideHostname;
    if ( $wgOverrideHostname !== false ) {
        return $wgOverrideHostname;
    }
 
    return php_uname( 'n' ) ?: 'unknown';
}
 
function wfDebugBacktrace( $limit = 0 ) {
    static $disabled = null;
 
    if ( $disabled === null ) {
        $disabled = !function_exists( 'debug_backtrace' );
        if ( $disabled ) {
            wfDebug( "debug_backtrace() is disabled" );
        }
    }
    if ( $disabled ) {
        return [];
    }
 
    if ( $limit ) {
        return array_slice( debug_backtrace( DEBUG_BACKTRACE_PROVIDE_OBJECT, $limit + 1 ), 1 );
    } else {
        return array_slice( debug_backtrace(), 1 );
    }
}
 
function wfBacktrace( $raw = null ) {
    $raw ??= MW_ENTRY_POINT === 'cli';
    if ( $raw ) {
        $frameFormat = "%s line %s calls %s()\n";
        $traceFormat = "%s";
    } else {
        $frameFormat = "<li>%s line %s calls %s()</li>\n";
        $traceFormat = "<ul>\n%s</ul>\n";
    }
 
    $frames = array_map( static function ( $frame ) use ( $frameFormat ) {
        $file = !empty( $frame['file'] ) ? basename( $frame['file'] ) : '-';
        $line = $frame['line'] ?? '-';
        $call = $frame['function'];
        if ( !empty( $frame['class'] ) ) {
            $call = $frame['class'] . $frame['type'] . $call;
        }
        return sprintf( $frameFormat, $file, $line, $call );
    }, wfDebugBacktrace() );
 
    return sprintf( $traceFormat, implode( '', $frames ) );
}
 
function wfGetCaller( $level = 2 ) {
    $backtrace = wfDebugBacktrace( $level + 1 );
    if ( isset( $backtrace[$level] ) ) {
        return wfFormatStackFrame( $backtrace[$level] );
    } else {
        return 'unknown';
    }
}
 
function wfGetAllCallers( $limit = 3 ) {
    $trace = array_reverse( wfDebugBacktrace() );
    if ( !$limit || $limit > count( $trace ) - 1 ) {
        $limit = count( $trace ) - 1;
    }
    $trace = array_slice( $trace, -$limit - 1, $limit );
    return implode( '/', array_map( 'wfFormatStackFrame', $trace ) );
}
 
function wfFormatStackFrame( $frame ) {
    if ( !isset( $frame['function'] ) ) {
        return 'NO_FUNCTION_GIVEN';
    }
    return isset( $frame['class'] ) && isset( $frame['type'] ) ?
        $frame['class'] . $frame['type'] . $frame['function'] :
        $frame['function'];
}
 
function wfClientAcceptsGzip( $force = false ) {
    static $result = null;
    if ( $result === null || $force ) {
        $result = false;
        if ( isset( $_SERVER['HTTP_ACCEPT_ENCODING'] ) ) {
            # @todo FIXME: We may want to disallow some broken browsers
            $m = [];
            if ( preg_match(
                    '/\bgzip(?:;(q)=([0-9]+(?:\.[0-9]+)))?\b/',
                    $_SERVER['HTTP_ACCEPT_ENCODING'],
                    $m
                )
            ) {
                if ( isset( $m[2] ) && ( $m[1] == 'q' ) && ( $m[2] == 0 ) ) {
                    return $result;
                }
                wfDebug( "wfClientAcceptsGzip: client accepts gzip." );
                $result = true;
            }
        }
    }
    return $result;
}
 
function wfEscapeWikiText( $input ): string {
    global $wgEnableMagicLinks;
    static $repl = null, $repl2 = null, $repl3 = null, $repl4 = null;
    if ( $repl === null || defined( 'MW_PARSER_TEST' ) || defined( 'MW_PHPUNIT_TEST' ) ) {
        // Tests depend upon being able to change $wgEnableMagicLinks, so don't cache
        // in those situations
        $repl = [
            '"' => '&#34;', '&' => '&#38;', "'" => '&#39;', '<' => '&#60;',
            '=' => '&#61;', '>' => '&#62;', '[' => '&#91;', ']' => '&#93;',
            '{' => '&#123;', '|' => '&#124;', '}' => '&#125;',
            ';' => '&#59;', // a token inside language converter brackets
            '!!' => '&#33;!', // a token inside table context
            "\n!" => "\n&#33;", "\r!" => "\r&#33;", // a token inside table context
            "\n#" => "\n&#35;", "\r#" => "\r&#35;",
            "\n*" => "\n&#42;", "\r*" => "\r&#42;",
            "\n:" => "\n&#58;", "\r:" => "\r&#58;",
            "\n " => "\n&#32;", "\r " => "\r&#32;",
            "\n\n" => "\n&#10;", "\r\n" => "&#13;\n",
            "\n\r" => "\n&#13;", "\r\r" => "\r&#13;",
            "\n\t" => "\n&#9;", "\r\t" => "\r&#9;", // "\n\t\n" is treated like "\n\n"
            "\n----" => "\n&#45;---", "\r----" => "\r&#45;---",
            '__' => '_&#95;', '://' => '&#58;//',
            '~~~' => '~~&#126;', // protect from PST, just to be safe(r)
        ];
 
        $magicLinks = array_keys( array_filter( $wgEnableMagicLinks ) );
        // We have to catch everything "\s" matches in PCRE
        foreach ( $magicLinks as $magic ) {
            $repl["$magic "] = "$magic&#32;";
            $repl["$magic\t"] = "$magic&#9;";
            $repl["$magic\r"] = "$magic&#13;";
            $repl["$magic\n"] = "$magic&#10;";
            $repl["$magic\f"] = "$magic&#12;";
        }
        // Additionally escape the following characters at the beginning of the
        // string, in case they merge to form tokens when spliced into a
        // string.  Tokens like -{ {{ [[ {| etc are already escaped because
        // the second character is escaped above, but the following tokens
        // are handled here: |+ |- __FOO__ ~~~
        $repl3 = [
            '+' => '&#43;', '-' => '&#45;', '_' => '&#95;', '~' => '&#126;',
        ];
        // Similarly, protect the following characters at the end of the
        // string, which could turn form the start of `__FOO__` or `~~~~`
        // A trailing newline could also form the unintended start of a
        // paragraph break if it is glued to a newline in the following
        // context.
        $repl4 = [
            '_' => '&#95;', '~' => '&#126;',
            "\n" => "&#10;", "\r" => "&#13;",
            "\t" => "&#9;", // "\n\t\n" is treated like "\n\n"
        ];
 
        // And handle protocols that don't use "://"
        global $wgUrlProtocols;
        $repl2 = [];
        foreach ( $wgUrlProtocols as $prot ) {
            if ( substr( $prot, -1 ) === ':' ) {
                $repl2[] = preg_quote( substr( $prot, 0, -1 ), '/' );
            }
        }
        $repl2 = $repl2 ? '/\b(' . implode( '|', $repl2 ) . '):/i' : '/^(?!)/';
    }
    // Tell phan that $repl2, $repl3 and $repl4 will also be non-null here
    '@phan-var string $repl2';
    '@phan-var string $repl3';
    '@phan-var string $repl4';
    // This will also stringify input in case it's not a string
    $text = substr( strtr( "\n$input", $repl ), 1 );
    if ( $text === '' ) {
        return $text;
    }
    $first = strtr( $text[0], $repl3 ); // protect first character
    if ( strlen( $text ) > 1 ) {
        $text = $first . substr( $text, 1, -1 ) .
        strtr( substr( $text, -1 ), $repl4 ); // protect last character
    } else {
        // special case for single-character strings
        $text = strtr( $first, $repl4 ); // protect last character
    }
    $text = preg_replace( $repl2, '$1&#58;', $text );
    return $text;
}
 
function wfSetVar( &$dest, $source, $force = false ) {
    $temp = $dest;
    if ( $source !== null || $force ) {
        $dest = $source;
    }
    return $temp;
}
 
function wfSetBit( &$dest, $bit, $state = true ) {
    $temp = (bool)( $dest & $bit );
    if ( $state !== null ) {
        if ( $state ) {
            $dest |= $bit;
        } else {
            $dest &= ~$bit;
        }
    }
    return $temp;
}
 
function wfVarDump( $var ) {
    global $wgOut;
    $s = str_replace( "\n", "<br />\n", var_export( $var, true ) . "\n" );
    if ( headers_sent() || $wgOut === null || !is_object( $wgOut ) ) {
        print $s;
    } else {
        $wgOut->addHTML( $s );
    }
}
 
function wfHttpError( $code, $label, $desc ) {
    global $wgOut;
    HttpStatus::header( $code );
    if ( $wgOut ) {
        $wgOut->disable();
        $wgOut->sendCacheControl();
    }
 
    \MediaWiki\Request\HeaderCallback::warnIfHeadersSent();
    header( 'Content-type: text/html; charset=utf-8' );
    ob_start();
    print '<!DOCTYPE html>' .
        '<html><head><title>' .
        htmlspecialchars( $label ) .
        '</title><meta name="color-scheme" content="light dark" /></head><body><h1>' .
        htmlspecialchars( $label ) .
        '</h1><p>' .
        nl2br( htmlspecialchars( $desc ) ) .
        "</p></body></html>\n";
    header( 'Content-Length: ' . ob_get_length() );
    ob_end_flush();
}
 
function wfResetOutputBuffers( $resetGzipEncoding = true ) {
    // phpcs:ignore Generic.CodeAnalysis.AssignmentInCondition.FoundInWhileCondition
    while ( $status = ob_get_status() ) {
        if ( isset( $status['flags'] ) ) {
            $flags = PHP_OUTPUT_HANDLER_CLEANABLE | PHP_OUTPUT_HANDLER_REMOVABLE;
            $deleteable = ( $status['flags'] & $flags ) === $flags;
        } elseif ( isset( $status['del'] ) ) {
            $deleteable = $status['del'];
        } else {
            // Guess that any PHP-internal setting can't be removed.
            $deleteable = $status['type'] !== 0; /* PHP_OUTPUT_HANDLER_INTERNAL */
        }
        if ( !$deleteable ) {
            // Give up, and hope the result doesn't break
            // output behavior.
            break;
        }
        if ( $status['name'] === 'MediaWikiIntegrationTestCase::wfResetOutputBuffersBarrier' ) {
            // Unit testing barrier to prevent this function from breaking PHPUnit.
            break;
        }
        if ( !ob_end_clean() ) {
            // Could not remove output buffer handler; abort now
            // to avoid getting in some kind of infinite loop.
            break;
        }
        if ( $resetGzipEncoding && $status['name'] == 'ob_gzhandler' ) {
            // Reset the 'Content-Encoding' field set by this handler
            // so we can start fresh.
            header_remove( 'Content-Encoding' );
            break;
        }
    }
}
 
function wfTimestamp( $outputtype = TS_UNIX, $ts = 0 ) {
    $ret = ConvertibleTimestamp::convert( $outputtype, $ts );
    if ( $ret === false ) {
        wfDebug( "wfTimestamp() fed bogus time value: TYPE=$outputtype; VALUE=$ts" );
    }
    return $ret;
}
 
function wfTimestampOrNull( $outputtype = TS_UNIX, $ts = null ) {
    if ( $ts === null ) {
        return null;
    } else {
        return wfTimestamp( $outputtype, $ts );
    }
}
 
function wfTimestampNow() {
    return ConvertibleTimestamp::now( TS_MW );
}
 
function wfTempDir() {
    global $wgTmpDirectory;
 
    if ( $wgTmpDirectory !== false ) {
        return $wgTmpDirectory;
    }
 
    return TempFSFile::getUsableTempDirectory();
}
 
function wfMkdirParents( $dir, $mode = null, $caller = null ) {
    global $wgDirectoryMode;
 
    if ( FileBackend::isStoragePath( $dir ) ) {
        throw new LogicException( __FUNCTION__ . " given storage path '$dir'." );
    }
    if ( $caller !== null ) {
        wfDebug( "$caller: called wfMkdirParents($dir)" );
    }
    if ( strval( $dir ) === '' ) {
        return true;
    }
 
    $dir = str_replace( [ '\\', '/' ], DIRECTORY_SEPARATOR, $dir );
    $mode ??= $wgDirectoryMode;
 
    // Turn off the normal warning, we're doing our own below
    // PHP doesn't include the path in its warning message, so we add our own to aid in diagnosis.
    //
    // Repeat existence check if creation failed so that we silently recover in case of
    // a race condition where another request created it since the first check.
    //
    // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
    $ok = is_dir( $dir ) || @mkdir( $dir, $mode, true ) || is_dir( $dir );
    if ( !$ok ) {
        trigger_error( sprintf( "failed to mkdir \"%s\" mode 0%o", $dir, $mode ), E_USER_WARNING );
    }
 
    return $ok;
}
 
function wfRecursiveRemoveDir( $dir ) {
    // taken from https://www.php.net/manual/en/function.rmdir.php#98622
    if ( is_dir( $dir ) ) {
        $objects = scandir( $dir );
        foreach ( $objects as $object ) {
            if ( $object != "." && $object != ".." ) {
                if ( filetype( $dir . '/' . $object ) == "dir" ) {
                    wfRecursiveRemoveDir( $dir . '/' . $object );
                } else {
                    unlink( $dir . '/' . $object );
                }
            }
        }
        rmdir( $dir );
    }
}
 
function wfPercent( $nr, int $acc = 2, bool $round = true ) {
    $accForFormat = $acc >= 0 ? $acc : 0;
    $ret = sprintf( "%.{$accForFormat}f", $nr );
    return $round ? round( (float)$ret, $acc ) . '%' : "$ret%";
}
 
function wfIniGetBool( $setting ) {
    return wfStringToBool( ini_get( $setting ) );
}
 
function wfStringToBool( $val ) {
    $val = strtolower( $val );
    // 'on' and 'true' can't have whitespace around them, but '1' can.
    return $val == 'on'
        || $val == 'true'
        || $val == 'yes'
        || preg_match( "/^\s*[+-]?0*[1-9]/", $val ); // approx C atoi() function
}
 
function wfEscapeShellArg( ...$args ) {
    return Shell::escape( ...$args );
}
 
function wfShellExec( $cmd, &$retval = null, $environ = [],
    $limits = [], $options = []
) {
    if ( Shell::isDisabled() ) {
        $retval = 1;
        // Backwards compatibility be upon us...
        return 'Unable to run external programs, proc_open() is disabled.';
    }
 
    if ( is_array( $cmd ) ) {
        $cmd = Shell::escape( $cmd );
    }
 
    $includeStderr = isset( $options['duplicateStderr'] ) && $options['duplicateStderr'];
    $profileMethod = $options['profileMethod'] ?? wfGetCaller();
 
    try {
        $result = Shell::command( [] )
            ->unsafeParams( (array)$cmd )
            ->environment( $environ )
            ->limits( $limits )
            ->includeStderr( $includeStderr )
            ->profileMethod( $profileMethod )
            // For b/c
            ->restrict( Shell::RESTRICT_NONE )
            ->execute();
    } catch ( ProcOpenError $ex ) {
        $retval = -1;
        return '';
    }
 
    $retval = $result->getExitCode();
 
    return $result->getStdout();
}
 
function wfShellExecWithStderr( $cmd, &$retval = null, $environ = [], $limits = [] ) {
    return wfShellExec( $cmd, $retval, $environ, $limits,
        [ 'duplicateStderr' => true, 'profileMethod' => wfGetCaller() ] );
}
 
function wfShellWikiCmd( $script, array $parameters = [], array $options = [] ) {
    global $wgPhpCli;
    // Give site config file a chance to run the script in a wrapper.
    // The caller may likely want to call wfBasename() on $script.
    ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )
        ->onWfShellWikiCmd( $script, $parameters, $options );
    $cmd = [ $options['php'] ?? $wgPhpCli ];
    if ( isset( $options['wrapper'] ) ) {
        $cmd[] = $options['wrapper'];
    }
    $cmd[] = $script;
    // Escape each parameter for shell
    return Shell::escape( array_merge( $cmd, $parameters ) );
}
 
function wfMerge(
    string $old,
    string $mine,
    string $yours,
    ?string &$simplisticMergeAttempt,
    ?string &$mergeLeftovers = null
): bool {
    global $wgDiff3;
 
    # This check may also protect against code injection in
    # case of broken installations.
    AtEase::suppressWarnings();
    $haveDiff3 = $wgDiff3 && file_exists( $wgDiff3 );
    AtEase::restoreWarnings();
 
    if ( !$haveDiff3 ) {
        wfDebug( "diff3 not found" );
        return false;
    }
 
    # Make temporary files
    $td = wfTempDir();
    $oldtextFile = fopen( $oldtextName = tempnam( $td, 'merge-old-' ), 'w' );
    $mytextFile = fopen( $mytextName = tempnam( $td, 'merge-mine-' ), 'w' );
    $yourtextFile = fopen( $yourtextName = tempnam( $td, 'merge-your-' ), 'w' );
 
    # NOTE: diff3 issues a warning to stderr if any of the files does not end with
    #       a newline character. To avoid this, we normalize the trailing whitespace before
    #       creating the diff.
 
    fwrite( $oldtextFile, rtrim( $old ) . "\n" );
    fclose( $oldtextFile );
    fwrite( $mytextFile, rtrim( $mine ) . "\n" );
    fclose( $mytextFile );
    fwrite( $yourtextFile, rtrim( $yours ) . "\n" );
    fclose( $yourtextFile );
 
    # Check for a conflict
    $cmd = Shell::escape( $wgDiff3, '--text', '--overlap-only', $mytextName,
        $oldtextName, $yourtextName );
    $handle = popen( $cmd, 'r' );
 
    $mergeLeftovers = '';
    do {
        $data = fread( $handle, 8192 );
        if ( $data === false || $data === '' ) {
            break;
        }
        $mergeLeftovers .= $data;
    } while ( true );
    pclose( $handle );
 
    $conflict = $mergeLeftovers !== '';
 
    # Merge differences automatically where possible, preferring "my" text for conflicts.
    $cmd = Shell::escape( $wgDiff3, '--text', '--ed', '--merge', $mytextName,
        $oldtextName, $yourtextName );
    $handle = popen( $cmd, 'r' );
    $simplisticMergeAttempt = '';
    do {
        $data = fread( $handle, 8192 );
        if ( $data === false || $data === '' ) {
            break;
        }
        $simplisticMergeAttempt .= $data;
    } while ( true );
    pclose( $handle );
    unlink( $mytextName );
    unlink( $oldtextName );
    unlink( $yourtextName );
 
    if ( $simplisticMergeAttempt === '' && $old !== '' && !$conflict ) {
        wfDebug( "Unexpected null result from diff3. Command: $cmd" );
        $conflict = true;
    }
    return !$conflict;
}
 
function wfBaseName( $path, $suffix = '' ) {
    if ( $suffix == '' ) {
        $encSuffix = '';
    } else {
        $encSuffix = '(?:' . preg_quote( $suffix, '#' ) . ')?';
    }
 
    $matches = [];
    if ( preg_match( "#([^/\\\\]*?){$encSuffix}[/\\\\]*$#", $path, $matches ) ) {
        return $matches[1];
    } else {
        return '';
    }
}
 
function wfRelativePath( $path, $from ) {
    // Normalize mixed input on Windows...
    $path = str_replace( '/', DIRECTORY_SEPARATOR, $path );
    $from = str_replace( '/', DIRECTORY_SEPARATOR, $from );
 
    // Trim trailing slashes -- fix for drive root
    $path = rtrim( $path, DIRECTORY_SEPARATOR );
    $from = rtrim( $from, DIRECTORY_SEPARATOR );
 
    $pieces = explode( DIRECTORY_SEPARATOR, dirname( $path ) );
    $against = explode( DIRECTORY_SEPARATOR, $from );
 
    if ( $pieces[0] !== $against[0] ) {
        // Non-matching Windows drive letters?
        // Return a full path.
        return $path;
    }
 
    // Trim off common prefix
    while ( count( $pieces ) && count( $against )
        && $pieces[0] == $against[0] ) {
        array_shift( $pieces );
        array_shift( $against );
    }
 
    // relative dots to bump us to the parent
    while ( count( $against ) ) {
        array_unshift( $pieces, '..' );
        array_shift( $against );
    }
 
    $pieces[] = wfBaseName( $path );
 
    return implode( DIRECTORY_SEPARATOR, $pieces );
}
 
function wfScript( $script = 'index' ) {
    global $wgScriptPath, $wgScript, $wgLoadScript;
    if ( $script === 'index' ) {
        return $wgScript;
    } elseif ( $script === 'load' ) {
        return $wgLoadScript;
    } else {
        return "{$wgScriptPath}/{$script}.php";
    }
}
 
function wfBoolToStr( $value ) {
    return $value ? 'true' : 'false';
}
 
function wfGetNull() {
    return wfIsWindows() ? 'NUL' : '/dev/null';
}
 
function wfStripIllegalFilenameChars( $name ) {
    global $wgIllegalFileChars;
    $illegalFileChars = $wgIllegalFileChars ? "|[" . $wgIllegalFileChars . "]" : '';
    $name = preg_replace(
        "/[^" . Title::legalChars() . "]" . $illegalFileChars . "/",
        '-',
        $name
    );
    // $wgIllegalFileChars may not include '/' and '\', so we still need to do this
    $name = wfBaseName( $name );
    return $name;
}
 
function wfMemoryLimit( $newLimit ) {
    $oldLimit = wfShorthandToInteger( ini_get( 'memory_limit' ) );
    // If the INI config is already unlimited, there is nothing larger
    if ( $oldLimit != -1 ) {
        $newLimit = wfShorthandToInteger( (string)$newLimit );
        if ( $newLimit == -1 ) {
            wfDebug( "Removing PHP's memory limit" );
            AtEase::suppressWarnings();
            ini_set( 'memory_limit', $newLimit );
            AtEase::restoreWarnings();
        } elseif ( $newLimit > $oldLimit ) {
            wfDebug( "Raising PHP's memory limit to $newLimit bytes" );
            AtEase::suppressWarnings();
            ini_set( 'memory_limit', $newLimit );
            AtEase::restoreWarnings();
        }
    }
}
 
function wfTransactionalTimeLimit() {
    global $wgTransactionalTimeLimit;
 
    $timeout = RequestTimeout::singleton();
    $timeLimit = $timeout->getWallTimeLimit();
    if ( $timeLimit !== INF ) {
        // RequestTimeout library is active
        if ( $wgTransactionalTimeLimit > $timeLimit ) {
            $timeout->setWallTimeLimit( $wgTransactionalTimeLimit );
        }
    } else {
        // Fallback case, likely $wgRequestTimeLimit === null
        $timeLimit = (int)ini_get( 'max_execution_time' );
        // Note that CLI scripts use 0
        if ( $timeLimit > 0 && $wgTransactionalTimeLimit > $timeLimit ) {
            $timeout->setWallTimeLimit( $wgTransactionalTimeLimit );
        }
    }
    ignore_user_abort( true ); // ignore client disconnects
 
    return $timeLimit;
}
 
function wfShorthandToInteger( ?string $string = '', int $default = -1 ): int {
    $string = trim( $string ?? '' );
    if ( $string === '' ) {
        return $default;
    }
    $last = $string[strlen( $string ) - 1];
    $val = intval( $string );
    switch ( $last ) {
        case 'g':
        case 'G':
            $val *= 1024;
            // break intentionally missing
        case 'm':
        case 'M':
            $val *= 1024;
            // break intentionally missing
        case 'k':
        case 'K':
            $val *= 1024;
    }
 
    return $val;
}
 
function wfIsInfinity( $str ) {
    // The INFINITY_VALS are hardcoded elsewhere in MediaWiki (e.g. mediawiki.special.block.js).
    return in_array( $str, ExpiryDef::INFINITY_VALS );
}
 
function wfThumbIsStandard( File $file, array $params ) {
    global $wgThumbLimits, $wgImageLimits, $wgResponsiveImages;
 
    $multipliers = [ 1 ];
    if ( $wgResponsiveImages ) {
        // These available sizes are hardcoded currently elsewhere in MediaWiki.
        // @see Linker::processResponsiveImages
        $multipliers[] = 1.5;
        $multipliers[] = 2;
    }
 
    $handler = $file->getHandler();
    if ( !$handler || !isset( $params['width'] ) ) {
        return false;
    }
 
    $basicParams = [];
    if ( isset( $params['page'] ) ) {
        $basicParams['page'] = $params['page'];
    }
 
    $thumbLimits = [];
    $imageLimits = [];
    // Expand limits to account for multipliers
    foreach ( $multipliers as $multiplier ) {
        $thumbLimits = array_merge( $thumbLimits, array_map(
            static function ( $width ) use ( $multiplier ) {
                return round( $width * $multiplier );
            }, $wgThumbLimits )
        );
        $imageLimits = array_merge( $imageLimits, array_map(
            static function ( $pair ) use ( $multiplier ) {
                return [
                    round( $pair[0] * $multiplier ),
                    round( $pair[1] * $multiplier ),
                ];
            }, $wgImageLimits )
        );
    }
 
    // Check if the width matches one of $wgThumbLimits
    if ( in_array( $params['width'], $thumbLimits ) ) {
        $normalParams = $basicParams + [ 'width' => $params['width'] ];
        // Append any default values to the map (e.g. "lossy", "lossless", ...)
        $handler->normaliseParams( $file, $normalParams );
    } else {
        // If not, then check if the width matches one of $wgImageLimits
        $match = false;
        foreach ( $imageLimits as $pair ) {
            $normalParams = $basicParams + [ 'width' => $pair[0], 'height' => $pair[1] ];
            // Decide whether the thumbnail should be scaled on width or height.
            // Also append any default values to the map (e.g. "lossy", "lossless", ...)
            $handler->normaliseParams( $file, $normalParams );
            // Check if this standard thumbnail size maps to the given width
            if ( $normalParams['width'] == $params['width'] ) {
                $match = true;
                break;
            }
        }
        if ( !$match ) {
            return false; // not standard for description pages
        }
    }
 
    // Check that the given values for non-page, non-width, params are just defaults
    foreach ( $params as $key => $value ) {
        if ( !isset( $normalParams[$key] ) || $normalParams[$key] != $value ) {
            return false;
        }
    }
 
    return true;
}
 
function wfArrayPlus2d( array $baseArray, array $newValues ) {
    // First merge items that are in both arrays
    foreach ( $baseArray as $name => &$groupVal ) {
        if ( isset( $newValues[$name] ) ) {
            $groupVal += $newValues[$name];
        }
    }
    // Now add items that didn't exist yet
    $baseArray += $newValues;
 
    return $baseArray;
}