GlobalFunctions.php

Go to the documentation of this file.

<?php
if ( !defined( 'MEDIAWIKI' ) ) {
    die( "This file is part of MediaWiki, it is not a valid entry point" );
}

// Hide compatibility functions from Doxygen

if ( !function_exists( 'mb_substr' ) ) {
    function mb_substr( $str, $start, $count = 'end' ) {
        return Fallback::mb_substr( $str, $start, $count );
    }

    function mb_substr_split_unicode( $str, $splitPos ) {
        return Fallback::mb_substr_split_unicode( $str, $splitPos );
    }
}

if ( !function_exists( 'mb_strlen' ) ) {
    function mb_strlen( $str, $enc = '' ) {
        return Fallback::mb_strlen( $str, $enc );
    }
}

if ( !function_exists( 'mb_strpos' ) ) {
    function mb_strpos( $haystack, $needle, $offset = 0, $encoding = '' ) {
        return Fallback::mb_strpos( $haystack, $needle, $offset, $encoding );
    }
}

if ( !function_exists( 'mb_strrpos' ) ) {
    function mb_strrpos( $haystack, $needle, $offset = 0, $encoding = '' ) {
        return Fallback::mb_strrpos( $haystack, $needle, $offset, $encoding );
    }
}

// gzdecode function only exists in PHP >= 5.4.0
// http://php.net/gzdecode
if ( !function_exists( 'gzdecode' ) ) {
    function gzdecode( $data ) {
        return gzinflate( substr( $data, 10, -8 ) );
    }
}

// hash_equals function only exists in PHP >= 5.6.0
if ( !function_exists( 'hash_equals' ) ) {
    function hash_equals( $known_string, $user_string ) {
        // Strict type checking as in PHP's native implementation
        if ( !is_string( $known_string ) ) {
            trigger_error( 'hash_equals(): Expected known_string to be a string, ' .
                gettype( $known_string ) . ' given', E_USER_WARNING );

            return false;
        }

        if ( !is_string( $user_string ) ) {
            trigger_error( 'hash_equals(): Expected user_string to be a string, ' .
                gettype( $user_string ) . ' given', E_USER_WARNING );

            return false;
        }

        // Note that we do one thing PHP doesn't: try to avoid leaking information about
        // relative lengths of $known_string and $user_string, and of multiple $known_strings.
        // However, lengths may still inevitably leak through, for example, CPU cache misses.
        $known_string_len = strlen( $known_string );
        $user_string_len = strlen( $user_string );
        $result = $known_string_len ^ $user_string_len;
        for ( $i = 0; $i < $user_string_len; $i++ ) {
            $result |= ord( $known_string[$i % $known_string_len] ) ^ ord( $user_string[$i] );
        }

        return ( $result === 0 );
    }
}

function wfArrayDiff2( $a, $b ) {
    return array_udiff( $a, $b, 'wfArrayDiff2_cmp' );
}

function wfArrayDiff2_cmp( $a, $b ) {
    if ( is_string( $a ) && is_string( $b ) ) {
        return strcmp( $a, $b );
    } elseif ( count( $a ) !== count( $b ) ) {
        return count( $a ) < count( $b ) ? -1 : 1;
    } else {
        reset( $a );
        reset( $b );
        while ( ( list( , $valueA ) = each( $a ) ) && ( list( , $valueB ) = each( $b ) ) ) {
            $cmp = strcmp( $valueA, $valueB );
            if ( $cmp !== 0 ) {
                return $cmp;
            }
        }
        return 0;
    }
}

function wfAppendToArrayIfNotDefault( $key, $value, $default, &$changed ) {
    if ( is_null( $changed ) ) {
        throw new MWException( 'GlobalFunctions::wfAppendToArrayIfNotDefault got null' );
    }
    if ( $default[$key] !== $value ) {
        $changed[$key] = $value;
    }
}

