src/Encoding.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin;
   6
   7 use function array_intersect;
   8 use function array_map;
   9 use function explode;
  10 use function fclose;
  11 use function feof;
  12 use function fgets;
  13 use function fopen;
  14 use function function_exists;
  15 use function fwrite;
  16 use function iconv;
  17 use function mb_convert_encoding;
  18 use function mb_convert_kana;
  19 use function mb_detect_encoding;
  20 use function mb_list_encodings;
  21 use function strtolower;
  22 use function tempnam;
  23 use function unlink;
  24
  25 /**
  26  * Encoding conversion helper class
  27  */
  28 class Encoding
  29 {
  30     /**
  31      * None encoding conversion engine
  32      */
  33     public const ENGINE_NONE = 0;
  34
  35     /**
  36      * iconv encoding conversion engine
  37      */
  38     public const ENGINE_ICONV = 1;
  39
  40     /**
  41      * mbstring encoding conversion engine
  42      */
  43     public const ENGINE_MB = 3;
  44
  45     /**
  46      * Chosen encoding engine
  47      */
  48     private static int|null $engine = null;
  49
  50     /**
  51      * Map of conversion engine configurations
  52      *
  53      * Each entry contains:
  54      *
  55      * - function to detect
  56      * - engine contant
  57      * - extension name to warn when missing
  58      *
  59      * @var mixed[]
  60      */
  61     private static array $enginemap = [
  62         'iconv' => ['iconv', self::ENGINE_ICONV, 'iconv'],
  63         'mb' => ['mb_convert_encoding', self::ENGINE_MB, 'mbstring'],
  64         'none' => ['isset', self::ENGINE_NONE, ''],
  65     ];
  66
  67     /**
  68      * Order of automatic detection of engines
  69      *
  70      * @var mixed[]
  71      */
  72     private static array $engineorder = ['iconv', 'mb'];
  73
  74     /**
  75      * Kanji encodings list
  76      */
  77     private static string $kanjiEncodings = 'ASCII,SJIS,EUC-JP,JIS';
  78
  79     /**
  80      * Initializes encoding engine detecting available backends.
  81      */
  82     public static function initEngine(): void
  83     {
  84         $engine = 'auto';
  85         $config = Config::getInstance();
  86         if (isset($config->settings['RecodingEngine'])) {
  87             $engine = $config->settings['RecodingEngine'];
  88         }
  89
  90         /* Use user configuration */
  91         if (isset(self::$enginemap[$engine])) {
  92             if (function_exists(self::$enginemap[$engine][0])) {
  93                 self::$engine = self::$enginemap[$engine][1];
  94
  95                 return;
  96             }
  97
  98             Core::warnMissingExtension(self::$enginemap[$engine][2]);
  99         }
 100
 101         /* Autodetection */
 102         foreach (self::$engineorder as $engine) {
 103             if (function_exists(self::$enginemap[$engine][0])) {
 104                 self::$engine = self::$enginemap[$engine][1];
 105
 106                 return;
 107             }
 108         }
 109
 110         /* Fallback to none conversion */
 111         self::$engine = self::ENGINE_NONE;
 112     }
 113
 114     /**
 115      * Setter for engine. Use with caution, mostly useful for testing.
 116      *
 117      * @param int $engine Engine encoding
 118      */
 119     public static function setEngine(int $engine): void
 120     {
 121         self::$engine = $engine;
 122     }
 123
 124     /**
 125      * Checks whether there is any charset conversion supported
 126      */
 127     public static function isSupported(): bool
 128     {
 129         if (self::$engine === null) {
 130             self::initEngine();
 131         }
 132
 133         return self::$engine != self::ENGINE_NONE;
 134     }
 135
 136     /**
 137      * Converts encoding of text according to parameters with detected
 138      * conversion function.
 139      *
 140      * @param string $srcCharset  source charset
 141      * @param string $destCharset target charset
 142      * @param string $what        what to convert
 143      *
 144      * @return string   converted text
 145      */
 146     public static function convertString(
 147         string $srcCharset,
 148         string $destCharset,
 149         string $what,
 150     ): string {
 151         if ($srcCharset === $destCharset) {
 152             return $what;
 153         }
 154
 155         if (self::$engine === null) {
 156             self::initEngine();
 157         }
 158
 159         return match (self::$engine) {
 160             self::ENGINE_ICONV => iconv(
 161                 $srcCharset,
 162                 $destCharset . (Config::getInstance()->settings['IconvExtraParams'] ?? ''), $what,
 163             ),
 164             self::ENGINE_MB => mb_convert_encoding($what, $destCharset, $srcCharset),
 165             default => $what,
 166         };
 167     }
 168
 169     /**
 170      * Detects whether Kanji encoding is available
 171      */
 172     public static function canConvertKanji(): bool
 173     {
 174         return $GLOBALS['lang'] === 'ja';
 175     }
 176
 177     /**
 178      * Setter for Kanji encodings. Use with caution, mostly useful for testing.
 179      */
 180     public static function getKanjiEncodings(): string
 181     {
 182         return self::$kanjiEncodings;
 183     }
 184
 185     /**
 186      * Setter for Kanji encodings. Use with caution, mostly useful for testing.
 187      *
 188      * @param string $value Kanji encodings list
 189      */
 190     public static function setKanjiEncodings(string $value): void
 191     {
 192         self::$kanjiEncodings = $value;
 193     }
 194
 195     /**
 196      * Reverses SJIS & EUC-JP position in the encoding codes list
 197      */
 198     public static function kanjiChangeOrder(): void
 199     {
 200         $parts = explode(',', self::$kanjiEncodings);
 201         if ($parts[1] === 'EUC-JP') {
 202             self::$kanjiEncodings = 'ASCII,SJIS,EUC-JP,JIS';
 203
 204             return;
 205         }
 206
 207         self::$kanjiEncodings = 'ASCII,EUC-JP,SJIS,JIS';
 208     }
 209
 210     /**
 211      * Kanji string encoding convert
 212      *
 213      * @param string $str  the string to convert
 214      * @param string $enc  the destination encoding code
 215      * @param string $kana set 'kana' convert to JIS-X208-kana
 216      *
 217      * @return string   the converted string
 218      */
 219     public static function kanjiStrConv(string $str, string $enc, string $kana): string
 220     {
 221         if ($enc === '' && $kana === '') {
 222             return $str;
 223         }
 224
 225         $stringEncoding = mb_detect_encoding($str, self::$kanjiEncodings);
 226         if ($stringEncoding === false) {
 227             $stringEncoding = 'utf-8';
 228         }
 229
 230         if ($kana === 'kana') {
 231             $dist = mb_convert_kana($str, 'KV', $stringEncoding);
 232             $str = $dist;
 233         }
 234
 235         if ($stringEncoding !== $enc && $enc !== '') {
 236             return mb_convert_encoding($str, $enc, $stringEncoding);
 237         }
 238
 239         return $str;
 240     }
 241
 242     /**
 243      * Kanji file encoding convert
 244      *
 245      * @param string $file the name of the file to convert
 246      * @param string $enc  the destination encoding code
 247      * @param string $kana set 'kana' convert to JIS-X208-kana
 248      *
 249      * @return string   the name of the converted file
 250      */
 251     public static function kanjiFileConv(string $file, string $enc, string $kana): string
 252     {
 253         if ($enc === '' && $kana === '') {
 254             return $file;
 255         }
 256
 257         $tmpfname = (string) tempnam(Config::getInstance()->getUploadTempDir(), $enc);
 258         $fpd = fopen($tmpfname, 'wb');
 259         if ($fpd === false) {
 260             return $file;
 261         }
 262
 263         $fps = fopen($file, 'r');
 264         if ($fps === false) {
 265             return $file;
 266         }
 267
 268         self::kanjiChangeOrder();
 269         while (! feof($fps)) {
 270             $line = fgets($fps, 4096);
 271             if ($line === false) {
 272                 continue;
 273             }
 274
 275             $dist = self::kanjiStrConv($line, $enc, $kana);
 276             fwrite($fpd, $dist);
 277         }
 278
 279         self::kanjiChangeOrder();
 280         fclose($fps);
 281         fclose($fpd);
 282         unlink($file);
 283
 284         return $tmpfname;
 285     }
 286
 287     /**
 288      * Defines radio form fields to switch between encoding modes
 289      *
 290      * @return string HTML code for the radio controls
 291      */
 292     public static function kanjiEncodingForm(): string
 293     {
 294         $template = new Template();
 295
 296         return $template->render('encoding/kanji_encoding_form');
 297     }
 298
 299     /**
 300      * Lists available encodings.
 301      *
 302      * @return mixed[]
 303      */
 304     public static function listEncodings(): array
 305     {
 306         if (self::$engine === null) {
 307             self::initEngine();
 308         }
 309
 310         /* Most engines do not support listing */
 311         $config = Config::getInstance();
 312         if (self::$engine != self::ENGINE_MB) {
 313             return $config->settings['AvailableCharsets'];
 314         }
 315
 316         return array_intersect(
 317             array_map(strtolower(...), mb_list_encodings()),
 318             $config->settings['AvailableCharsets'],
 319         );
 320     }
 321 }