includes/functions-formatting.php

   1 <?php
   2 /*
   3  * YOURLS
   4  * Function library for anything related to formatting / validating / sanitizing
   5  */
   6
   7 /**
   8  * Convert an integer (1337) to a string (3jk).
   9  *
  10  */
  11 function yourls_int2string( $num, $chars = null ) {
  12         if( $chars == null )
  13                 $chars = yourls_get_shorturl_charset();
  14         $string = '';
  15         $len = strlen( $chars );
  16         while( $num >= $len ) {
  17                 $mod = bcmod( $num, $len );
  18                 $num = bcdiv( $num, $len );
  19                 $string = $chars[ $mod ] . $string;
  20         }
  21         $string = $chars[ intval( $num ) ] . $string;
  22
  23         return yourls_apply_filter( 'int2string', $string, $num, $chars );
  24 }
  25
  26 /**
  27  * Convert a string (3jk) to an integer (1337)
  28  *
  29  */
  30 function yourls_string2int( $string, $chars = null ) {
  31         if( $chars == null )
  32                 $chars = yourls_get_shorturl_charset();
  33         $integer = 0;
  34         $string = strrev( $string  );
  35         $baselen = strlen( $chars );
  36         $inputlen = strlen( $string );
  37         for ($i = 0; $i < $inputlen; $i++) {
  38                 $index = strpos( $chars, $string[$i] );
  39                 $integer = bcadd( $integer, bcmul( $index, bcpow( $baselen, $i ) ) );
  40         }
  41
  42         return yourls_apply_filter( 'string2int', $integer, $string, $chars );
  43 }
  44
  45 /**
  46  * Return a unique(ish) hash for a string to be used as a valid HTML id
  47  *
  48  */
  49 function yourls_string2htmlid( $string ) {
  50         return yourls_apply_filter( 'string2htmlid', 'y'.abs( crc32( $string ) ) );
  51 }
  52
  53 /**
  54  * Make sure a link keyword (ie "1fv" as in "site.com/1fv") is valid.
  55  *
  56  */
  57 function yourls_sanitize_string( $string ) {
  58         // make a regexp pattern with the shorturl charset, and remove everything but this
  59         $pattern = yourls_make_regexp_pattern( yourls_get_shorturl_charset() );
  60         $valid = substr( preg_replace( '![^'.$pattern.']!', '', $string ), 0, 199 );
  61
  62         return yourls_apply_filter( 'sanitize_string', $valid, $string );
  63 }
  64
  65 /**
  66  * Alias function. I was always getting it wrong.
  67  *
  68  */
  69 function yourls_sanitize_keyword( $keyword ) {
  70         return yourls_sanitize_string( $keyword );
  71 }
  72
  73 /**
  74  * Sanitize a page title. No HTML per W3C http://www.w3.org/TR/html401/struct/global.html#h-7.4.2
  75  *
  76  */
  77 function yourls_sanitize_title( $unsafe_title ) {
  78         $title = $unsafe_title;
  79         $title = strip_tags( $title );
  80         $title = preg_replace( "/\s+/", ' ', trim( $title ) );
  81         return yourls_apply_filter( 'sanitize_title', $title, $unsafe_title );
  82 }
  83
  84 /**
  85  * A few sanity checks on the URL. Used for redirection or DB. For display purpose, see yourls_esc_url()
  86  *
  87  */
  88 function yourls_sanitize_url( $unsafe_url ) {
  89         $url = yourls_esc_url( $unsafe_url, 'redirection' );
  90         return yourls_apply_filter( 'sanitize_url', $url, $unsafe_url );
  91 }
  92
  93 /**
  94  * Perform a replacement while a string is found, eg $subject = '%0%0%0DDD', $search ='%0D' -> $result =''
  95  *
  96  * Stolen from WP's _deep_replace
  97  *
  98  */
  99 function yourls_deep_replace( $search, $subject ){
 100         $found = true;
 101         while($found) {
 102                 $found = false;
 103                 foreach( (array) $search as $val ) {
 104                         while( strpos( $subject, $val ) !== false ) {
 105                                 $found = true;
 106                                 $subject = str_replace( $val, '', $subject );
 107                         }
 108                 }
 109         }
 110
 111         return $subject;
 112 }
 113
 114 /**
 115  * Make sure an integer is a valid integer (PHP's intval() limits to too small numbers)
 116  *
 117  */
 118 function yourls_sanitize_int( $in ) {
 119         return ( substr( preg_replace( '/[^0-9]/', '', strval( $in ) ), 0, 20 ) );
 120 }
 121
 122 /**
 123  * Escape a string or an array of strings before DB usage. ALWAYS escape before using in a SQL query. Thanks.
 124  *
 125  * @param string|array $data string or array of strings to be escaped
 126  * @return string|array escaped data
 127  */
 128 function yourls_escape( $data ) {
 129         if( is_array( $data ) ) {
 130                 foreach( $data as $k => $v ) {
 131                         if( is_array( $v ) ) {
 132                                 $data[ $k ] = yourls_escape( $v );
 133                         } else {
 134                                 $data[ $k ] = yourls_escape_real( $v );
 135                         }
 136                 }
 137         } else {
 138                 $data = yourls_escape_real( $data );
 139         }
 140
 141         return $data;
 142 }
 143
 144 /**
 145  * "Real" escape. This function should NOT be called directly. Use yourls_escape() instead.
 146  *
 147  * This function uses a "real" escape if possible, using PDO, MySQL or MySQLi functions,
 148  * with a fallback to a "simple" addslashes
 149  * If you're implementing a custom DB engine or a custom cache system, you can define an
 150  * escape function using filter 'custom_escape_real'
 151  *
 152  * @since 1.7
 153  * @param string $a string to be escaped
 154  * @return string escaped string
 155  */
 156 function yourls_escape_real( $string ) {
 157         global $ydb;
 158         if( isset( $ydb ) && ( $ydb instanceof ezSQLcore ) )
 159                 return $ydb->escape( $string );
 160
 161         // YOURLS DB classes have been bypassed by a custom DB engine or a custom cache layer
 162         return yourls_apply_filters( 'custom_escape_real', addslashes( $string ), $string );
 163 }
 164
 165 /**
 166  * Sanitize an IP address
 167  *
 168  */
 169 function yourls_sanitize_ip( $ip ) {
 170         return preg_replace( '/[^0-9a-fA-F:., ]/', '', $ip );
 171 }
 172
 173 /**
 174  * Make sure a date is m(m)/d(d)/yyyy, return false otherwise
 175  *
 176  */
 177 function yourls_sanitize_date( $date ) {
 178         if( !preg_match( '!^\d{1,2}/\d{1,2}/\d{4}$!' , $date ) ) {
 179                 return false;
 180         }
 181         return $date;
 182 }
 183
 184 /**
 185  * Sanitize a date for SQL search. Return false if malformed input.
 186  *
 187  */
 188 function yourls_sanitize_date_for_sql( $date ) {
 189         if( !yourls_sanitize_date( $date ) )
 190                 return false;
 191         return date( 'Y-m-d', strtotime( $date ) );
 192 }
 193
 194 /**
 195  * Return trimmed string
 196  *
 197  */
 198 function yourls_trim_long_string( $string, $length = 60, $append = '[...]' ) {
 199         $newstring = $string;
 200         if( function_exists( 'mb_substr' ) ) {
 201                 if ( mb_strlen( $newstring ) > $length ) {
 202                         $newstring = mb_substr( $newstring, 0, $length - mb_strlen( $append ), 'UTF-8' ) . $append;
 203                 }
 204         } else {
 205                 if ( strlen( $newstring ) > $length ) {
 206                         $newstring = substr( $newstring, 0, $length - strlen( $append ) ) . $append;
 207                 }
 208         }
 209         return yourls_apply_filter( 'trim_long_string', $newstring, $string, $length, $append );
 210 }
 211
 212 /**
 213  * Sanitize a version number (1.4.1-whatever -> 1.4.1)
 214  *
 215  */
 216 function yourls_sanitize_version( $ver ) {
 217         return preg_replace( '/[^0-9.]/', '', $ver );
 218 }
 219
 220 /**
 221  * Sanitize a filename (no Win32 stuff)
 222  *
 223  */
 224 function yourls_sanitize_filename( $file ) {
 225         $file = str_replace( '\\', '/', $file ); // sanitize for Win32 installs
 226         $file = preg_replace( '|/+|' ,'/', $file ); // remove any duplicate slash
 227         return $file;
 228 }
 229
 230 /**
 231  * Check if a string seems to be UTF-8. Stolen from WP.
 232  *
 233  */
 234 function yourls_seems_utf8( $str ) {
 235         $length = strlen( $str );
 236         for ( $i=0; $i < $length; $i++ ) {
 237                 $c = ord( $str[ $i ] );
 238                 if ( $c < 0x80 ) $n = 0; # 0bbbbbbb
 239                 elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb
 240                 elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb
 241                 elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb
 242                 elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb
 243                 elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b
 244                 else return false; # Does not match any model
 245                 for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
 246                         if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
 247                                 return false;
 248                 }
 249         }
 250         return true;
 251 }
 252
 253 /**
 254  * Checks for invalid UTF8 in a string. Stolen from WP
 255  *
 256  * @since 1.6
 257  *
 258  * @param string $string The text which is to be checked.
 259  * @param boolean $strip Optional. Whether to attempt to strip out invalid UTF8. Default is false.
 260  * @return string The checked text.
 261  */
 262 function yourls_check_invalid_utf8( $string, $strip = false ) {
 263         $string = (string) $string;
 264
 265         if ( 0 === strlen( $string ) ) {
 266                 return '';
 267         }
 268
 269         // Check for support for utf8 in the installed PCRE library once and store the result in a static
 270         static $utf8_pcre;
 271         if ( !isset( $utf8_pcre ) ) {
 272                 $utf8_pcre = @preg_match( '/^./u', 'a' );
 273         }
 274         // We can't demand utf8 in the PCRE installation, so just return the string in those cases
 275         if ( !$utf8_pcre ) {
 276                 return $string;
 277         }
 278
 279         // preg_match fails when it encounters invalid UTF8 in $string
 280         if ( 1 === @preg_match( '/^./us', $string ) ) {
 281                 return $string;
 282         }
 283
 284         // Attempt to strip the bad chars if requested (not recommended)
 285         if ( $strip && function_exists( 'iconv' ) ) {
 286                 return iconv( 'utf-8', 'utf-8', $string );
 287         }
 288
 289         return '';
 290 }
 291
 292 /**
 293  * Converts a number of special characters into their HTML entities. Stolen from WP.
 294  *
 295  * Specifically deals with: &, <, >, ", and '.
 296  *
 297  * $quote_style can be set to ENT_COMPAT to encode " to
 298  * &quot;, or ENT_QUOTES to do both. Default is ENT_NOQUOTES where no quotes are encoded.
 299  *
 300  * @since 1.6
 301  *
 302  * @param string $string The text which is to be encoded.
 303  * @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.
 304  * @param boolean $double_encode Optional. Whether to encode existing html entities. Default is false.
 305  * @return string The encoded text with HTML entities.
 306  */
 307 function yourls_specialchars( $string, $quote_style = ENT_NOQUOTES, $double_encode = false ) {
 308         $string = (string) $string;
 309
 310         if ( 0 === strlen( $string ) )
 311                 return '';
 312
 313         // Don't bother if there are no specialchars - saves some processing
 314         if ( ! preg_match( '/[&<>"\']/', $string ) )
 315                 return $string;
 316
 317         // Account for the previous behaviour of the function when the $quote_style is not an accepted value
 318         if ( empty( $quote_style ) )
 319                 $quote_style = ENT_NOQUOTES;
 320         elseif ( ! in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) )
 321                 $quote_style = ENT_QUOTES;
 322
 323         $charset = 'UTF-8';
 324
 325         $_quote_style = $quote_style;
 326
 327         if ( $quote_style === 'double' ) {
 328                 $quote_style = ENT_COMPAT;
 329                 $_quote_style = ENT_COMPAT;
 330         } elseif ( $quote_style === 'single' ) {
 331                 $quote_style = ENT_NOQUOTES;
 332         }
 333
 334         // Handle double encoding ourselves
 335         if ( $double_encode ) {
 336                 $string = @htmlspecialchars( $string, $quote_style, $charset );
 337         } else {
 338                 // Decode &amp; into &
 339                 $string = yourls_specialchars_decode( $string, $_quote_style );
 340
 341                 // Guarantee every &entity; is valid or re-encode the &
 342                 $string = yourls_kses_normalize_entities( $string );
 343
 344                 // Now re-encode everything except &entity;
 345                 $string = preg_split( '/(&#?x?[0-9a-z]+;)/i', $string, -1, PREG_SPLIT_DELIM_CAPTURE );
 346
 347                 for ( $i = 0; $i < count( $string ); $i += 2 )
 348                         $string[$i] = @htmlspecialchars( $string[$i], $quote_style, $charset );
 349
 350                 $string = implode( '', $string );
 351         }
 352
 353         // Backwards compatibility
 354         if ( 'single' === $_quote_style )
 355                 $string = str_replace( "'", '&#039;', $string );
 356
 357         return $string;
 358 }
 359
 360 /**
 361  * Converts a number of HTML entities into their special characters. Stolen from WP.
 362  *
 363  * Specifically deals with: &, <, >, ", and '.
 364  *
 365  * $quote_style can be set to ENT_COMPAT to decode " entities,
 366  * or ENT_QUOTES to do both " and '. Default is ENT_NOQUOTES where no quotes are decoded.
 367  *
 368  * @since 1.6
 369  *
 370  * @param string $string The text which is to be decoded.
 371  * @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old _wp_specialchars() values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.
 372  * @return string The decoded text without HTML entities.
 373  */
 374 function yourls_specialchars_decode( $string, $quote_style = ENT_NOQUOTES ) {
 375         $string = (string) $string;
 376
 377         if ( 0 === strlen( $string ) ) {
 378                 return '';
 379         }
 380
 381         // Don't bother if there are no entities - saves a lot of processing
 382         if ( strpos( $string, '&' ) === false ) {
 383                 return $string;
 384         }
 385
 386         // Match the previous behaviour of _wp_specialchars() when the $quote_style is not an accepted value
 387         if ( empty( $quote_style ) ) {
 388                 $quote_style = ENT_NOQUOTES;
 389         } elseif ( !in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) ) {
 390                 $quote_style = ENT_QUOTES;
 391         }
 392
 393         // More complete than get_html_translation_table( HTML_SPECIALCHARS )
 394         $single = array( '&#039;'  => '\'', '&#x27;' => '\'' );
 395         $single_preg = array( '/&#0*39;/'  => '&#039;', '/&#x0*27;/i' => '&#x27;' );
 396         $double = array( '&quot;' => '"', '&#034;'  => '"', '&#x22;' => '"' );
 397         $double_preg = array( '/&#0*34;/'  => '&#034;', '/&#x0*22;/i' => '&#x22;' );
 398         $others = array( '&lt;'   => '<', '&#060;'  => '<', '&gt;'   => '>', '&#062;'  => '>', '&amp;'  => '&', '&#038;'  => '&', '&#x26;' => '&' );
 399         $others_preg = array( '/&#0*60;/'  => '&#060;', '/&#0*62;/'  => '&#062;', '/&#0*38;/'  => '&#038;', '/&#x0*26;/i' => '&#x26;' );
 400
 401         if ( $quote_style === ENT_QUOTES ) {
 402                 $translation = array_merge( $single, $double, $others );
 403                 $translation_preg = array_merge( $single_preg, $double_preg, $others_preg );
 404         } elseif ( $quote_style === ENT_COMPAT || $quote_style === 'double' ) {
 405                 $translation = array_merge( $double, $others );
 406                 $translation_preg = array_merge( $double_preg, $others_preg );
 407         } elseif ( $quote_style === 'single' ) {
 408                 $translation = array_merge( $single, $others );
 409                 $translation_preg = array_merge( $single_preg, $others_preg );
 410         } elseif ( $quote_style === ENT_NOQUOTES ) {
 411                 $translation = $others;
 412                 $translation_preg = $others_preg;
 413         }
 414
 415         // Remove zero padding on numeric entities
 416         $string = preg_replace( array_keys( $translation_preg ), array_values( $translation_preg ), $string );
 417
 418         // Replace characters according to translation table
 419         return strtr( $string, $translation );
 420 }
 421
 422
 423 /**
 424  * Escaping for HTML blocks. Stolen from WP
 425  *
 426  * @since 1.6
 427  *
 428  * @param string $text
 429  * @return string
 430  */
 431 function yourls_esc_html( $text ) {
 432         $safe_text = yourls_check_invalid_utf8( $text );
 433         $safe_text = yourls_specialchars( $safe_text, ENT_QUOTES );
 434         return yourls_apply_filters( 'esc_html', $safe_text, $text );
 435 }
 436
 437 /**
 438  * Escaping for HTML attributes.  Stolen from WP
 439  *
 440  * @since 1.6
 441  *
 442  * @param string $text
 443  * @return string
 444  */
 445 function yourls_esc_attr( $text ) {
 446         $safe_text = yourls_check_invalid_utf8( $text );
 447         $safe_text = yourls_specialchars( $safe_text, ENT_QUOTES );
 448         return yourls_apply_filters( 'esc_attr', $safe_text, $text );
 449 }
 450
 451 /**
 452  * Checks and cleans a URL before printing it. Stolen from WP.
 453  *
 454  * A number of characters are removed from the URL. If the URL is for displaying
 455  * (the default behaviour) ampersands are also replaced.
 456  *
 457  * @since 1.6
 458  *
 459  * @param string $url The URL to be cleaned.
 460  * @param string $context 'display' or something else. Use yourls_sanitize_url() for database or redirection usage.
 461  * @param array $protocols Optional. Array of allowed protocols, defaults to global $yourls_allowedprotocols
 462  * @return string The cleaned $url
 463  */
 464 function yourls_esc_url( $url, $context = 'display', $protocols = array() ) {
 465         // make sure there's only one 'http://' at the beginning (prevents pasting a URL right after the default 'http://')
 466         $url = str_replace(
 467                 array( 'http://http://', 'http://https://' ),
 468                 array( 'http://',        'https://'        ),
 469                 $url
 470         );
 471
 472         if ( '' == $url )
 473                 return $url;
 474
 475         // make sure there's a protocol, add http:// if not
 476         if ( ! yourls_get_protocol( $url ) )
 477                 $url = 'http://'.$url;
 478
 479         // force scheme and domain to lowercase - see issue 591
 480         preg_match( '!^([a-zA-Z]+://([^/]+))(.*)$!', $url, $matches );
 481         if( isset( $matches[1] ) && isset( $matches[3] ) )
 482                 $url = strtolower( $matches[1] ) . $matches[3];
 483
 484         $original_url = $url;
 485
 486         $url = preg_replace( '|[^a-z0-9-~+_.?#=!&;,/:%@$\|*\'()\\x80-\\xff]|i', '', $url );
 487         // Previous regexp in YOURLS was '|[^a-z0-9-~+_.?\[\]\^#=!&;,/:%@$\|*`\'<>"()\\x80-\\xff\{\}]|i'
 488         // TODO: check if that was it too destructive
 489         $strip = array( '%0d', '%0a', '%0D', '%0A' );
 490         $url = yourls_deep_replace( $strip, $url );
 491         $url = str_replace( ';//', '://', $url );
 492
 493         // Replace ampersands and single quotes only when displaying.
 494         if ( 'display' == $context ) {
 495                 $url = yourls_kses_normalize_entities( $url );
 496                 $url = str_replace( '&amp;', '&#038;', $url );
 497                 $url = str_replace( "'", '&#039;', $url );
 498         }
 499
 500         if ( ! is_array( $protocols ) or ! $protocols ) {
 501                 global $yourls_allowedprotocols;
 502                 $protocols = yourls_apply_filter( 'esc_url_protocols', $yourls_allowedprotocols );
 503                 // Note: $yourls_allowedprotocols is also globally filterable in functions-kses.php/yourls_kses_init()
 504         }
 505
 506         if ( !yourls_is_allowed_protocol( $url, $protocols ) )
 507                 return '';
 508
 509         // I didn't use KSES function kses_bad_protocol() because it doesn't work the way I liked (returns //blah from illegal://blah)
 510
 511         $url = substr( $url, 0, 1999 );
 512
 513         return yourls_apply_filter( 'esc_url', $url, $original_url, $context );
 514 }
 515
 516 /**
 517  * Escape single quotes, htmlspecialchar " < > &, and fix line endings. Stolen from WP.
 518  *
 519  * Escapes text strings for echoing in JS. It is intended to be used for inline JS
 520  * (in a tag attribute, for example onclick="..."). Note that the strings have to
 521  * be in single quotes. The filter 'js_escape' is also applied here.
 522  *
 523  * @since 1.6
 524  *
 525  * @param string $text The text to be escaped.
 526  * @return string Escaped text.
 527  */
 528 function yourls_esc_js( $text ) {
 529         $safe_text = yourls_check_invalid_utf8( $text );
 530         $safe_text = yourls_specialchars( $safe_text, ENT_COMPAT );
 531         $safe_text = preg_replace( '/&#(x)?0*(?(1)27|39);?/i', "'", stripslashes( $safe_text ) );
 532         $safe_text = str_replace( "\r", '', $safe_text );
 533         $safe_text = str_replace( "\n", '\\n', addslashes( $safe_text ) );
 534         return yourls_apply_filters( 'esc_js', $safe_text, $text );
 535 }
 536
 537 /**
 538  * Escaping for textarea values. Stolen from WP.
 539  *
 540  * @since 1.6
 541  *
 542  * @param string $text
 543  * @return string
 544  */
 545 function yourls_esc_textarea( $text ) {
 546         $safe_text = htmlspecialchars( $text, ENT_QUOTES );
 547         return yourls_apply_filters( 'esc_textarea', $safe_text, $text );
 548 }
 549
 550
 551 /**
 552 * PHP emulation of JS's encodeURI
 553 *
 554 * @link https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/encodeURI
 555 * @param $url
 556 * @return string
 557 */
 558 function yourls_encodeURI( $url ) {
 559         // Decode URL all the way
 560         $result = yourls_rawurldecode_while_encoded( $url );
 561         // Encode once
 562         $result = strtr( rawurlencode( $result ), array (
 563         '%3B' => ';', '%2C' => ',', '%2F' => '/', '%3F' => '?', '%3A' => ':', '%40' => '@',
 564                 '%26' => '&', '%3D' => '=', '%2B' => '+', '%24' => '$', '%21' => '!', '%2A' => '*',
 565                 '%27' => '\'', '%28' => '(', '%29' => ')', '%23' => '#',
 566     ) );
 567         // @TODO:
 568         // Known limit: this will most likely break IDN URLs such as http://www.académie-française.fr/
 569         // To fully support IDN URLs, advocate use of a plugin.
 570         return yourls_apply_filter( 'encodeURI', $result, $url );
 571 }
 572
 573 /**
 574  * Adds backslashes before letters and before a number at the start of a string. Stolen from WP.
 575  *
 576  * @since 1.6
 577  *
 578  * @param string $string Value to which backslashes will be added.
 579  * @return string String with backslashes inserted.
 580  */
 581 function yourls_backslashit($string) {
 582     $string = preg_replace('/^([0-9])/', '\\\\\\\\\1', $string);
 583     $string = preg_replace('/([a-z])/i', '\\\\\1', $string);
 584     return $string;
 585 }
 586
 587 /**
 588  * Check if a string seems to be urlencoded
 589  *
 590  * We use rawurlencode instead of urlencode to avoid messing with '+'
 591  *
 592  * @since 1.7
 593  * @param string $string
 594  * @return bool
 595  */
 596 function yourls_is_rawurlencoded( $string ) {
 597         return rawurldecode( $string ) != $string;
 598 }
 599
 600 /**
 601  * rawurldecode a string till it's not encoded anymore
 602  *
 603  * Deals with multiple encoding (eg "%2521" => "%21" => "!").
 604  * See https://github.com/YOURLS/YOURLS/issues/1303
 605  *
 606  * @since 1.7
 607  * @param string $string
 608  * @return string
 609  */
 610 function yourls_rawurldecode_while_encoded( $string ) {
 611         $string = rawurldecode( $string );
 612         if( yourls_is_rawurlencoded( $string ) ) {
 613                 $string = yourls_rawurldecode_while_encoded( $string );
 614         }
 615         return $string;
 616 }