function wfMergeErrorArrays( /*...*/ ) {
    $args = func_get_args();
    $out = array();
    foreach ( $args as $errors ) {
        foreach ( $errors as $params ) {
            # @todo FIXME: Sometimes get nested arrays for $params,
            # which leads to E_NOTICEs
            $spec = implode( "\t", $params );
            $out[$spec] = $params;
        }
    }
    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 );

    $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 = 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 ( is_null( $s ) ) {
        $needle = null;
        return '';
    }

    if ( is_null( $needle ) ) {
        $needle = array( '%3B', '%40', '%24', '%21', '%2A', '%28', '%29', '%2C', '%2F' );
        if ( !isset( $_SERVER['SERVER_SOFTWARE'] ) ||
            ( strpos( $_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS/7' ) === false )
        ) {
            $needle[] = '%3A';
        }
    }

    $s = urlencode( $s );
    $s = str_ireplace(
        $needle,
        array( ';', '@', '$', '!', '*', '(', ')', ',', '/', ':' ),
        $s
    );

    return $s;
}

function wfArrayToCgi( $array1, $array2 = null, $prefix = '' ) {
    if ( !is_null( $array2 ) ) {
        $array1 = $array1 + $array2;
    }

    $cgi = '';
    foreach ( $array1 as $key => $value ) {
        if ( !is_null( $value ) && $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 = array();
    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 {
            list( $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 = array( $k => $temp );
            }
            if ( isset( $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 != '' ) {
        if ( false === strpos( $url, '?' ) ) {
            $url .= '?';
        } else {
            $url .= '&';
        }
        $url .= $query;
    }
    return $url;
}

function wfExpandUrl( $url, $defaultProto = PROTO_CURRENT ) {
    global $wgServer, $wgCanonicalServer, $wgInternalServer, $wgRequest,
        $wgHttpsPort;
    if ( $defaultProto === PROTO_CANONICAL ) {
        $serverUrl = $wgCanonicalServer;
    } elseif ( $defaultProto === PROTO_INTERNAL && $wgInternalServer !== false ) {
        // Make $wgInternalServer fall back to $wgServer if not set
        $serverUrl = $wgInternalServer;
    } else {
        $serverUrl = $wgServer;
        if ( $defaultProto === PROTO_CURRENT ) {
            $defaultProto = $wgRequest->getProtocol() . '://';
        }
    }

    // Analyze $serverUrl to obtain its protocol
    $bits = wfParseUrl( $serverUrl );
    $serverHasProto = $bits && $bits['scheme'] != '';

    if ( $defaultProto === PROTO_CANONICAL || $defaultProto === PROTO_INTERNAL ) {
        if ( $serverHasProto ) {
            $defaultProto = $bits['scheme'] . '://';
        } else {
            // $wgCanonicalServer or $wgInternalServer doesn't have a protocol.
            // This really isn't supposed to happen. Fall back to HTTP in this
            // ridiculous case.
            $defaultProto = PROTO_HTTP;
        }
    }

    $defaultProtoWithoutSlashes = substr( $defaultProto, 0, -2 );

    if ( substr( $url, 0, 2 ) == '//' ) {
        $url = $defaultProtoWithoutSlashes . $url;
    } elseif ( substr( $url, 0, 1 ) == '/' ) {
        // If $serverUrl is protocol-relative, prepend $defaultProtoWithoutSlashes,
        // otherwise leave it alone.
        $url = ( $serverHasProto ? '' : $defaultProtoWithoutSlashes ) . $serverUrl . $url;
    }

    $bits = wfParseUrl( $url );

    // ensure proper port for HTTPS arrives in URL
    // https://bugzilla.wikimedia.org/show_bug.cgi?id=65184
    if ( $defaultProto === PROTO_HTTPS && $wgHttpsPort != 443 ) {
        $bits['port'] = $wgHttpsPort;
    }

    if ( $bits && isset( $bits['path'] ) ) {
        $bits['path'] = wfRemoveDotSegments( $bits['path'] );
        return wfAssembleUrl( $bits );
    } elseif ( $bits ) {
        # No path to expand
        return $url;
    } elseif ( substr( $url, 0, 1 ) != '/' ) {
        # URL is a relative path
        return wfRemoveDotSegments( $url );
    }

    # Expanded URL is not valid.
    return false;
}

function wfAssembleUrl( $urlParts ) {
    $result = '';

    if ( isset( $urlParts['delimiter'] ) ) {
        if ( isset( $urlParts['scheme'] ) ) {
            $result .= $urlParts['scheme'];
        }

        $result .= $urlParts['delimiter'];
    }

    if ( isset( $urlParts['host'] ) ) {
        if ( isset( $urlParts['user'] ) ) {
            $result .= $urlParts['user'];
            if ( isset( $urlParts['pass'] ) ) {
                $result .= ':' . $urlParts['pass'];
            }
            $result .= '@';
        }

        $result .= $urlParts['host'];

        if ( isset( $urlParts['port'] ) ) {
            $result .= ':' . $urlParts['port'];
        }
    }

    if ( isset( $urlParts['path'] ) ) {
        $result .= $urlParts['path'];
    }

    if ( isset( $urlParts['query'] ) ) {
        $result .= '?' . $urlParts['query'];
    }

    if ( isset( $urlParts['fragment'] ) ) {
        $result .= '#' . $urlParts['fragment'];
    }

    return $result;
}

function wfRemoveDotSegments( $urlPath ) {
    $output = '';
    $inputOffset = 0;
    $inputLength = strlen( $urlPath );

    while ( $inputOffset < $inputLength ) {
        $prefixLengthOne = substr( $urlPath, $inputOffset, 1 );
        $prefixLengthTwo = substr( $urlPath, $inputOffset, 2 );
        $prefixLengthThree = substr( $urlPath, $inputOffset, 3 );
        $prefixLengthFour = substr( $urlPath, $inputOffset, 4 );
        $trimOutput = false;

        if ( $prefixLengthTwo == './' ) {
            # Step A, remove leading "./"
            $inputOffset += 2;
        } elseif ( $prefixLengthThree == '../' ) {
            # Step A, remove leading "../"
            $inputOffset += 3;
        } elseif ( ( $prefixLengthTwo == '/.' ) && ( $inputOffset + 2 == $inputLength ) ) {
            # Step B, replace leading "/.$" with "/"
            $inputOffset += 1;
            $urlPath[$inputOffset] = '/';
        } elseif ( $prefixLengthThree == '/./' ) {
            # Step B, replace leading "/./" with "/"
            $inputOffset += 2;
        } elseif ( $prefixLengthThree == '/..' && ( $inputOffset + 3 == $inputLength ) ) {
            # Step C, replace leading "/..$" with "/" and
            # remove last path component in output
            $inputOffset += 2;
            $urlPath[$inputOffset] = '/';
            $trimOutput = true;
        } elseif ( $prefixLengthFour == '/../' ) {
            # Step C, replace leading "/../" with "/" and
            # remove last path component in output
            $inputOffset += 3;
            $trimOutput = true;
        } elseif ( ( $prefixLengthOne == '.' ) && ( $inputOffset + 1 == $inputLength ) ) {
            # Step D, remove "^.$"
            $inputOffset += 1;
        } elseif ( ( $prefixLengthTwo == '..' ) && ( $inputOffset + 2 == $inputLength ) ) {
            # Step D, remove "^..$"
            $inputOffset += 2;
        } else {
            # Step E, move leading path segment to output
            if ( $prefixLengthOne == '/' ) {
                $slashPos = strpos( $urlPath, '/', $inputOffset + 1 );
            } else {
                $slashPos = strpos( $urlPath, '/', $inputOffset );
            }
            if ( $slashPos === false ) {
                $output .= substr( $urlPath, $inputOffset );
                $inputOffset = $inputLength;
            } else {
                $output .= substr( $urlPath, $inputOffset, $slashPos - $inputOffset );
                $inputOffset += $slashPos - $inputOffset;
            }
        }

        if ( $trimOutput ) {
            $slashPos = strrpos( $output, '/' );
            if ( $slashPos === false ) {
                $output = '';
            } else {
                $output = substr( $output, 0, $slashPos );
            }
        }
    }

    return $output;
}

function wfUrlProtocols( $includeProtocolRelative = true ) {
    global $wgUrlProtocols;

    // Cache return values separately based on $includeProtocolRelative
    static $withProtRel = null, $withoutProtRel = null;
    $cachedValue = $includeProtocolRelative ? $withProtRel : $withoutProtRel;
    if ( !is_null( $cachedValue ) ) {
        return $cachedValue;
    }

    // Support old-style $wgUrlProtocols strings, for backwards compatibility
    // with LocalSettings files from 1.5
    if ( is_array( $wgUrlProtocols ) ) {
        $protocols = array();
        foreach ( $wgUrlProtocols as $protocol ) {
            // Filter out '//' if !$includeProtocolRelative
            if ( $includeProtocolRelative || $protocol !== '//' ) {
                $protocols[] = preg_quote( $protocol, '/' );
            }
        }

        $retval = implode( '|', $protocols );
    } else {
        // Ignore $includeProtocolRelative in this case
        // This case exists for pre-1.6 compatibility, and we can safely assume
        // that '//' won't appear in a pre-1.6 config because protocol-relative
        // URLs weren't supported until 1.18
        $retval = $wgUrlProtocols;
    }

    // Cache return value
    if ( $includeProtocolRelative ) {
        $withProtRel = $retval;
    } else {
        $withoutProtRel = $retval;
    }
    return $retval;
}

function wfUrlProtocolsWithoutProtRel() {
    return wfUrlProtocols( false );
}

function wfParseUrl( $url ) {
    global $wgUrlProtocols; // Allow all protocols defined in DefaultSettings/LocalSettings.php

    // Protocol-relative URLs are handled really badly by parse_url(). It's so
    // bad that the easiest way to handle them is to just prepend 'http:' and
    // strip the protocol out later.
    $wasRelative = substr( $url, 0, 2 ) == '//';
    if ( $wasRelative ) {
        $url = "http:$url";
    }
    wfSuppressWarnings();
    $bits = parse_url( $url );
    wfRestoreWarnings();
    // parse_url() returns an array without scheme for some invalid URLs, e.g.
    // parse_url("%0Ahttp://example.com") == array( 'host' => '%0Ahttp', 'path' => 'example.com' )
    if ( !$bits || !isset( $bits['scheme'] ) ) {
        return false;
    }

    // parse_url() incorrectly handles schemes case-sensitively. Convert it to lowercase.
    $bits['scheme'] = strtolower( $bits['scheme'] );

    // most of the protocols are followed by ://, but mailto: and sometimes news: not, check for it
    if ( in_array( $bits['scheme'] . '://', $wgUrlProtocols ) ) {
        $bits['delimiter'] = '://';
    } elseif ( in_array( $bits['scheme'] . ':', $wgUrlProtocols ) ) {
        $bits['delimiter'] = ':';
        // parse_url detects for news: and mailto: the host part of an url as path
        // We have to correct this wrong detection
        if ( isset( $bits['path'] ) ) {
            $bits['host'] = $bits['path'];
            $bits['path'] = '';
        }
    } else {
        return false;
    }

    /* Provide an empty host for eg. file:/// urls (see bug 28627) */
    if ( !isset( $bits['host'] ) ) {
        $bits['host'] = '';

        // bug 45069
        if ( isset( $bits['path'] ) ) {
            /* parse_url loses the third / for file:///c:/ urls (but not on variants) */
            if ( substr( $bits['path'], 0, 1 ) !== '/' ) {
                $bits['path'] = '/' . $bits['path'];
            }
        } else {
            $bits['path'] = '';
        }
    }

    // If the URL was protocol-relative, fix scheme and delimiter
    if ( $wasRelative ) {
        $bits['scheme'] = '';
        $bits['delimiter'] = '//';
    }
    return $bits;
}

function wfExpandIRI( $url ) {
    return preg_replace_callback(
        '/((?:%[89A-F][0-9A-F])+)/i',
        'wfExpandIRI_callback',
        wfExpandUrl( $url )
    );
}

function wfExpandIRI_callback( $matches ) {
    return urldecode( $matches[1] );
}

function wfMakeUrlIndexes( $url ) {
    $bits = wfParseUrl( $url );

    // Reverse the labels in the hostname, convert to lower case
    // For emails reverse domainpart only
    if ( $bits['scheme'] == 'mailto' ) {
        $mailparts = explode( '@', $bits['host'], 2 );
        if ( count( $mailparts ) === 2 ) {
            $domainpart = strtolower( implode( '.', array_reverse( explode( '.', $mailparts[1] ) ) ) );
        } else {
            // No domain specified, don't mangle it
            $domainpart = '';
        }
        $reversedHost = $domainpart . '@' . $mailparts[0];
    } else {
        $reversedHost = strtolower( implode( '.', array_reverse( explode( '.', $bits['host'] ) ) ) );
    }
    // Add an extra dot to the end
    // Why? Is it in wrong place in mailto links?
    if ( substr( $reversedHost, -1, 1 ) !== '.' ) {
        $reversedHost .= '.';
    }
    // Reconstruct the pseudo-URL
    $prot = $bits['scheme'];
    $index = $prot . $bits['delimiter'] . $reversedHost;
    // Leave out user and password. Add the port, path, query and fragment
    if ( isset( $bits['port'] ) ) {
        $index .= ':' . $bits['port'];
    }
    if ( isset( $bits['path'] ) ) {
        $index .= $bits['path'];
    } else {
        $index .= '/';
    }
    if ( isset( $bits['query'] ) ) {
        $index .= '?' . $bits['query'];
    }
    if ( isset( $bits['fragment'] ) ) {
        $index .= '#' . $bits['fragment'];
    }

    if ( $prot == '' ) {
        return array( "http:$index", "https:$index" );
    } else {
        return array( $index );
    }
}

function wfMatchesDomainList( $url, $domains ) {
    $bits = wfParseUrl( $url );
    if ( is_array( $bits ) && isset( $bits['host'] ) ) {
        $host = '.' . $bits['host'];
        foreach ( (array)$domains as $domain ) {
            $domain = '.' . $domain;
            if ( substr( $host, -strlen( $domain ) ) === $domain ) {
                return true;
            }
        }
    }
    return false;
}

function wfDebug( $text, $dest = 'all' ) {
    global $wgDebugLogFile, $wgDebugRawPage, $wgDebugLogPrefix;

    if ( !$wgDebugRawPage && wfIsDebugRawPage() ) {
        return;
    }

    // Turn $dest into a string if it's a boolean (for b/c)
    if ( $dest === true ) {
        $dest = 'all';
    } elseif ( $dest === false ) {
        $dest = 'log';
    }

    $timer = wfDebugTimer();
    if ( $timer !== '' ) {
        $text = preg_replace( '/[^\n]/', $timer . '\0', $text, 1 );
    }

    if ( $dest === 'all' ) {
        MWDebug::debugMsg( $text );
    }

    if ( $wgDebugLogFile != '' ) {
        # Strip unprintables; they can switch terminal modes when binary data
        # gets dumped, which is pretty annoying.
        $text = preg_replace( '![\x00-\x08\x0b\x0c\x0e-\x1f]!', ' ', $text );
        $text = $wgDebugLogPrefix . $text;
        wfErrorLog( $text, $wgDebugLogFile );
    }
}

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
    if ( ( isset( $_GET['action'] ) && $_GET['action'] == 'raw' )
        || (
            isset( $_SERVER['SCRIPT_NAME'] )
            && substr( $_SERVER['SCRIPT_NAME'], -8 ) == 'load.php'
        )
    ) {
        $cache = true;
    } else {
        $cache = false;
    }
    return $cache;
}

function wfDebugTimer() {
    global $wgDebugTimestamps, $wgRequestTime;

    if ( !$wgDebugTimestamps ) {
        return '';
    }

    $prefix = sprintf( "%6.4f", microtime( true ) - $wgRequestTime );
    $mem = sprintf( "%5.1fM", ( memory_get_usage( true ) / ( 1024 * 1024 ) ) );
    return "$prefix $mem  ";
}

function wfDebugMem( $exact = false ) {
    $mem = memory_get_usage();
    if ( !$exact ) {
        $mem = floor( $mem / 1024 ) . ' KiB';
    } else {
        $mem .= ' B';
    }
    wfDebug( "Memory usage: $mem\n" );
}

function wfDebugLog( $logGroup, $text, $dest = 'all' ) {
    global $wgDebugLogGroups;

    $text = trim( $text ) . "\n";

    // Turn $dest into a string if it's a boolean (for b/c)
    if ( $dest === true ) {
        $dest = 'all';
    } elseif ( $dest === false ) {
        $dest = 'private';
    }

    if ( !isset( $wgDebugLogGroups[$logGroup] ) ) {
        if ( $dest !== 'private' ) {
            wfDebug( "[$logGroup] $text", $dest );
        }
        return;
    }

    if ( $dest === 'all' ) {
        MWDebug::debugMsg( "[$logGroup] $text" );
    }

    $logConfig = $wgDebugLogGroups[$logGroup];
    if ( $logConfig === false ) {
        return;
    }
    if ( is_array( $logConfig ) ) {
        if ( isset( $logConfig['sample'] ) && mt_rand( 1, $logConfig['sample'] ) !== 1 ) {
            return;
        }
        $destination = $logConfig['destination'];
    } else {
        $destination = strval( $logConfig );
    }

    $time = wfTimestamp( TS_DB );
    $wiki = wfWikiID();
    $host = wfHostname();
    wfErrorLog( "$time $host $wiki: $text", $destination );
}

function wfLogDBError( $text ) {
    global $wgDBerrorLog, $wgDBerrorLogTZ;
    static $logDBErrorTimeZoneObject = null;

    if ( $wgDBerrorLog ) {
        $host = wfHostname();
        $wiki = wfWikiID();

        if ( $wgDBerrorLogTZ && !$logDBErrorTimeZoneObject ) {
            $logDBErrorTimeZoneObject = new DateTimeZone( $wgDBerrorLogTZ );
        }

        // Workaround for https://bugs.php.net/bug.php?id=52063
        // Can be removed when min PHP > 5.3.2
        if ( $logDBErrorTimeZoneObject === null ) {
            $d = date_create( "now" );
        } else {
            $d = date_create( "now", $logDBErrorTimeZoneObject );
        }

        $date = $d->format( 'D M j G:i:s T Y' );

        $text = "$date\t$host\t$wiki\t" . trim( $text ) . "\n";
        wfErrorLog( $text, $wgDBerrorLog );
    }
}

function wfDeprecated( $function, $version = false, $component = false, $callerOffset = 2 ) {
    MWDebug::deprecated( $function, $version, $component, $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 wfErrorLog( $text, $file ) {
    if ( substr( $file, 0, 4 ) == 'udp:' ) {
        # Needs the sockets extension
        if ( preg_match( '!^(tcp|udp):(?://)?\[([0-9a-fA-F:]+)\]:(\d+)(?:/(.*))?$!', $file, $m ) ) {
            // IPv6 bracketed host
            $host = $m[2];
            $port = intval( $m[3] );
            $prefix = isset( $m[4] ) ? $m[4] : false;
            $domain = AF_INET6;
        } elseif ( preg_match( '!^(tcp|udp):(?://)?([a-zA-Z0-9.-]+):(\d+)(?:/(.*))?$!', $file, $m ) ) {
            $host = $m[2];
            if ( !IP::isIPv4( $host ) ) {
                $host = gethostbyname( $host );
            }
            $port = intval( $m[3] );
            $prefix = isset( $m[4] ) ? $m[4] : false;
            $domain = AF_INET;
        } else {
            throw new MWException( __METHOD__ . ': Invalid UDP specification' );
        }

        // Clean it up for the multiplexer
        if ( strval( $prefix ) !== '' ) {
            $text = preg_replace( '/^/m', $prefix . ' ', $text );

            // Limit to 64KB
            if ( strlen( $text ) > 65506 ) {
                $text = substr( $text, 0, 65506 );
            }

            if ( substr( $text, -1 ) != "\n" ) {
                $text .= "\n";
            }
        } elseif ( strlen( $text ) > 65507 ) {
            $text = substr( $text, 0, 65507 );
        }

        $sock = socket_create( $domain, SOCK_DGRAM, SOL_UDP );
        if ( !$sock ) {
            return;
        }

        socket_sendto( $sock, $text, strlen( $text ), 0, $host, $port );
        socket_close( $sock );
    } else {
        wfSuppressWarnings();
        $exists = file_exists( $file );
        $size = $exists ? filesize( $file ) : false;
        if ( !$exists || ( $size !== false && $size + strlen( $text ) < 0x7fffffff ) ) {
            file_put_contents( $file, $text, FILE_APPEND );
        }
        wfRestoreWarnings();
    }
}

function wfLogProfilingData() {
    global $wgRequestTime, $wgDebugLogFile, $wgDebugLogGroups, $wgDebugRawPage;
    global $wgProfileLimit, $wgUser, $wgRequest;

    StatCounter::singleton()->flush();

    $profiler = Profiler::instance();

    # Profiling must actually be enabled...
    if ( $profiler->isStub() ) {
        return;
    }

    // Get total page request time and only show pages that longer than
    // $wgProfileLimit time (default is 0)
    $elapsed = microtime( true ) - $wgRequestTime;
    if ( $elapsed <= $wgProfileLimit ) {
        return;
    }

    $profiler->logData();

    // Check whether this should be logged in the debug file.
    if ( isset( $wgDebugLogGroups['profileoutput'] )
        && $wgDebugLogGroups['profileoutput'] === false
    ) {
        // Explicitely disabled
        return;
    }
    if ( !isset( $wgDebugLogGroups['profileoutput'] ) && $wgDebugLogFile == '' ) {
        // Logging not enabled; no point going further
        return;
    }
    if ( !$wgDebugRawPage && wfIsDebugRawPage() ) {
        return;
    }

    $forward = '';
    if ( !empty( $_SERVER['HTTP_X_FORWARDED_FOR'] ) ) {
        $forward = ' forwarded for ' . $_SERVER['HTTP_X_FORWARDED_FOR'];
    }
    if ( !empty( $_SERVER['HTTP_CLIENT_IP'] ) ) {
        $forward .= ' client IP ' . $_SERVER['HTTP_CLIENT_IP'];
    }
    if ( !empty( $_SERVER['HTTP_FROM'] ) ) {
        $forward .= ' from ' . $_SERVER['HTTP_FROM'];
    }
    if ( $forward ) {
        $forward = "\t(proxied via {$_SERVER['REMOTE_ADDR']}{$forward})";
    }
    // Don't load $wgUser at this late stage just for statistics purposes
    // @todo FIXME: We can detect some anons even if it is not loaded. See User::getId()
    if ( $wgUser->isItemLoaded( 'id' ) && $wgUser->isAnon() ) {
        $forward .= ' anon';
    }

    // Command line script uses a FauxRequest object which does not have
    // any knowledge about an URL and throw an exception instead.
    try {
        $requestUrl = $wgRequest->getRequestURL();
    } catch ( MWException $e ) {
        $requestUrl = 'n/a';
    }

    $log = sprintf( "%s\t%04.3f\t%s\n",
        gmdate( 'YmdHis' ), $elapsed,
        urldecode( $requestUrl . $forward ) );

    wfDebugLog( 'profileoutput', $log . $profiler->getOutput() );
}

function wfIncrStats( $key, $count = 1 ) {
    StatCounter::singleton()->incr( $key, $count );
}

function wfReadOnly() {
    return wfReadOnlyReason() !== false;
}

function wfReadOnlyReason() {
    global $wgReadOnly, $wgReadOnlyFile;

    if ( $wgReadOnly === null ) {
        // Set $wgReadOnly for faster access next time
        if ( is_file( $wgReadOnlyFile ) && filesize( $wgReadOnlyFile ) > 0 ) {
            $wgReadOnly = file_get_contents( $wgReadOnlyFile );
        } else {
            $wgReadOnly = false;
        }
    }

    return $wgReadOnly;
}

function wfGetLangObj( $langcode = false ) {
    # Identify which language to get or create a language object for.
    # Using is_object here due to Stub objects.
    if ( is_object( $langcode ) ) {
        # Great, we already have the object (hopefully)!
        return $langcode;
    }

    global $wgContLang, $wgLanguageCode;
    if ( $langcode === true || $langcode === $wgLanguageCode ) {
        # $langcode is the language code of the wikis content language object.
        # or it is a boolean and value is true
        return $wgContLang;
    }

    global $wgLang;
    if ( $langcode === false || $langcode === $wgLang->getCode() ) {
        # $langcode is the language code of user language object.
        # or it was a boolean and value is false
        return $wgLang;
    }

    $validCodes = array_keys( Language::fetchLanguageNames() );
    if ( in_array( $langcode, $validCodes ) ) {
        # $langcode corresponds to a valid language.
        return Language::factory( $langcode );
    }

    # $langcode is a string, but not a valid language code; use content language.
    wfDebug( "Invalid language code passed to wfGetLangObj, falling back to content language.\n" );
    return $wgContLang;
}

function wfMessage( $key /*...*/ ) {
    $params = func_get_args();
    array_shift( $params );
    if ( isset( $params[0] ) && is_array( $params[0] ) ) {
        $params = $params[0];
    }
    return new Message( $key, $params );
}

function wfMessageFallback( /*...*/ ) {
    $args = func_get_args();
    return call_user_func_array( 'Message::newFallbackSequence', $args );
}

function wfMsg( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    $args = func_get_args();
    array_shift( $args );
    return wfMsgReal( $key, $args );
}

function wfMsgNoTrans( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    $args = func_get_args();
    array_shift( $args );
    return wfMsgReal( $key, $args, true, false, false );
}

function wfMsgForContent( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    global $wgForceUIMsgAsContentMsg;
    $args = func_get_args();
    array_shift( $args );
    $forcontent = true;
    if ( is_array( $wgForceUIMsgAsContentMsg )
        && in_array( $key, $wgForceUIMsgAsContentMsg )
    ) {
        $forcontent = false;
    }
    return wfMsgReal( $key, $args, true, $forcontent );
}

function wfMsgForContentNoTrans( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    global $wgForceUIMsgAsContentMsg;
    $args = func_get_args();
    array_shift( $args );
    $forcontent = true;
    if ( is_array( $wgForceUIMsgAsContentMsg )
        && in_array( $key, $wgForceUIMsgAsContentMsg )
    ) {
        $forcontent = false;
    }
    return wfMsgReal( $key, $args, true, $forcontent, false );
}

function wfMsgReal( $key, $args, $useDB = true, $forContent = false, $transform = true ) {
    wfDeprecated( __METHOD__, '1.21' );

    wfProfileIn( __METHOD__ );
    $message = wfMsgGetKey( $key, $useDB, $forContent, $transform );
    $message = wfMsgReplaceArgs( $message, $args );
    wfProfileOut( __METHOD__ );
    return $message;
}

function wfMsgGetKey( $key, $useDB = true, $langCode = false, $transform = true ) {
    wfDeprecated( __METHOD__, '1.21' );

    wfRunHooks( 'NormalizeMessageKey', array( &$key, &$useDB, &$langCode, &$transform ) );

    $cache = MessageCache::singleton();
    $message = $cache->get( $key, $useDB, $langCode );
    if ( $message === false ) {
        $message = '&lt;' . htmlspecialchars( $key ) . '&gt;';
    } elseif ( $transform ) {
        $message = $cache->transform( $message );
    }
    return $message;
}

function wfMsgReplaceArgs( $message, $args ) {
    # Fix windows line-endings
    # Some messages are split with explode("\n", $msg)
    $message = str_replace( "\r", '', $message );

    // Replace arguments
    if ( count( $args ) ) {
        if ( is_array( $args[0] ) ) {
            $args = array_values( $args[0] );
        }
        $replacementKeys = array();
        foreach ( $args as $n => $param ) {
            $replacementKeys['$' . ( $n + 1 )] = $param;
        }
        $message = strtr( $message, $replacementKeys );
    }

    return $message;
}

function wfMsgHtml( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    $args = func_get_args();
    array_shift( $args );
    return wfMsgReplaceArgs( htmlspecialchars( wfMsgGetKey( $key ) ), $args );
}

function wfMsgWikiHtml( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    $args = func_get_args();
    array_shift( $args );
    return wfMsgReplaceArgs(
        MessageCache::singleton()->parse( wfMsgGetKey( $key ), null,
        /* can't be set to false */ true, /* interface */ true )->getText(),
        $args );
}

function wfMsgExt( $key, $options ) {
    wfDeprecated( __METHOD__, '1.21' );

    $args = func_get_args();
    array_shift( $args );
    array_shift( $args );
    $options = (array)$options;

    foreach ( $options as $arrayKey => $option ) {
        if ( !preg_match( '/^[0-9]+|language$/', $arrayKey ) ) {
            # An unknown index, neither numeric nor "language"
            wfWarn( "wfMsgExt called with incorrect parameter key $arrayKey", 1, E_USER_WARNING );
        } elseif ( preg_match( '/^[0-9]+$/', $arrayKey ) && !in_array( $option,
        array( 'parse', 'parseinline', 'escape', 'escapenoentities',
        'replaceafter', 'parsemag', 'content' ) ) ) {
            # A numeric index with unknown value
            wfWarn( "wfMsgExt called with incorrect parameter $option", 1, E_USER_WARNING );
        }
    }

    if ( in_array( 'content', $options, true ) ) {
        $forContent = true;
        $langCode = true;
        $langCodeObj = null;
    } elseif ( array_key_exists( 'language', $options ) ) {
        $forContent = false;
        $langCode = wfGetLangObj( $options['language'] );
        $langCodeObj = $langCode;
    } else {
        $forContent = false;
        $langCode = false;
        $langCodeObj = null;
    }

    $string = wfMsgGetKey( $key, /*DB*/true, $langCode, /*Transform*/false );

    if ( !in_array( 'replaceafter', $options, true ) ) {
        $string = wfMsgReplaceArgs( $string, $args );
    }

    $messageCache = MessageCache::singleton();
    $parseInline = in_array( 'parseinline', $options, true );
    if ( in_array( 'parse', $options, true ) || $parseInline ) {
        $string = $messageCache->parse( $string, null, true, !$forContent, $langCodeObj );
        if ( $string instanceof ParserOutput ) {
            $string = $string->getText();
        }

        if ( $parseInline ) {
            $string = Parser::stripOuterParagraph( $string );
        }
    } elseif ( in_array( 'parsemag', $options, true ) ) {
        $string = $messageCache->transform( $string,
                !$forContent, $langCodeObj );
    }

    if ( in_array( 'escape', $options, true ) ) {
        $string = htmlspecialchars ( $string );
    } elseif ( in_array( 'escapenoentities', $options, true ) ) {
        $string = Sanitizer::escapeHtmlAllowEntities( $string );
    }

    if ( in_array( 'replaceafter', $options, true ) ) {
        $string = wfMsgReplaceArgs( $string, $args );
    }

    return $string;
}

function wfEmptyMsg( $key ) {
    wfDeprecated( __METHOD__, '1.21' );

    return MessageCache::singleton()->get( $key, /*useDB*/true, /*content*/false ) === false;
}

function wfHostname() {
    static $host;
    if ( is_null( $host ) ) {

        # Hostname overriding
        global $wgOverrideHostname;
        if ( $wgOverrideHostname !== false ) {
            # Set static and skip any detection
            $host = $wgOverrideHostname;
            return $host;
        }

        if ( function_exists( 'posix_uname' ) ) {
            // This function not present on Windows
            $uname = posix_uname();
        } else {
            $uname = false;
        }
        if ( is_array( $uname ) && isset( $uname['nodename'] ) ) {
            $host = $uname['nodename'];
        } elseif ( getenv( 'COMPUTERNAME' ) ) {
            # Windows computer name
            $host = getenv( 'COMPUTERNAME' );
        } else {
            # This may be a virtual server.
            $host = $_SERVER['SERVER_NAME'];
        }
    }
    return $host;
}

function wfReportTime() {
    global $wgRequestTime, $wgShowHostnames;

    $responseTime = round( ( microtime( true ) - $wgRequestTime ) * 1000 );
    $reportVars = array( 'wgBackendResponseTime' => $responseTime );
    if ( $wgShowHostnames ) {
        $reportVars['wgHostname'] = wfHostname();
    }
    return Skin::makeVariablesScript( $reportVars );
}

function wfDebugBacktrace( $limit = 0 ) {
    static $disabled = null;

    if ( is_null( $disabled ) ) {
        $disabled = !function_exists( 'debug_backtrace' );
        if ( $disabled ) {
            wfDebug( "debug_backtrace() is disabled\n" );
        }
    }
    if ( $disabled ) {
        return array();
    }

    if ( $limit && version_compare( PHP_VERSION, '5.4.0', '>=' ) ) {
        return array_slice( debug_backtrace( DEBUG_BACKTRACE_PROVIDE_OBJECT, $limit + 1 ), 1 );
    } else {
        return array_slice( debug_backtrace(), 1 );
    }
}

function wfBacktrace() {
    global $wgCommandLineMode;

    if ( $wgCommandLineMode ) {
        $msg = '';
    } else {
        $msg = "<ul>\n";
    }
    $backtrace = wfDebugBacktrace();
    foreach ( $backtrace as $call ) {
        if ( isset( $call['file'] ) ) {
            $f = explode( DIRECTORY_SEPARATOR, $call['file'] );
            $file = $f[count( $f ) - 1];
        } else {
            $file = '-';
        }
        if ( isset( $call['line'] ) ) {
            $line = $call['line'];
        } else {
            $line = '-';
        }
        if ( $wgCommandLineMode ) {
            $msg .= "$file line $line calls ";
        } else {
            $msg .= '<li>' . $file . ' line ' . $line . ' calls ';
        }
        if ( !empty( $call['class'] ) ) {
            $msg .= $call['class'] . $call['type'];
        }
        $msg .= $call['function'] . '()';

        if ( $wgCommandLineMode ) {
            $msg .= "\n";
        } else {
            $msg .= "</li>\n";
        }
    }
    if ( $wgCommandLineMode ) {
        $msg .= "\n";
    } else {
        $msg .= "</ul>\n";
    }

    return $msg;
}

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 ) {
    return isset( $frame['class'] ) ?
        $frame['class'] . '::' . $frame['function'] :
        $frame['function'];
}

/* Some generic result counters, pulled out of SearchEngine */

function wfShowingResults( $offset, $limit ) {
    return wfMessage( 'showingresults' )->numParams( $limit, $offset + 1 )->parse();
}

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 blacklist some broken browsers
            $m = array();
            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 ) ) {
                    $result = false;
                    return $result;
                }
                wfDebug( "wfClientAcceptsGzip: client accepts gzip.\n" );
                $result = true;
            }
        }
    }
    return $result;
}

