1 <?php

     2 /**

     3  * Random_* Compatibility Library

     4  * for using the new PHP 7 random_* API in PHP 5 projects

     5  *

     6  * The MIT License (MIT)

     7  *

     8  * Copyright (c) 2015 Paragon Initiative Enterprises

     9  *

    10  * Permission is hereby granted, free of charge, to any person obtaining a copy

    11  * of this software and associated documentation files (the "Software"), to deal

    12  * in the Software without restriction, including without limitation the rights

    13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    14  * copies of the Software, and to permit persons to whom the Software is

    15  * furnished to do so, subject to the following conditions:

    16  *

    17  * The above copyright notice and this permission notice shall be included in

    18  * all copies or substantial portions of the Software.

    19  *

    20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

    26  * SOFTWARE.

    27  */

    28 

    29 if (!function_exists('RandomCompat_strlen')) {

    30     if (

    31         defined('MB_OVERLOAD_STRING') &&

    32         ini_get('mbstring.func_overload') & MB_OVERLOAD_STRING

    33     ) {

    34         /**

    35          * strlen() implementation that isn't brittle to mbstring.func_overload

    36          *

    37          * This version uses mb_strlen() in '8bit' mode to treat strings as raw

    38          * binary rather than UTF-8, ISO-8859-1, etc

    39          *

    40          * @param string $binary_string

    41          *

    42          * @throws TypeError

    43          *

    44          * @return int

    45          */

    46         function RandomCompat_strlen($binary_string)

    47         {

    48             if (!is_string($binary_string)) {

    49                 throw new TypeError(

    50                     'RandomCompat_strlen() expects a string'

    51                 );

    52             }

    53 

    54             return mb_strlen($binary_string, '8bit');

    55         }

    56 

    57     } else {

    58         /**

    59          * strlen() implementation that isn't brittle to mbstring.func_overload

    60          *

    61          * This version just used the default strlen()

    62          *

    63          * @param string $binary_string

    64          *

    65          * @throws TypeError

    66          *

    67          * @return int

    68          */

    69         function RandomCompat_strlen($binary_string)

    70         {

    71             if (!is_string($binary_string)) {

    72                 throw new TypeError(

    73                     'RandomCompat_strlen() expects a string'

    74                 );

    75             }

    76             return strlen($binary_string);

    77         }

    78     }

    79 }

    80 

    81 if (!function_exists('RandomCompat_substr')) {

    82 

    83     if (

    84         defined('MB_OVERLOAD_STRING')

    85         &&

    86         ini_get('mbstring.func_overload') & MB_OVERLOAD_STRING

    87     ) {

    88         /**

    89          * substr() implementation that isn't brittle to mbstring.func_overload

    90          *

    91          * This version uses mb_substr() in '8bit' mode to treat strings as raw

    92          * binary rather than UTF-8, ISO-8859-1, etc

    93          *

    94          * @param string $binary_string

    95          * @param int $start

    96          * @param int $length (optional)

    97          *

    98          * @throws TypeError

    99          *

   100          * @return string

   101          */

   102         function RandomCompat_substr($binary_string, $start, $length = null)

   103         {

   104             if (!is_string($binary_string)) {

   105                 throw new TypeError(

   106                     'RandomCompat_substr(): First argument should be a string'

   107                 );

   108             }

   109 

   110             if (!is_int($start)) {

   111                 throw new TypeError(

   112                     'RandomCompat_substr(): Second argument should be an integer'

   113                 );

   114             }

   115 

   116             if ($length === null) {

   117                 /**

   118                  * mb_substr($str, 0, NULL, '8bit') returns an empty string on

   119                  * PHP 5.3, so we have to find the length ourselves.

   120                  */

   121                 $length = RandomCompat_strlen($length) - $start;

   122             } elseif (!is_int($length)) {

   123                 throw new TypeError(

   124                     'RandomCompat_substr(): Third argument should be an integer, or omitted'

   125                 );

   126             }

   127 

   128             return mb_substr($binary_string, $start, $length, '8bit');

   129         }

   130 

   131     } else {

   132 

   133         /**

   134          * substr() implementation that isn't brittle to mbstring.func_overload

   135          *

   136          * This version just uses the default substr()

   137          *

   138          * @param string $binary_string

   139          * @param int $start

   140          * @param int $length (optional)

   141          *

   142          * @throws TypeError

   143          *

   144          * @return string

   145          */

   146         function RandomCompat_substr($binary_string, $start, $length = null)

   147         {

   148             if (!is_string($binary_string)) {

   149                 throw new TypeError(

   150                     'RandomCompat_substr(): First argument should be a string'

   151                 );

   152             }

   153 

   154             if (!is_int($start)) {

   155                 throw new TypeError(

   156                     'RandomCompat_substr(): Second argument should be an integer'

   157                 );

   158             }

   159 

   160             if ($length !== null) {

   161                 if (!is_int($length)) {

   162                     throw new TypeError(

   163                         'RandomCompat_substr(): Third argument should be an integer, or omitted'

   164                     );

   165                 }

   166 

   167                 return substr($binary_string, $start, $length);

   168             }

   169 

   170             return substr($binary_string, $start);

   171         }

   172     }

   173 }