418 lines
13 KiB
PHP
418 lines
13 KiB
PHP
|
|
<?php
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author W-Shadow
|
||
|
|
* @copyright 2010
|
||
|
|
*/
|
||
|
|
|
||
|
|
if ( ! function_exists( 'sys_get_temp_dir' ) ) {
|
||
|
|
function sys_get_temp_dir() {
|
||
|
|
if ( ! empty( $_ENV['TMP'] ) ) { return realpath( $_ENV['TMP'] ); }
|
||
|
|
if ( ! empty( $_ENV['TMPDIR'] ) ) { return realpath( $_ENV['TMPDIR'] ); }
|
||
|
|
if ( ! empty( $_ENV['TEMP'] ) ) { return realpath( $_ENV['TEMP'] ); }
|
||
|
|
$tempfile = tempnam( uniqid( rand(),TRUE ),'' );
|
||
|
|
if ( @file_exists( $tempfile ) ) {
|
||
|
|
unlink( $tempfile );
|
||
|
|
return realpath( dirname( $tempfile ) );
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//Include the internationalized domain name converter (requires PHP 5)
|
||
|
|
if ( version_compare( phpversion(), '5.0.0', '>=' ) && ! class_exists( 'idna_convert' ) ) {
|
||
|
|
include BLC_DIRECTORY . '/idn/idna_convert.class.php';
|
||
|
|
if ( ! function_exists( 'encode_utf8' ) ) {
|
||
|
|
include BLC_DIRECTORY . '/idn/transcode_wrapper.php';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if ( ! class_exists( 'blcUtility' ) ) {
|
||
|
|
class blcUtility {
|
||
|
|
/**
|
||
|
|
* Checks if PHP is running in safe mode
|
||
|
|
* blcUtility::is_safe_mode()
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
static function is_safe_mode() {
|
||
|
|
// Check php.ini safe_mode only if PHP version is lower than 5.3.0, else set to false.
|
||
|
|
if ( version_compare( phpversion(), '5.3.0', '<' ) ) {
|
||
|
|
$safe_mode = ini_get( 'safe_mode' );
|
||
|
|
} else {
|
||
|
|
$safe_mode = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Null, 0, '', '0' and so on count as false.
|
||
|
|
if ( ! $safe_mode ) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// Test for some textual true/false variations.
|
||
|
|
switch ( strtolower( $safe_mode ) ) {
|
||
|
|
case 'on':
|
||
|
|
case 'true':
|
||
|
|
case 'yes':
|
||
|
|
return true;
|
||
|
|
|
||
|
|
case 'off':
|
||
|
|
case 'false':
|
||
|
|
case 'no':
|
||
|
|
return false;
|
||
|
|
|
||
|
|
default: // Let PHP handle anything else.
|
||
|
|
return (bool) (int) $safe_mode;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* blcUtility::is_open_basedir()
|
||
|
|
* Checks if open_basedir is enabled
|
||
|
|
*
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
static function is_open_basedir(){
|
||
|
|
$open_basedir = ini_get( 'open_basedir' );
|
||
|
|
return $open_basedir && ( strtolower( $open_basedir ) != 'none' );
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Truncate a string on a specified boundary character.
|
||
|
|
*
|
||
|
|
* @param string $text The text to truncate.
|
||
|
|
* @param integer $max_characters Return no more than $max_characters
|
||
|
|
* @param string $break Break on this character. Defaults to space.
|
||
|
|
* @param string $pad Pad the truncated string with this string. Defaults to an HTML ellipsis.
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
static function truncate( $text, $max_characters = 0, $break = ' ', $pad = '…' ) {
|
||
|
|
if ( strlen( $text ) <= $max_characters ) {
|
||
|
|
return $text;
|
||
|
|
}
|
||
|
|
|
||
|
|
$text = substr( $text, 0, $max_characters );
|
||
|
|
$break_pos = strrpos( $text, $break );
|
||
|
|
if ( false !== $break_pos ) {
|
||
|
|
$text = substr( $text, 0, $break_pos );
|
||
|
|
}
|
||
|
|
|
||
|
|
return $text.$pad;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* extract_tags()
|
||
|
|
* Extract specific HTML tags and their attributes from a string.
|
||
|
|
*
|
||
|
|
* You can either specify one tag, an array of tag names, or a regular expression that matches the tag name(s).
|
||
|
|
* If multiple tags are specified you must also set the $selfclosing parameter and it must be the same for
|
||
|
|
* all specified tags (so you can't extract both normal and self-closing tags in one go).
|
||
|
|
*
|
||
|
|
* The function returns a numerically indexed array of extracted tags. Each entry is an associative array
|
||
|
|
* with these keys :
|
||
|
|
* tag_name - the name of the extracted tag, e.g. "a" or "img".
|
||
|
|
* offset - the numberic offset of the first character of the tag within the HTML source.
|
||
|
|
* contents - the inner HTML of the tag. This is always empty for self-closing tags.
|
||
|
|
* attributes - a name -> value array of the tag's attributes, or an empty array if the tag has none.
|
||
|
|
* full_tag - the entire matched tag, e.g. '<a href="http://example.com">example.com</a>'. This key
|
||
|
|
* will only be present if you set $return_the_entire_tag to true.
|
||
|
|
*
|
||
|
|
* @param string $html The HTML code to search for tags.
|
||
|
|
* @param string|array $tag The tag(s) to extract.
|
||
|
|
* @param bool $selfclosing Whether the tag is self-closing or not. Setting it to null will force the script to try and make an educated guess.
|
||
|
|
* @param bool $return_the_entire_tag Return the entire matched tag in 'full_tag' key of the results array.
|
||
|
|
* @param string $charset The character set of the HTML code. Defaults to ISO-8859-1.
|
||
|
|
*
|
||
|
|
* @return array An array of extracted tags, or an empty array if no matching tags were found.
|
||
|
|
*/
|
||
|
|
static function extract_tags( $html, $tag, $selfclosing = null, $return_the_entire_tag = false, $charset = 'ISO-8859-1' ) {
|
||
|
|
|
||
|
|
if ( is_array( $tag ) ) {
|
||
|
|
$tag = implode( '|', $tag );
|
||
|
|
}
|
||
|
|
|
||
|
|
//If the user didn't specify if $tag is a self-closing tag we try to auto-detect it
|
||
|
|
//by checking against a list of known self-closing tags.
|
||
|
|
$selfclosing_tags = array( 'area', 'base', 'basefont', 'br', 'hr', 'input', 'img', 'link', 'meta', 'col', 'param' );
|
||
|
|
if ( is_null( $selfclosing ) ) {
|
||
|
|
$selfclosing = in_array( $tag, $selfclosing_tags );
|
||
|
|
}
|
||
|
|
|
||
|
|
//The regexp is different for normal and self-closing tags because I can't figure out
|
||
|
|
//how to make a sufficiently robust unified one.
|
||
|
|
if ( $selfclosing ) {
|
||
|
|
$tag_pattern =
|
||
|
|
'@<(?P<tag>' . $tag . ') # <tag
|
||
|
|
(?P<attributes>\s[^>]+)? # attributes, if any
|
||
|
|
\s*/?> # /> or just >, being lenient here
|
||
|
|
@xsi';
|
||
|
|
} else {
|
||
|
|
$tag_pattern =
|
||
|
|
'@<(?P<tag>' . $tag . ') # <tag
|
||
|
|
(?P<attributes>\s[^>]+)? # attributes, if any
|
||
|
|
\s*> # >
|
||
|
|
(?P<contents>.*?) # tag contents
|
||
|
|
</(?P=tag)> # the closing </tag>
|
||
|
|
@xsi';
|
||
|
|
}
|
||
|
|
|
||
|
|
$attribute_pattern =
|
||
|
|
'@
|
||
|
|
(?P<name>\w+) # attribute name
|
||
|
|
\s*=\s*
|
||
|
|
(
|
||
|
|
(?P<quote>[\"\'])(?P<value_quoted>.*?)(?P=quote) # a quoted value
|
||
|
|
| # or
|
||
|
|
(?P<value_unquoted>[^\s"\']+?)(?:\s+|$) # an unquoted value (terminated by whitespace or EOF)
|
||
|
|
)
|
||
|
|
@xsi';
|
||
|
|
|
||
|
|
//Find all tags
|
||
|
|
if ( ! preg_match_all( $tag_pattern, $html, $matches, PREG_SET_ORDER | PREG_OFFSET_CAPTURE ) ) {
|
||
|
|
//Return an empty array if we didn't find anything
|
||
|
|
return array();
|
||
|
|
}
|
||
|
|
|
||
|
|
$tags = array();
|
||
|
|
foreach ( $matches as $match ) {
|
||
|
|
|
||
|
|
// Parse tag attributes, if any.
|
||
|
|
$attributes = array();
|
||
|
|
if ( ! empty( $match['attributes'][0] ) ) {
|
||
|
|
|
||
|
|
if ( preg_match_all( $attribute_pattern, $match['attributes'][0], $attribute_data, PREG_SET_ORDER ) ) {
|
||
|
|
//Turn the attribute data into a name->value array
|
||
|
|
foreach ( $attribute_data as $attr ) {
|
||
|
|
if( ! empty( $attr['value_quoted'] ) ) {
|
||
|
|
$value = $attr['value_quoted'];
|
||
|
|
} else if( ! empty( $attr['value_unquoted'] ) ) {
|
||
|
|
$value = $attr['value_unquoted'];
|
||
|
|
} else {
|
||
|
|
$value = '';
|
||
|
|
}
|
||
|
|
|
||
|
|
// Passing the value through html_entity_decode is handy when you want
|
||
|
|
// to extract link URLs or something like that. You might want to remove
|
||
|
|
// or modify this call if it doesn't fit your situation.
|
||
|
|
$value = html_entity_decode( $value, ENT_QUOTES, $charset );
|
||
|
|
|
||
|
|
$attributes[ $attr['name'] ] = $value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
$tag = array(
|
||
|
|
'tag_name' => $match['tag'][0],
|
||
|
|
'offset' => $match[0][1],
|
||
|
|
'contents' => ! empty( $match['contents'] ) ? $match['contents'][0] : '', // Empty for self-closing tags.
|
||
|
|
'attributes' => $attributes,
|
||
|
|
);
|
||
|
|
if ( $return_the_entire_tag ) {
|
||
|
|
$tag['full_tag'] = $match[0][0];
|
||
|
|
}
|
||
|
|
|
||
|
|
$tags[] = $tag;
|
||
|
|
}
|
||
|
|
|
||
|
|
return $tags;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the value of a cookie.
|
||
|
|
*
|
||
|
|
* @param string $cookie_name The name of the cookie to return.
|
||
|
|
* @param string $default_value Optional. If the cookie is not set, this value will be returned instead. Defaults to an empty string.
|
||
|
|
* @return mixed Either the value of the requested cookie, or $default_value.
|
||
|
|
*/
|
||
|
|
static function get_cookie( $cookie_name, $default_value = '' ) {
|
||
|
|
if ( isset( $_COOKIE[$cookie_name] ) ) {
|
||
|
|
return $_COOKIE[$cookie_name];
|
||
|
|
} else {
|
||
|
|
return $default_value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Format a time delta using a fuzzy format, e.g. '2 minutes ago', '2 days', etc.
|
||
|
|
*
|
||
|
|
* @param int $delta Time period in seconds.
|
||
|
|
* @param string $type Optional. The output template to use.
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
static function fuzzy_delta( $delta, $template = 'default' ) {
|
||
|
|
|
||
|
|
$templates = array(
|
||
|
|
'seconds' => array(
|
||
|
|
'default' => _n_noop('%d second', '%d seconds'),
|
||
|
|
'ago' => _n_noop('%d second ago', '%d seconds ago'),
|
||
|
|
),
|
||
|
|
'minutes' => array(
|
||
|
|
'default' => _n_noop('%d minute', '%d minutes'),
|
||
|
|
'ago' => _n_noop('%d minute ago', '%d minutes ago'),
|
||
|
|
),
|
||
|
|
'hours' => array(
|
||
|
|
'default' => _n_noop('%d hour', '%d hours'),
|
||
|
|
'ago' => _n_noop('%d hour ago', '%d hours ago'),
|
||
|
|
),
|
||
|
|
'days' => array(
|
||
|
|
'default' => _n_noop('%d day', '%d days'),
|
||
|
|
'ago' => _n_noop('%d day ago', '%d days ago'),
|
||
|
|
),
|
||
|
|
'months' => array(
|
||
|
|
'default' => _n_noop('%d month', '%d months'),
|
||
|
|
'ago' => _n_noop('%d month ago', '%d months ago'),
|
||
|
|
),
|
||
|
|
);
|
||
|
|
|
||
|
|
if ( $delta < 1 ) {
|
||
|
|
$delta = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( $delta < MINUTE_IN_SECONDS ) {
|
||
|
|
$units = 'seconds';
|
||
|
|
} elseif ( $delta < HOUR_IN_SECONDS ) {
|
||
|
|
$delta = intval( $delta / MINUTE_IN_SECONDS );
|
||
|
|
$units = 'minutes';
|
||
|
|
} elseif ( $delta < DAY_IN_SECONDS ) {
|
||
|
|
$delta = intval( $delta / HOUR_IN_SECONDS );
|
||
|
|
$units = 'hours';
|
||
|
|
} elseif ( $delta < MONTH_IN_SECONDS ) {
|
||
|
|
$delta = intval( $delta / DAY_IN_SECONDS );
|
||
|
|
$units = 'days';
|
||
|
|
} else {
|
||
|
|
$delta = intval( $delta / MONTH_IN_SECONDS );
|
||
|
|
$units = 'months';
|
||
|
|
}
|
||
|
|
|
||
|
|
return sprintf(
|
||
|
|
_n(
|
||
|
|
$templates[$units][$template][0],
|
||
|
|
$templates[$units][$template][1],
|
||
|
|
$delta,
|
||
|
|
'broken-link-checker'
|
||
|
|
),
|
||
|
|
$delta
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Optimize the plugin's tables
|
||
|
|
*
|
||
|
|
* @return void
|
||
|
|
*/
|
||
|
|
static function optimize_database(){
|
||
|
|
global $wpdb; /** @var wpdb $wpdb */
|
||
|
|
|
||
|
|
$wpdb->query( "OPTIMIZE TABLE {$wpdb->prefix}blc_links, {$wpdb->prefix}blc_instances, {$wpdb->prefix}blc_synch" );
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the server's load averages.
|
||
|
|
*
|
||
|
|
* Returns an array with three samples - the 1 minute avg, the 5 minute avg, and the 15 minute avg.
|
||
|
|
*
|
||
|
|
* @param integer $cache How long the load averages may be cached, in seconds. Set to 0 to get maximally up-to-date data.
|
||
|
|
* @return array|null Array, or NULL if retrieving load data is impossible (e.g. when running on a Windows box).
|
||
|
|
*/
|
||
|
|
static function get_server_load( $cache = 5 ) {
|
||
|
|
static $cached_load = null;
|
||
|
|
static $cached_when = 0;
|
||
|
|
|
||
|
|
if ( ! empty( $cache ) && ((time() - $cached_when) <= $cache) ) {
|
||
|
|
return $cached_load;
|
||
|
|
}
|
||
|
|
|
||
|
|
$load = null;
|
||
|
|
|
||
|
|
if ( function_exists( 'sys_getloadavg' ) ) {
|
||
|
|
$load = sys_getloadavg();
|
||
|
|
} else {
|
||
|
|
$loadavg_file = '/proc/loadavg';
|
||
|
|
if ( @is_readable( $loadavg_file ) ) {
|
||
|
|
$load = explode( ' ', file_get_contents( $loadavg_file ) );
|
||
|
|
$load = array_map( 'floatval', $load );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
$cached_load = $load;
|
||
|
|
$cached_when = time();
|
||
|
|
return $load;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert an internationalized domain name or URL to ASCII-compatible encoding.
|
||
|
|
*
|
||
|
|
* @param string $url Either a domain name or a complete URL.
|
||
|
|
* @param string $charset The character encoding of the $url parameter. Defaults to the encoding set in Settings -> Reading.
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
static function idn_to_ascii( $url, $charset = '' ) {
|
||
|
|
$idn = blcUtility::get_idna_converter();
|
||
|
|
if ( $idn != null ) {
|
||
|
|
if ( empty( $charset ) ) {
|
||
|
|
$charset = get_bloginfo( 'charset' );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Encode only the host.
|
||
|
|
if ( preg_match( '@(\w+:/*)?([^/:]+)(.*$)?@s', $url, $matches ) ) {
|
||
|
|
$host = $matches[2];
|
||
|
|
if ( ( strtoupper( $charset ) != 'UTF-8') && ( strtoupper( $charset ) != 'UTF8') ) {
|
||
|
|
$host = encode_utf8( $host, $charset, true );
|
||
|
|
}
|
||
|
|
$host = $idn->encode( $host );
|
||
|
|
$url = $matches[1] . $host . $matches[3];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return $url;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert an internationalized domain name (or URL) from ASCII-compatible encoding to UTF8.
|
||
|
|
*
|
||
|
|
* @param string $url
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
static function idn_to_utf8( $url ) {
|
||
|
|
$idn = blcUtility::get_idna_converter();
|
||
|
|
if ( null !== $idn ) {
|
||
|
|
$url = $idn->decode( $url );
|
||
|
|
}
|
||
|
|
|
||
|
|
return $url;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get an instance of idna_converter
|
||
|
|
*
|
||
|
|
* @return idna_convert|null Either an instance of IDNA converter, or NULL if the converter class is not available
|
||
|
|
*/
|
||
|
|
static function get_idna_converter() {
|
||
|
|
static $idn = null;
|
||
|
|
if ( ( null === $idn ) && class_exists( 'idna_convert' ) ) {
|
||
|
|
$idn = new idna_convert();
|
||
|
|
}
|
||
|
|
return $idn;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Generate a numeric hash from a string. The result will be constrained to the specified interval.
|
||
|
|
*
|
||
|
|
* @static
|
||
|
|
* @param string $input
|
||
|
|
* @param int $min
|
||
|
|
* @param int $max
|
||
|
|
* @return float
|
||
|
|
*/
|
||
|
|
public static function constrained_hash( $input, $min = 0, $max = 1 ) {
|
||
|
|
$bytes_to_use = 3;
|
||
|
|
$md5_char_count = 32;
|
||
|
|
$hash = substr( md5( $input ), $md5_char_count - $bytes_to_use * 2 );
|
||
|
|
$hash = intval( hexdec( $hash ) );
|
||
|
|
return $min + ( ( $max - $min ) * ( $hash / ( pow( 2, $bytes_to_use * 8 ) - 1) ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
}//class
|
||
|
|
|
||
|
|
}//class_exists
|