function wfCheckLimits( $deflimit = 50, $optionname = 'rclimit' ) {
    global $wgRequest;
    wfDeprecated( __METHOD__, '1.24' );
    return $wgRequest->getLimitOffset( $deflimit, $optionname );
}

function wfEscapeWikiText( $text ) {
    static $repl = null, $repl2 = null;
    if ( $repl === null ) {
        $repl = array(
            '"' => '&#34;', '&' => '&#38;', "'" => '&#39;', '<' => '&#60;',
            '=' => '&#61;', '>' => '&#62;', '[' => '&#91;', ']' => '&#93;',
            '{' => '&#123;', '|' => '&#124;', '}' => '&#125;', ';' => '&#59;',
            "\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;//',
        );

        // We have to catch everything "\s" matches in PCRE
        foreach ( array( 'ISBN', 'RFC', 'PMID' ) 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;";
        }

        // And handle protocols that don't use "://"
        global $wgUrlProtocols;
        $repl2 = array();
        foreach ( $wgUrlProtocols as $prot ) {
            if ( substr( $prot, -1 ) === ':' ) {
                $repl2[] = preg_quote( substr( $prot, 0, -1 ), '/' );
            }
        }
        $repl2 = $repl2 ? '/\b(' . join( '|', $repl2 ) . '):/i' : '/^(?!)/';
    }
    $text = substr( strtr( "\n$text", $repl ), 1 );
    $text = preg_replace( $repl2, '$1&#58;', $text );
    return $text;
}

function wfSetVar( &$dest, $source, $force = false ) {
    $temp = $dest;
    if ( !is_null( $source ) || $force ) {
        $dest = $source;
    }
    return $temp;
}

function wfSetBit( &$dest, $bit, $state = true ) {
    $temp = (bool)( $dest & $bit );
    if ( !is_null( $state ) ) {
        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() || !isset( $wgOut ) || !is_object( $wgOut ) ) {
        print $s;
    } else {
        $wgOut->addHTML( $s );
    }
}

function wfHttpError( $code, $label, $desc ) {
    global $wgOut;
    $wgOut->disable();
    header( "HTTP/1.0 $code $label" );
    header( "Status: $code $label" );
    $wgOut->sendCacheControl();

    header( 'Content-type: text/html; charset=utf-8' );
    print "<!doctype html>" .
        '<html><head><title>' .
        htmlspecialchars( $label ) .
        '</title></head><body><h1>' .
        htmlspecialchars( $label ) .
        '</h1><p>' .
        nl2br( htmlspecialchars( $desc ) ) .
        "</p></body></html>\n";
}

function wfResetOutputBuffers( $resetGzipEncoding = true ) {
    if ( $resetGzipEncoding ) {
        // Suppress Content-Encoding and Content-Length
        // headers from 1.10+s wfOutputHandler
        global $wgDisableOutputCompression;
        $wgDisableOutputCompression = true;
    }
    while ( $status = ob_get_status() ) {
        if ( $status['type'] == 0 /* PHP_OUTPUT_HANDLER_INTERNAL */ ) {
            // Probably from zlib.output_compression or other
            // PHP-internal setting which can't be removed.
            //
            // Give up, and hope the result doesn't break
            // output behavior.
            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 ) {
            if ( $status['name'] == 'ob_gzhandler' ) {
                // Reset the 'Content-Encoding' field set by this handler
                // so we can start fresh.
                header_remove( 'Content-Encoding' );
                break;
            }
        }
    }
}

function wfClearOutputBuffers() {
    wfResetOutputBuffers( false );
}

function wfAcceptToPrefs( $accept, $def = '*/*' ) {
    # No arg means accept anything (per HTTP spec)
    if ( !$accept ) {
        return array( $def => 1.0 );
    }

    $prefs = array();

    $parts = explode( ',', $accept );

    foreach ( $parts as $part ) {
        # @todo FIXME: Doesn't deal with params like 'text/html; level=1'
        $values = explode( ';', trim( $part ) );
        $match = array();
        if ( count( $values ) == 1 ) {
            $prefs[$values[0]] = 1.0;
        } elseif ( preg_match( '/q\s*=\s*(\d*\.\d+)/', $values[1], $match ) ) {
            $prefs[$values[0]] = floatval( $match[1] );
        }
    }

    return $prefs;
}

function mimeTypeMatch( $type, $avail ) {
    if ( array_key_exists( $type, $avail ) ) {
        return $type;
    } else {
        $parts = explode( '/', $type );
        if ( array_key_exists( $parts[0] . '/*', $avail ) ) {
            return $parts[0] . '/*';
        } elseif ( array_key_exists( '*/*', $avail ) ) {
            return '*/*';
        } else {
            return null;
        }
    }
}

function wfNegotiateType( $cprefs, $sprefs ) {
    $combine = array();

    foreach ( array_keys( $sprefs ) as $type ) {
        $parts = explode( '/', $type );
        if ( $parts[1] != '*' ) {
            $ckey = mimeTypeMatch( $type, $cprefs );
            if ( $ckey ) {
                $combine[$type] = $sprefs[$type] * $cprefs[$ckey];
            }
        }
    }

    foreach ( array_keys( $cprefs ) as $type ) {
        $parts = explode( '/', $type );
        if ( $parts[1] != '*' && !array_key_exists( $type, $sprefs ) ) {
            $skey = mimeTypeMatch( $type, $sprefs );
            if ( $skey ) {
                $combine[$type] = $sprefs[$skey] * $cprefs[$type];
            }
        }
    }

    $bestq = 0;
    $besttype = null;

    foreach ( array_keys( $combine ) as $type ) {
        if ( $combine[$type] > $bestq ) {
            $besttype = $type;
            $bestq = $combine[$type];
        }
    }

    return $besttype;
}

function wfSuppressWarnings( $end = false ) {
    static $suppressCount = 0;
    static $originalLevel = false;

    if ( $end ) {
        if ( $suppressCount ) {
            --$suppressCount;
            if ( !$suppressCount ) {
                error_reporting( $originalLevel );
            }
        }
    } else {
        if ( !$suppressCount ) {
            $originalLevel = error_reporting( E_ALL & ~(
                E_WARNING |
                E_NOTICE |
                E_USER_WARNING |
                E_USER_NOTICE |
                E_DEPRECATED |
                E_USER_DEPRECATED |
                E_STRICT
            ) );
        }
        ++$suppressCount;
    }
}

function wfRestoreWarnings() {
    wfSuppressWarnings( true );
}

# Autodetect, convert and provide timestamps of various types

define( 'TS_UNIX', 0 );

define( 'TS_MW', 1 );

define( 'TS_DB', 2 );

define( 'TS_RFC2822', 3 );

define( 'TS_ISO_8601', 4 );

define( 'TS_EXIF', 5 );

define( 'TS_ORACLE', 6 );

define( 'TS_POSTGRES', 7 );

define( 'TS_ISO_8601_BASIC', 9 );

function wfTimestamp( $outputtype = TS_UNIX, $ts = 0 ) {
    try {
        $timestamp = new MWTimestamp( $ts );
        return $timestamp->getTimestamp( $outputtype );
    } catch ( TimestampException $e ) {
        wfDebug( "wfTimestamp() fed bogus time value: TYPE=$outputtype; VALUE=$ts\n" );
        return false;
    }
}

function wfTimestampOrNull( $outputtype = TS_UNIX, $ts = null ) {
    if ( is_null( $ts ) ) {
        return null;
    } else {
        return wfTimestamp( $outputtype, $ts );
    }
}

function wfTimestampNow() {
    # return NOW
    return wfTimestamp( TS_MW, time() );
}

function wfIsWindows() {
    static $isWindows = null;
    if ( $isWindows === null ) {
        $isWindows = substr( php_uname(), 0, 7 ) == 'Windows';
    }
    return $isWindows;
}

function wfIsHHVM() {
    return defined( 'HHVM_VERSION' );
}

function swap( &$x, &$y ) {
    wfDeprecated( __FUNCTION__, '1.24' );
    $z = $x;
    $x = $y;
    $y = $z;
}

function wfTempDir() {
    global $wgTmpDirectory;

    if ( $wgTmpDirectory !== false ) {
        return $wgTmpDirectory;
    }

    $tmpDir = array_map( "getenv", array( 'TMPDIR', 'TMP', 'TEMP' ) );

    foreach ( $tmpDir as $tmp ) {
        if ( $tmp && file_exists( $tmp ) && is_dir( $tmp ) && is_writable( $tmp ) ) {
            return $tmp;
        }
    }
    return sys_get_temp_dir();
}

function wfMkdirParents( $dir, $mode = null, $caller = null ) {
    global $wgDirectoryMode;

    if ( FileBackend::isStoragePath( $dir ) ) { // sanity
        throw new MWException( __FUNCTION__ . " given storage path '$dir'." );
    }

    if ( !is_null( $caller ) ) {
        wfDebug( "$caller: called wfMkdirParents($dir)\n" );
    }

    if ( strval( $dir ) === '' || ( file_exists( $dir ) && is_dir( $dir ) ) ) {
        return true;
    }

    $dir = str_replace( array( '\\', '/' ), DIRECTORY_SEPARATOR, $dir );

    if ( is_null( $mode ) ) {
        $mode = $wgDirectoryMode;
    }

    // Turn off the normal warning, we're doing our own below
    wfSuppressWarnings();
    $ok = mkdir( $dir, $mode, true ); // PHP5 <3
    wfRestoreWarnings();

    if ( !$ok ) {
        //directory may have been created on another request since we last checked
        if ( is_dir( $dir ) ) {
            return true;
        }

        // PHP doesn't report the path in its warning message, so add our own to aid in diagnosis.
        wfLogWarning( sprintf( "failed to mkdir \"%s\" mode 0%o", $dir, $mode ) );
    }
    return $ok;
}

function wfRecursiveRemoveDir( $dir ) {
    wfDebug( __FUNCTION__ . "( $dir )\n" );
    // taken from http://de3.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 );
                }
            }
        }
        reset( $objects );
        rmdir( $dir );
    }
}

function wfPercent( $nr, $acc = 2, $round = true ) {
    $ret = sprintf( "%.${acc}f", $nr );
    return $round ? round( $ret, $acc ) . '%' : "$ret%";
}

function wfIniGetBool( $setting ) {
    $val = strtolower( ini_get( $setting ) );
    // '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( /*...*/ ) {
    wfInitShellLocale();

    $args = func_get_args();
    $first = true;
    $retVal = '';
    foreach ( $args as $arg ) {
        if ( !$first ) {
            $retVal .= ' ';
        } else {
            $first = false;
        }

        if ( wfIsWindows() ) {
            // Escaping for an MSVC-style command line parser and CMD.EXE
            // @codingStandardsIgnoreStart For long URLs
            // Refs:
            //  * http://web.archive.org/web/20020708081031/http://mailman.lyra.org/pipermail/scite-interest/2002-March/000436.html
            //  * http://technet.microsoft.com/en-us/library/cc723564.aspx
            //  * Bug #13518
            //  * CR r63214
            // Double the backslashes before any double quotes. Escape the double quotes.
            // @codingStandardsIgnoreEnd
            $tokens = preg_split( '/(\\\\*")/', $arg, -1, PREG_SPLIT_DELIM_CAPTURE );
            $arg = '';
            $iteration = 0;
            foreach ( $tokens as $token ) {
                if ( $iteration % 2 == 1 ) {
                    // Delimiter, a double quote preceded by zero or more slashes
                    $arg .= str_replace( '\\', '\\\\', substr( $token, 0, -1 ) ) . '\\"';
                } elseif ( $iteration % 4 == 2 ) {
                    // ^ in $token will be outside quotes, need to be escaped
                    $arg .= str_replace( '^', '^^', $token );
                } else { // $iteration % 4 == 0
                    // ^ in $token will appear inside double quotes, so leave as is
                    $arg .= $token;
                }
                $iteration++;
            }
            // Double the backslashes before the end of the string, because
            // we will soon add a quote
            $m = array();
            if ( preg_match( '/^(.*?)(\\\\+)$/', $arg, $m ) ) {
                $arg = $m[1] . str_replace( '\\', '\\\\', $m[2] );
            }

            // Add surrounding quotes
            $retVal .= '"' . $arg . '"';
        } else {
            $retVal .= escapeshellarg( $arg );
        }
    }
    return $retVal;
}

function wfShellExecDisabled() {
    static $disabled = null;
    if ( is_null( $disabled ) ) {
        if ( wfIniGetBool( 'safe_mode' ) ) {
            wfDebug( "wfShellExec can't run in safe_mode, PHP's exec functions are too broken.\n" );
            $disabled = 'safemode';
        } elseif ( !function_exists( 'proc_open' ) ) {
            wfDebug( "proc_open() is disabled\n" );
            $disabled = 'disabled';
        } else {
            $disabled = false;
        }
    }
    return $disabled;
}

function wfShellExec( $cmd, &$retval = null, $environ = array(),
    $limits = array(), $options = array()
) {
    global $IP, $wgMaxShellMemory, $wgMaxShellFileSize, $wgMaxShellTime,
        $wgMaxShellWallClockTime, $wgShellCgroup;

    $disabled = wfShellExecDisabled();
    if ( $disabled ) {
        $retval = 1;
        return $disabled == 'safemode' ?
            'Unable to run external programs in safe mode.' :
            'Unable to run external programs, proc_open() is disabled.';
    }

    $includeStderr = isset( $options['duplicateStderr'] ) && $options['duplicateStderr'];

    wfInitShellLocale();

    $envcmd = '';
    foreach ( $environ as $k => $v ) {
        if ( wfIsWindows() ) {
            /* Surrounding a set in quotes (method used by wfEscapeShellArg) makes the quotes themselves
             * appear in the environment variable, so we must use carat escaping as documented in
             * http://technet.microsoft.com/en-us/library/cc723564.aspx
             * Note however that the quote isn't listed there, but is needed, and the parentheses
             * are listed there but doesn't appear to need it.
             */
            $envcmd .= "set $k=" . preg_replace( '/([&|()<>^"])/', '^\\1', $v ) . '&& ';
        } else {
            /* Assume this is a POSIX shell, thus required to accept variable assignments before the command
             * http://www.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_09_01
             */
            $envcmd .= "$k=" . escapeshellarg( $v ) . ' ';
        }
    }
    if ( is_array( $cmd ) ) {
        // Command line may be given as an array, escape each value and glue them together with a space
        $cmdVals = array();
        foreach ( $cmd as $val ) {
            $cmdVals[] = wfEscapeShellArg( $val );
        }
        $cmd = implode( ' ', $cmdVals );
    }

    $cmd = $envcmd . $cmd;

    $useLogPipe = false;
    if ( is_executable( '/bin/bash' ) ) {
        $time = intval ( isset( $limits['time'] ) ? $limits['time'] : $wgMaxShellTime );
        if ( isset( $limits['walltime'] ) ) {
            $wallTime = intval( $limits['walltime'] );
        } elseif ( isset( $limits['time'] ) ) {
            $wallTime = $time;
        } else {
            $wallTime = intval( $wgMaxShellWallClockTime );
        }
        $mem = intval ( isset( $limits['memory'] ) ? $limits['memory'] : $wgMaxShellMemory );
        $filesize = intval ( isset( $limits['filesize'] ) ? $limits['filesize'] : $wgMaxShellFileSize );

        if ( $time > 0 || $mem > 0 || $filesize > 0 || $wallTime > 0 ) {
            $cmd = '/bin/bash ' . escapeshellarg( "$IP/includes/limit.sh" ) . ' ' .
                escapeshellarg( $cmd ) . ' ' .
                escapeshellarg(
                    "MW_INCLUDE_STDERR=" . ( $includeStderr ? '1' : '' ) . ';' .
                    "MW_CPU_LIMIT=$time; " .
                    'MW_CGROUP=' . escapeshellarg( $wgShellCgroup ) . '; ' .
                    "MW_MEM_LIMIT=$mem; " .
                    "MW_FILE_SIZE_LIMIT=$filesize; " .
                    "MW_WALL_CLOCK_LIMIT=$wallTime; " .
                    "MW_USE_LOG_PIPE=yes"
                );
            $useLogPipe = true;
        } elseif ( $includeStderr ) {
            $cmd .= ' 2>&1';
        }
    } elseif ( $includeStderr ) {
        $cmd .= ' 2>&1';
    }
    wfDebug( "wfShellExec: $cmd\n" );

    $desc = array(
        0 => array( 'file', 'php://stdin', 'r' ),
        1 => array( 'pipe', 'w' ),
        2 => array( 'file', 'php://stderr', 'w' ) );
    if ( $useLogPipe ) {
        $desc[3] = array( 'pipe', 'w' );
    }
    $pipes = null;
    $proc = proc_open( $cmd, $desc, $pipes );
    if ( !$proc ) {
        wfDebugLog( 'exec', "proc_open() failed: $cmd" );
        $retval = -1;
        return '';
    }
    $outBuffer = $logBuffer = '';
    $emptyArray = array();
    $status = false;
    $logMsg = false;

    // According to the documentation, it is possible for stream_select()
    // to fail due to EINTR. I haven't managed to induce this in testing
    // despite sending various signals. If it did happen, the error
    // message would take the form:
    //
    // stream_select(): unable to select [4]: Interrupted system call (max_fd=5)
    //
    // where [4] is the value of the macro EINTR and "Interrupted system
    // call" is string which according to the Linux manual is "possibly"
    // localised according to LC_MESSAGES.
    $eintr = defined( 'SOCKET_EINTR' ) ? SOCKET_EINTR : 4;
    $eintrMessage = "stream_select(): unable to select [$eintr]";

    // Build a table mapping resource IDs to pipe FDs to work around a
    // PHP 5.3 issue in which stream_select() does not preserve array keys
    // <https://bugs.php.net/bug.php?id=53427>.
    $fds = array();
    foreach ( $pipes as $fd => $pipe ) {
        $fds[(int)$pipe] = $fd;
    }

    $running = true;
    $timeout = null;
    $numReadyPipes = 0;

    while ( $running === true || $numReadyPipes !== 0 ) {
        if ( $running ) {
            $status = proc_get_status( $proc );
            // If the process has terminated, switch to nonblocking selects
            // for getting any data still waiting to be read.
            if ( !$status['running'] ) {
                $running = false;
                $timeout = 0;
            }
        }

        $readyPipes = $pipes;

        // Clear last error
        // @codingStandardsIgnoreStart Generic.PHP.NoSilencedErrors.Discouraged
        @trigger_error( '' );
        $numReadyPipes = @stream_select( $readyPipes, $emptyArray, $emptyArray, $timeout );
        if ( $numReadyPipes === false ) {
            // @codingStandardsIgnoreEnd
            $error = error_get_last();
            if ( strncmp( $error['message'], $eintrMessage, strlen( $eintrMessage ) ) == 0 ) {
                continue;
            } else {
                trigger_error( $error['message'], E_USER_WARNING );
                $logMsg = $error['message'];
                break;
            }
        }
        foreach ( $readyPipes as $pipe ) {
            $block = fread( $pipe, 65536 );
            $fd = $fds[(int)$pipe];
            if ( $block === '' ) {
                // End of file
                fclose( $pipes[$fd] );
                unset( $pipes[$fd] );
                if ( !$pipes ) {
                    break 2;
                }
            } elseif ( $block === false ) {
                // Read error
                $logMsg = "Error reading from pipe";
                break 2;
            } elseif ( $fd == 1 ) {
                // From stdout
                $outBuffer .= $block;
            } elseif ( $fd == 3 ) {
                // From log FD
                $logBuffer .= $block;
                if ( strpos( $block, "\n" ) !== false ) {
                    $lines = explode( "\n", $logBuffer );
                    $logBuffer = array_pop( $lines );
                    foreach ( $lines as $line ) {
                        wfDebugLog( 'exec', $line );
                    }
                }
            }
        }
    }

    foreach ( $pipes as $pipe ) {
        fclose( $pipe );
    }

    // Use the status previously collected if possible, since proc_get_status()
    // just calls waitpid() which will not return anything useful the second time.
    if ( $running ) {
        $status = proc_get_status( $proc );
    }

    if ( $logMsg !== false ) {
        // Read/select error
        $retval = -1;
        proc_close( $proc );
    } elseif ( $status['signaled'] ) {
        $logMsg = "Exited with signal {$status['termsig']}";
        $retval = 128 + $status['termsig'];
        proc_close( $proc );
    } else {
        if ( $status['running'] ) {
            $retval = proc_close( $proc );
        } else {
            $retval = $status['exitcode'];
            proc_close( $proc );
        }
        if ( $retval == 127 ) {
            $logMsg = "Possibly missing executable file";
        } elseif ( $retval >= 129 && $retval <= 192 ) {
            $logMsg = "Probably exited with signal " . ( $retval - 128 );
        }
    }

    if ( $logMsg !== false ) {
        wfDebugLog( 'exec', "$logMsg: $cmd" );
    }

    return $outBuffer;
}

function wfShellExecWithStderr( $cmd, &$retval = null, $environ = array(), $limits = array() ) {
    return wfShellExec( $cmd, $retval, $environ, $limits, array( 'duplicateStderr' => true ) );
}

function wfInitShellLocale() {
    static $done = false;
    if ( $done ) {
        return;
    }
    $done = true;
    global $wgShellLocale;
    if ( !wfIniGetBool( 'safe_mode' ) ) {
        putenv( "LC_CTYPE=$wgShellLocale" );
        setlocale( LC_CTYPE, $wgShellLocale );
    }
}

function wfShellMaintenanceCmd( $script, array $parameters = array(), array $options = array() ) {
    return wfShellWikiCmd( $script, $parameters, $options );
}

function wfShellWikiCmd( $script, array $parameters = array(), array $options = array() ) {
    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.
    wfRunHooks( 'wfShellWikiCmd', array( &$script, &$parameters, &$options ) );
    $cmd = isset( $options['php'] ) ? array( $options['php'] ) : array( $wgPhpCli );
    if ( isset( $options['wrapper'] ) ) {
        $cmd[] = $options['wrapper'];
    }
    $cmd[] = $script;
    // Escape each parameter for shell
    return implode( " ", array_map( 'wfEscapeShellArg', array_merge( $cmd, $parameters ) ) );
}

function wfMerge( $old, $mine, $yours, &$result ) {
    global $wgDiff3;

    # This check may also protect against code injection in
    # case of broken installations.
    wfSuppressWarnings();
    $haveDiff3 = $wgDiff3 && file_exists( $wgDiff3 );
    wfRestoreWarnings();

    if ( !$haveDiff3 ) {
        wfDebug( "diff3 not found\n" );
        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 = wfEscapeShellArg( $wgDiff3 ) . ' -a --overlap-only ' .
        wfEscapeShellArg( $mytextName ) . ' ' .
        wfEscapeShellArg( $oldtextName ) . ' ' .
        wfEscapeShellArg( $yourtextName );
    $handle = popen( $cmd, 'r' );

    if ( fgets( $handle, 1024 ) ) {
        $conflict = true;
    } else {
        $conflict = false;
    }
    pclose( $handle );

    # Merge differences
    $cmd = wfEscapeShellArg( $wgDiff3 ) . ' -a -e --merge ' .
        wfEscapeShellArg( $mytextName, $oldtextName, $yourtextName );
    $handle = popen( $cmd, 'r' );
    $result = '';
    do {
        $data = fread( $handle, 8192 );
        if ( strlen( $data ) == 0 ) {
            break;
        }
        $result .= $data;
    } while ( true );
    pclose( $handle );
    unlink( $mytextName );
    unlink( $oldtextName );
    unlink( $yourtextName );

    if ( $result === '' && $old !== '' && !$conflict ) {
        wfDebug( "Unexpected null result from diff3. Command: $cmd\n" );
        $conflict = true;
    }
    return !$conflict;
}

function wfDiff( $before, $after, $params = '-u' ) {
    if ( $before == $after ) {
        return '';
    }

    global $wgDiff;
    wfSuppressWarnings();
    $haveDiff = $wgDiff && file_exists( $wgDiff );
    wfRestoreWarnings();

    # This check may also protect against code injection in
    # case of broken installations.
    if ( !$haveDiff ) {
        wfDebug( "diff executable not found\n" );
        $diffs = new Diff( explode( "\n", $before ), explode( "\n", $after ) );
        $format = new UnifiedDiffFormatter();
        return $format->format( $diffs );
    }

    # Make temporary files
    $td = wfTempDir();
    $oldtextFile = fopen( $oldtextName = tempnam( $td, 'merge-old-' ), 'w' );
    $newtextFile = fopen( $newtextName = tempnam( $td, 'merge-your-' ), 'w' );

    fwrite( $oldtextFile, $before );
    fclose( $oldtextFile );
    fwrite( $newtextFile, $after );
    fclose( $newtextFile );

    // Get the diff of the two files
    $cmd = "$wgDiff " . $params . ' ' . wfEscapeShellArg( $oldtextName, $newtextName );

    $h = popen( $cmd, 'r' );

    $diff = '';

    do {
        $data = fread( $h, 8192 );
        if ( strlen( $data ) == 0 ) {
            break;
        }
        $diff .= $data;
    } while ( true );

    // Clean up
    pclose( $h );
    unlink( $oldtextName );
    unlink( $newtextName );

    // Kill the --- and +++ lines. They're not useful.
    $diff_lines = explode( "\n", $diff );
    if ( isset( $diff_lines[0] ) && strpos( $diff_lines[0], '---' ) === 0 ) {
        unset( $diff_lines[0] );
    }
    if ( isset( $diff_lines[1] ) && strpos( $diff_lines[1], '+++' ) === 0 ) {
        unset( $diff_lines[1] );
    }

    $diff = implode( "\n", $diff_lines );

    return $diff;
}

function wfUsePHP( $req_ver ) {
    $php_ver = PHP_VERSION;

    if ( version_compare( $php_ver, (string)$req_ver, '<' ) ) {
        throw new MWException( "PHP $req_ver required--this is only $php_ver" );
    }
}

function wfUseMW( $req_ver ) {
    global $wgVersion;

    if ( version_compare( $wgVersion, (string)$req_ver, '<' ) ) {
        throw new MWException( "MediaWiki $req_ver required--this is only $wgVersion" );
    }
}

function wfBaseName( $path, $suffix = '' ) {
    if ( $suffix == '' ) {
        $encSuffix = '';
    } else {
        $encSuffix = '(?:' . preg_quote( $suffix, '#' ) . ')?';
    }

    $matches = array();
    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 );
    }

    array_push( $pieces, wfBaseName( $path ) );

    return implode( DIRECTORY_SEPARATOR, $pieces );
}

function wfBaseConvert( $input, $sourceBase, $destBase, $pad = 1,
    $lowercase = true, $engine = 'auto'
) {
    $input = (string)$input;
    if (
        $sourceBase < 2 ||
        $sourceBase > 36 ||
        $destBase < 2 ||
        $destBase > 36 ||
        $sourceBase != (int)$sourceBase ||
        $destBase != (int)$destBase ||
        $pad != (int)$pad ||
        !preg_match(
            "/^[" . substr( '0123456789abcdefghijklmnopqrstuvwxyz', 0, $sourceBase ) . "]+$/i",
            $input
        )
    ) {
        return false;
    }

    static $baseChars = array(
        10 => 'a', 11 => 'b', 12 => 'c', 13 => 'd', 14 => 'e', 15 => 'f',
        16 => 'g', 17 => 'h', 18 => 'i', 19 => 'j', 20 => 'k', 21 => 'l',
        22 => 'm', 23 => 'n', 24 => 'o', 25 => 'p', 26 => 'q', 27 => 'r',
        28 => 's', 29 => 't', 30 => 'u', 31 => 'v', 32 => 'w', 33 => 'x',
        34 => 'y', 35 => 'z',

        '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5,
        '6' => 6, '7' => 7, '8' => 8, '9' => 9, 'a' => 10, 'b' => 11,
        'c' => 12, 'd' => 13, 'e' => 14, 'f' => 15, 'g' => 16, 'h' => 17,
        'i' => 18, 'j' => 19, 'k' => 20, 'l' => 21, 'm' => 22, 'n' => 23,
        'o' => 24, 'p' => 25, 'q' => 26, 'r' => 27, 's' => 28, 't' => 29,
        'u' => 30, 'v' => 31, 'w' => 32, 'x' => 33, 'y' => 34, 'z' => 35
    );

    if ( extension_loaded( 'gmp' ) && ( $engine == 'auto' || $engine == 'gmp' ) ) {
        // Removing leading zeros works around broken base detection code in
        // some PHP versions (see <https://bugs.php.net/bug.php?id=50175> and
        // <https://bugs.php.net/bug.php?id=55398>).
        $result = gmp_strval( gmp_init( ltrim( $input, '0' ), $sourceBase ), $destBase );
    } elseif ( extension_loaded( 'bcmath' ) && ( $engine == 'auto' || $engine == 'bcmath' ) ) {
        $decimal = '0';
        foreach ( str_split( strtolower( $input ) ) as $char ) {
            $decimal = bcmul( $decimal, $sourceBase );
            $decimal = bcadd( $decimal, $baseChars[$char] );
        }

        // @codingStandardsIgnoreStart Generic.CodeAnalysis.ForLoopWithTestFunctionCall.NotAllowed
        for ( $result = ''; bccomp( $decimal, 0 ); $decimal = bcdiv( $decimal, $destBase, 0 ) ) {
            $result .= $baseChars[bcmod( $decimal, $destBase )];
        }
        // @codingStandardsIgnoreEnd

        $result = strrev( $result );
    } else {
        $inDigits = array();
        foreach ( str_split( strtolower( $input ) ) as $char ) {
            $inDigits[] = $baseChars[$char];
        }

        // Iterate over the input, modulo-ing out an output digit
        // at a time until input is gone.
        $result = '';
        while ( $inDigits ) {
            $work = 0;
            $workDigits = array();

            // Long division...
            foreach ( $inDigits as $digit ) {
                $work *= $sourceBase;
                $work += $digit;

                if ( $workDigits || $work >= $destBase ) {
                    $workDigits[] = (int)( $work / $destBase );
                }
                $work %= $destBase;
            }

            // All that division leaves us with a remainder,
            // which is conveniently our next output digit.
            $result .= $baseChars[$work];

            // And we continue!
            $inDigits = $workDigits;
        }

        $result = strrev( $result );
    }

    if ( !$lowercase ) {
        $result = strtoupper( $result );
    }

    return str_pad( $result, $pad, '0', STR_PAD_LEFT );
}

function wfCheckEntropy() {
    return (
            ( wfIsWindows() && version_compare( PHP_VERSION, '5.3.3', '>=' ) )
            || ini_get( 'session.entropy_file' )
        )
        && intval( ini_get( 'session.entropy_length' ) ) >= 32;
}

function wfFixSessionID() {
    // If the cookie or session id is already set we already have a session and should abort
    if ( isset( $_COOKIE[session_name()] ) || session_id() ) {
        return;
    }

    // PHP's built-in session entropy is enabled if:
    // - entropy_file is set or you're on Windows with php 5.3.3+
    // - AND entropy_length is > 0
    // We treat it as disabled if it doesn't have an entropy length of at least 32
    $entropyEnabled = wfCheckEntropy();

    // If built-in entropy is not enabled or not sufficient override PHP's
    // built in session id generation code
    if ( !$entropyEnabled ) {
        wfDebug( __METHOD__ . ": PHP's built in entropy is disabled or not sufficient, " .
            "overriding session id generation using our cryptrand source.\n" );
        session_id( MWCryptRand::generateHex( 32 ) );
    }
}

function wfResetSessionID() {
    global $wgCookieSecure;
    $oldSessionId = session_id();
    $cookieParams = session_get_cookie_params();
    if ( wfCheckEntropy() && $wgCookieSecure == $cookieParams['secure'] ) {
        session_regenerate_id( false );
    } else {
        $tmp = $_SESSION;
        session_destroy();
        wfSetupSession( MWCryptRand::generateHex( 32 ) );
        $_SESSION = $tmp;
    }
    $newSessionId = session_id();
    wfRunHooks( 'ResetSessionID', array( $oldSessionId, $newSessionId ) );
}

function wfSetupSession( $sessionId = false ) {
    global $wgSessionsInMemcached, $wgSessionsInObjectCache, $wgCookiePath, $wgCookieDomain,
            $wgCookieSecure, $wgCookieHttpOnly, $wgSessionHandler;
    if ( $wgSessionsInObjectCache || $wgSessionsInMemcached ) {
        ObjectCacheSessionHandler::install();
    } elseif ( $wgSessionHandler && $wgSessionHandler != ini_get( 'session.save_handler' ) ) {
        # Only set this if $wgSessionHandler isn't null and session.save_handler
        # hasn't already been set to the desired value (that causes errors)
        ini_set( 'session.save_handler', $wgSessionHandler );
    }
    session_set_cookie_params(
        0, $wgCookiePath, $wgCookieDomain, $wgCookieSecure, $wgCookieHttpOnly );
    session_cache_limiter( 'private, must-revalidate' );
    if ( $sessionId ) {
        session_id( $sessionId );
    } else {
        wfFixSessionID();
    }
    wfSuppressWarnings();
    session_start();
    wfRestoreWarnings();
}

function wfGetPrecompiledData( $name ) {
    global $IP;

    $file = "$IP/serialized/$name";
    if ( file_exists( $file ) ) {
        $blob = file_get_contents( $file );
        if ( $blob ) {
            return unserialize( $blob );
        }
    }
    return false;
}

function wfMemcKey( /*...*/ ) {
    global $wgCachePrefix;
    $prefix = $wgCachePrefix === false ? wfWikiID() : $wgCachePrefix;
    $args = func_get_args();
    $key = $prefix . ':' . implode( ':', $args );
    $key = str_replace( ' ', '_', $key );
    return $key;
}

function wfForeignMemcKey( $db, $prefix /*...*/ ) {
    $args = array_slice( func_get_args(), 2 );
    if ( $prefix ) {
        $key = "$db-$prefix:" . implode( ':', $args );
    } else {
        $key = $db . ':' . implode( ':', $args );
    }
    return str_replace( ' ', '_', $key );
}

function wfWikiID() {
    global $wgDBprefix, $wgDBname;
    if ( $wgDBprefix ) {
        return "$wgDBname-$wgDBprefix";
    } else {
        return $wgDBname;
    }
}

function wfSplitWikiID( $wiki ) {
    $bits = explode( '-', $wiki, 2 );
    if ( count( $bits ) < 2 ) {
        $bits[] = '';
    }
    return $bits;
}

function &wfGetDB( $db, $groups = array(), $wiki = false ) {
    return wfGetLB( $wiki )->getConnection( $db, $groups, $wiki );
}

function wfGetLB( $wiki = false ) {
    return wfGetLBFactory()->getMainLB( $wiki );
}

function &wfGetLBFactory() {
    return LBFactory::singleton();
}

function wfFindFile( $title, $options = array() ) {
    return RepoGroup::singleton()->findFile( $title, $options );
}

function wfLocalFile( $title ) {
    return RepoGroup::singleton()->getLocalRepo()->newFile( $title );
}

function wfQueriesMustScale() {
    global $wgMiserMode;
    return $wgMiserMode
        || ( SiteStats::pages() > 100000
        && SiteStats::edits() > 1000000
        && SiteStats::users() > 10000 );
}

function wfScript( $script = 'index' ) {
    global $wgScriptPath, $wgScriptExtension, $wgScript, $wgLoadScript;
    if ( $script === 'index' ) {
        return $wgScript;
    } elseif ( $script === 'load' ) {
        return $wgLoadScript;
    } else {
        return "{$wgScriptPath}/{$script}{$wgScriptExtension}";
    }
}

function wfGetScriptUrl() {
    if ( isset( $_SERVER['SCRIPT_NAME'] ) ) {
        #
        # as it was called, minus the query string.
        #
        # Some sites use Apache rewrite rules to handle subdomains,
        # and have PHP set up in a weird way that causes PHP_SELF
        # to contain the rewritten URL instead of the one that the
        # outside world sees.
        #
        # If in this mode, use SCRIPT_URL instead, which mod_rewrite
        # provides containing the "before" URL.
        return $_SERVER['SCRIPT_NAME'];
    } else {
        return $_SERVER['URL'];
    }
}

function wfBoolToStr( $value ) {
    return $value ? 'true' : 'false';
}

function wfGetNull() {
    return wfIsWindows() ? 'NUL' : '/dev/null';
}

function wfWaitForSlaves( $ifWritesSince = false, $wiki = false, $cluster = false ) {
    // B/C: first argument used to be "max seconds of lag"; ignore such values
    $ifWritesSince = ( $ifWritesSince > 1e9 ) ? $ifWritesSince : false;

    if ( $cluster !== false ) {
        $lb = wfGetLBFactory()->getExternalLB( $cluster );
    } else {
        $lb = wfGetLB( $wiki );
    }

    // bug 27975 - Don't try to wait for slaves if there are none
    // Prevents permission error when getting master position
    if ( $lb->getServerCount() > 1 ) {
        if ( $ifWritesSince && !$lb->hasMasterConnection() ) {
            return true; // assume no writes done
        }
        $dbw = $lb->getConnection( DB_MASTER, array(), $wiki );
        if ( $ifWritesSince && $dbw->lastDoneWrites() < $ifWritesSince ) {
            return true; // no writes since the last wait
        }
        $pos = $dbw->getMasterPos();
        // The DBMS may not support getMasterPos() or the whole
        // load balancer might be fake (e.g. $wgAllDBsAreLocalhost).
        if ( $pos !== false ) {
            return $lb->waitForAll( $pos, PHP_SAPI === 'cli' ? 86400 : null );
        }
    }

    return true;
}

function wfCountDown( $seconds ) {
    for ( $i = $seconds; $i >= 0; $i-- ) {
        if ( $i != $seconds ) {
            echo str_repeat( "\x08", strlen( $i + 1 ) );
        }
        echo $i;
        flush();
        if ( $i ) {
            sleep( 1 );
        }
    }
    echo "\n";
}

function wfStripIllegalFilenameChars( $name ) {
    global $wgIllegalFileChars;
    $illegalFileChars = $wgIllegalFileChars ? "|[" . $wgIllegalFileChars . "]" : '';
    $name = wfBaseName( $name );
    $name = preg_replace(
        "/[^" . Title::legalChars() . "]" . $illegalFileChars . "/",
        '-',
        $name
    );
    return $name;
}

function wfMemoryLimit() {
    global $wgMemoryLimit;
    $memlimit = wfShorthandToInteger( ini_get( 'memory_limit' ) );
    if ( $memlimit != -1 ) {
        $conflimit = wfShorthandToInteger( $wgMemoryLimit );
        if ( $conflimit == -1 ) {
            wfDebug( "Removing PHP's memory limit\n" );
            wfSuppressWarnings();
            ini_set( 'memory_limit', $conflimit );
            wfRestoreWarnings();
            return $conflimit;
        } elseif ( $conflimit > $memlimit ) {
            wfDebug( "Raising PHP's memory limit to $conflimit bytes\n" );
            wfSuppressWarnings();
            ini_set( 'memory_limit', $conflimit );
            wfRestoreWarnings();
            return $conflimit;
        }
    }
    return $memlimit;
}

function wfShorthandToInteger( $string = '' ) {
    $string = trim( $string );
    if ( $string === '' ) {
        return -1;
    }
    $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 wfBCP47( $code ) {
    $codeSegment = explode( '-', $code );
    $codeBCP = array();
    foreach ( $codeSegment as $segNo => $seg ) {
        // when previous segment is x, it is a private segment and should be lc
        if ( $segNo > 0 && strtolower( $codeSegment[( $segNo - 1 )] ) == 'x' ) {
            $codeBCP[$segNo] = strtolower( $seg );
        // ISO 3166 country code
        } elseif ( ( strlen( $seg ) == 2 ) && ( $segNo > 0 ) ) {
            $codeBCP[$segNo] = strtoupper( $seg );
        // ISO 15924 script code
        } elseif ( ( strlen( $seg ) == 4 ) && ( $segNo > 0 ) ) {
            $codeBCP[$segNo] = ucfirst( strtolower( $seg ) );
        // Use lowercase for other cases
        } else {
            $codeBCP[$segNo] = strtolower( $seg );
        }
    }
    $langCode = implode( '-', $codeBCP );
    return $langCode;
}

function wfGetCache( $inputType ) {
    return ObjectCache::getInstance( $inputType );
}

function wfGetMainCache() {
    global $wgMainCacheType;
    return ObjectCache::getInstance( $wgMainCacheType );
}

function wfGetMessageCacheStorage() {
    global $wgMessageCacheType;
    return ObjectCache::getInstance( $wgMessageCacheType );
}

function wfGetParserCacheStorage() {
    global $wgParserCacheType;
    return ObjectCache::getInstance( $wgParserCacheType );
}

function wfGetLangConverterCacheStorage() {
    global $wgLanguageConverterCacheType;
    return ObjectCache::getInstance( $wgLanguageConverterCacheType );
}

function wfRunHooks( $event, array $args = array(), $deprecatedVersion = null ) {
    return Hooks::run( $event, $args, $deprecatedVersion );
}

function wfUnpack( $format, $data, $length = false ) {
    if ( $length !== false ) {
        $realLen = strlen( $data );
        if ( $realLen < $length ) {
            throw new MWException( "Tried to use wfUnpack on a "
                . "string of length $realLen, but needed one "
                . "of at least length $length."
            );
        }
    }

    wfSuppressWarnings();
    $result = unpack( $format, $data );
    wfRestoreWarnings();

    if ( $result === false ) {
        // If it cannot extract the packed data.
        throw new MWException( "unpack could not unpack binary data" );
    }
    return $result;
}

function wfIsBadImage( $name, $contextTitle = false, $blacklist = null ) {
    static $badImageCache = null; // based on bad_image_list msg
    wfProfileIn( __METHOD__ );

    # Handle redirects
    $redirectTitle = RepoGroup::singleton()->checkRedirect( Title::makeTitle( NS_FILE, $name ) );
    if ( $redirectTitle ) {
        $name = $redirectTitle->getDBkey();
    }

    # Run the extension hook
    $bad = false;
    if ( !wfRunHooks( 'BadImage', array( $name, &$bad ) ) ) {
        wfProfileOut( __METHOD__ );
        return $bad;
    }

    $cacheable = ( $blacklist === null );
    if ( $cacheable && $badImageCache !== null ) {
        $badImages = $badImageCache;
    } else { // cache miss
        if ( $blacklist === null ) {
            $blacklist = wfMessage( 'bad_image_list' )->inContentLanguage()->plain(); // site list
        }
        # Build the list now
        $badImages = array();
        $lines = explode( "\n", $blacklist );
        foreach ( $lines as $line ) {
            # List items only
            if ( substr( $line, 0, 1 ) !== '*' ) {
                continue;
            }

            # Find all links
            $m = array();
            if ( !preg_match_all( '/\[\[:?(.*?)\]\]/', $line, $m ) ) {
                continue;
            }

            $exceptions = array();
            $imageDBkey = false;
            foreach ( $m[1] as $i => $titleText ) {
                $title = Title::newFromText( $titleText );
                if ( !is_null( $title ) ) {
                    if ( $i == 0 ) {
                        $imageDBkey = $title->getDBkey();
                    } else {
                        $exceptions[$title->getPrefixedDBkey()] = true;
                    }
                }
            }

            if ( $imageDBkey !== false ) {
                $badImages[$imageDBkey] = $exceptions;
            }
        }
        if ( $cacheable ) {
            $badImageCache = $badImages;
        }
    }

    $contextKey = $contextTitle ? $contextTitle->getPrefixedDBkey() : false;
    $bad = isset( $badImages[$name] ) && !isset( $badImages[$name][$contextKey] );
    wfProfileOut( __METHOD__ );
    return $bad;
}

function wfCanIPUseHTTPS( $ip ) {
    $canDo = true;
    wfRunHooks( 'CanIPUseHTTPS', array( $ip, &$canDo ) );
    return !!$canDo;
}

function wfGetIP() {
    wfDeprecated( __METHOD__, '1.19' );
    global $wgRequest;
    return $wgRequest->getIP();
}

function wfIsTrustedProxy( $ip ) {
    return IP::isTrustedProxy( $ip );
}

function wfIsConfiguredProxy( $ip ) {
    return IP::isConfiguredProxy( $ip );
}