lib/charset.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  charset conversion utils
   4  *
   5  *  Copyright (c) 2017 Rob Clark
   6  */
   7
   8 #include <common.h>
   9 #include <charset.h>
  10 #include <capitalization.h>
  11 #include <cp437.h>
  12 #include <efi_loader.h>
  13 #include <errno.h>
  14 #include <malloc.h>
  15
  16 /**
  17  * codepage_437 - Unicode to codepage 437 translation table
  18  */
  19 const u16 codepage_437[128] = CP437;
  20
  21 static struct capitalization_table capitalization_table[] =
  22 #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
  23         UNICODE_CAPITALIZATION_TABLE;
  24 #elif CONFIG_FAT_DEFAULT_CODEPAGE == 1250
  25         CP1250_CAPITALIZATION_TABLE;
  26 #else
  27         CP437_CAPITALIZATION_TABLE;
  28 #endif
  29
  30 /**
  31  * get_code() - read Unicode code point from UTF-8 stream
  32  *
  33  * @read_u8:    - stream reader
  34  * @src:        - string buffer passed to stream reader, optional
  35  * Return:      - Unicode code point, or -1
  36  */
  37 static int get_code(u8 (*read_u8)(void *data), void *data)
  38 {
  39         s32 ch = 0;
  40
  41         ch = read_u8(data);
  42         if (!ch)
  43                 return 0;
  44         if (ch >= 0xc2 && ch <= 0xf4) {
  45                 int code = 0;
  46
  47                 if (ch >= 0xe0) {
  48                         if (ch >= 0xf0) {
  49                                 /* 0xf0 - 0xf4 */
  50                                 ch &= 0x07;
  51                                 code = ch << 18;
  52                                 ch = read_u8(data);
  53                                 if (ch < 0x80 || ch > 0xbf)
  54                                         goto error;
  55                                 ch &= 0x3f;
  56                         } else {
  57                                 /* 0xe0 - 0xef */
  58                                 ch &= 0x0f;
  59                         }
  60                         code += ch << 12;
  61                         if ((code >= 0xD800 && code <= 0xDFFF) ||
  62                             code >= 0x110000)
  63                                 goto error;
  64                         ch = read_u8(data);
  65                         if (ch < 0x80 || ch > 0xbf)
  66                                 goto error;
  67                 }
  68                 /* 0xc0 - 0xdf or continuation byte (0x80 - 0xbf) */
  69                 ch &= 0x3f;
  70                 code += ch << 6;
  71                 ch = read_u8(data);
  72                 if (ch < 0x80 || ch > 0xbf)
  73                         goto error;
  74                 ch &= 0x3f;
  75                 ch += code;
  76         } else if (ch >= 0x80) {
  77                 goto error;
  78         }
  79         return ch;
  80 error:
  81         return -1;
  82 }
  83
  84 /**
  85  * read_string() - read byte from character string
  86  *
  87  * @data:       - pointer to string
  88  * Return:      - byte read
  89  *
  90  * The string pointer is incremented if it does not point to '\0'.
  91  */
  92 static u8 read_string(void *data)
  93
  94 {
  95         const char **src = (const char **)data;
  96         u8 c;
  97
  98         if (!src || !*src || !**src)
  99                 return 0;
 100         c = **src;
 101         ++*src;
 102         return c;
 103 }
 104
 105 /**
 106  * read_console() - read byte from console
 107  *
 108  * @data        - not used, needed to match interface
 109  * Return:      - byte read or 0 on error
 110  */
 111 static u8 read_console(void *data)
 112 {
 113         int ch;
 114
 115         ch = getchar();
 116         if (ch < 0)
 117                 ch = 0;
 118         return ch;
 119 }
 120
 121 int console_read_unicode(s32 *code)
 122 {
 123         for (;;) {
 124                 s32 c;
 125
 126                 if (!tstc()) {
 127                         /* No input available */
 128                         return 1;
 129                 }
 130
 131                 /* Read Unicode code */
 132                 c = get_code(read_console, NULL);
 133                 if (c > 0) {
 134                         *code = c;
 135                         return 0;
 136                 }
 137         }
 138 }
 139
 140 s32 utf8_get(const char **src)
 141 {
 142         return get_code(read_string, src);
 143 }
 144
 145 int utf8_put(s32 code, char **dst)
 146 {
 147         if (!dst || !*dst)
 148                 return -1;
 149         if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
 150                 return -1;
 151         if (code <= 0x007F) {
 152                 **dst = code;
 153         } else {
 154                 if (code <= 0x07FF) {
 155                         **dst = code >> 6 | 0xC0;
 156                 } else {
 157                         if (code < 0x10000) {
 158                                 **dst = code >> 12 | 0xE0;
 159                         } else {
 160                                 **dst = code >> 18 | 0xF0;
 161                                 ++*dst;
 162                                 **dst = (code >> 12 & 0x3F) | 0x80;
 163                         }
 164                         ++*dst;
 165                         **dst = (code >> 6 & 0x3F) | 0x80;
 166                 }
 167                 ++*dst;
 168                 **dst = (code & 0x3F) | 0x80;
 169         }
 170         ++*dst;
 171         return 0;
 172 }
 173
 174 size_t utf8_utf16_strnlen(const char *src, size_t count)
 175 {
 176         size_t len = 0;
 177
 178         for (; *src && count; --count)  {
 179                 s32 code = utf8_get(&src);
 180
 181                 if (!code)
 182                         break;
 183                 if (code < 0) {
 184                         /* Reserve space for a replacement character */
 185                         len += 1;
 186                 } else if (code < 0x10000) {
 187                         len += 1;
 188                 } else {
 189                         len += 2;
 190                 }
 191         }
 192         return len;
 193 }
 194
 195 int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count)
 196 {
 197         if (!src || !dst || !*dst)
 198                 return -1;
 199
 200         for (; count && *src; --count) {
 201                 s32 code = utf8_get(&src);
 202
 203                 if (code < 0)
 204                         code = '?';
 205                 utf16_put(code, dst);
 206         }
 207         **dst = 0;
 208         return 0;
 209 }
 210
 211 s32 utf16_get(const u16 **src)
 212 {
 213         s32 code, code2;
 214
 215         if (!src || !*src)
 216                 return -1;
 217         if (!**src)
 218                 return 0;
 219         code = **src;
 220         ++*src;
 221         if (code >= 0xDC00 && code <= 0xDFFF)
 222                 return -1;
 223         if (code >= 0xD800 && code <= 0xDBFF) {
 224                 if (!**src)
 225                         return -1;
 226                 code &= 0x3ff;
 227                 code <<= 10;
 228                 code += 0x10000;
 229                 code2 = **src;
 230                 ++*src;
 231                 if (code2 <= 0xDC00 || code2 >= 0xDFFF)
 232                         return -1;
 233                 code2 &= 0x3ff;
 234                 code += code2;
 235         }
 236         return code;
 237 }
 238
 239 int utf16_put(s32 code, u16 **dst)
 240 {
 241         if (!dst || !*dst)
 242                 return -1;
 243         if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
 244                 return -1;
 245         if (code < 0x10000) {
 246                 **dst = code;
 247         } else {
 248                 code -= 0x10000;
 249                 **dst = code >> 10 | 0xD800;
 250                 ++*dst;
 251                 **dst = (code & 0x3ff) | 0xDC00;
 252         }
 253         ++*dst;
 254         return 0;
 255 }
 256
 257 size_t utf16_strnlen(const u16 *src, size_t count)
 258 {
 259         size_t len = 0;
 260
 261         for (; *src && count; --count)  {
 262                 s32 code = utf16_get(&src);
 263
 264                 if (!code)
 265                         break;
 266                 /*
 267                  * In case of an illegal sequence still reserve space for a
 268                  * replacement character.
 269                  */
 270                 ++len;
 271         }
 272         return len;
 273 }
 274
 275 size_t utf16_utf8_strnlen(const u16 *src, size_t count)
 276 {
 277         size_t len = 0;
 278
 279         for (; *src && count; --count)  {
 280                 s32 code = utf16_get(&src);
 281
 282                 if (!code)
 283                         break;
 284                 if (code < 0)
 285                         /* Reserve space for a replacement character */
 286                         len += 1;
 287                 else if (code < 0x80)
 288                         len += 1;
 289                 else if (code < 0x800)
 290                         len += 2;
 291                 else if (code < 0x10000)
 292                         len += 3;
 293                 else
 294                         len += 4;
 295         }
 296         return len;
 297 }
 298
 299 int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count)
 300 {
 301         if (!src || !dst || !*dst)
 302                 return -1;
 303
 304         for (; count && *src; --count) {
 305                 s32 code = utf16_get(&src);
 306
 307                 if (code < 0)
 308                         code = '?';
 309                 utf8_put(code, dst);
 310         }
 311         **dst = 0;
 312         return 0;
 313 }
 314
 315 s32 utf_to_lower(const s32 code)
 316 {
 317         struct capitalization_table *pos = capitalization_table;
 318         s32 ret = code;
 319
 320         if (code <= 0x7f) {
 321                 if (code >= 'A' && code <= 'Z')
 322                         ret += 0x20;
 323                 return ret;
 324         }
 325         for (; pos->upper; ++pos) {
 326                 if (pos->upper == code) {
 327                         ret = pos->lower;
 328                         break;
 329                 }
 330         }
 331         return ret;
 332 }
 333
 334 s32 utf_to_upper(const s32 code)
 335 {
 336         struct capitalization_table *pos = capitalization_table;
 337         s32 ret = code;
 338
 339         if (code <= 0x7f) {
 340                 if (code >= 'a' && code <= 'z')
 341                         ret -= 0x20;
 342                 return ret;
 343         }
 344         for (; pos->lower; ++pos) {
 345                 if (pos->lower == code) {
 346                         ret = pos->upper;
 347                         break;
 348                 }
 349         }
 350         return ret;
 351 }
 352
 353 /*
 354  * u16_strncmp() - compare two u16 string
 355  *
 356  * @s1:         first string to compare
 357  * @s2:         second string to compare
 358  * @n:          maximum number of u16 to compare
 359  * Return:      0  if the first n u16 are the same in s1 and s2
 360  *              < 0 if the first different u16 in s1 is less than the
 361  *              corresponding u16 in s2
 362  *              > 0 if the first different u16 in s1 is greater than the
 363  *              corresponding u16 in s2
 364  */
 365 int u16_strncmp(const u16 *s1, const u16 *s2, size_t n)
 366 {
 367         int ret = 0;
 368
 369         for (; n; --n, ++s1, ++s2) {
 370                 ret = *s1 - *s2;
 371                 if (ret || !*s1)
 372                         break;
 373         }
 374
 375         return ret;
 376 }
 377
 378 size_t __efi_runtime u16_strnlen(const u16 *in, size_t count)
 379 {
 380         size_t i;
 381         for (i = 0; count-- && in[i]; i++);
 382         return i;
 383 }
 384
 385 size_t u16_strsize(const void *in)
 386 {
 387         return (u16_strlen(in) + 1) * sizeof(u16);
 388 }
 389
 390 u16 *u16_strcpy(u16 *dest, const u16 *src)
 391 {
 392         u16 *tmp = dest;
 393
 394         for (;; dest++, src++) {
 395                 *dest = *src;
 396                 if (!*src)
 397                         break;
 398         }
 399
 400         return tmp;
 401 }
 402
 403 u16 *u16_strdup(const void *src)
 404 {
 405         u16 *new;
 406         size_t len;
 407
 408         if (!src)
 409                 return NULL;
 410         len = u16_strsize(src);
 411         new = malloc(len);
 412         if (!new)
 413                 return NULL;
 414         memcpy(new, src, len);
 415
 416         return new;
 417 }
 418
 419 size_t u16_strlcat(u16 *dest, const u16 *src, size_t count)
 420 {
 421         size_t destlen = u16_strlen(dest);
 422         size_t srclen = u16_strlen(src);
 423         size_t ret = destlen + srclen + 1;
 424
 425         if (destlen >= count)
 426                 return ret;
 427         if (ret > count)
 428                 srclen -= ret - count;
 429         memcpy(&dest[destlen], src, 2 * srclen);
 430         dest[destlen + srclen] = 0x0000;
 431
 432         return ret;
 433 }
 434
 435 /* Convert UTF-16 to UTF-8.  */
 436 uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
 437 {
 438         uint32_t code_high = 0;
 439
 440         while (size--) {
 441                 uint32_t code = *src++;
 442
 443                 if (code_high) {
 444                         if (code >= 0xDC00 && code <= 0xDFFF) {
 445                                 /* Surrogate pair.  */
 446                                 code = ((code_high - 0xD800) << 10) + (code - 0xDC00) + 0x10000;
 447
 448                                 *dest++ = (code >> 18) | 0xF0;
 449                                 *dest++ = ((code >> 12) & 0x3F) | 0x80;
 450                                 *dest++ = ((code >> 6) & 0x3F) | 0x80;
 451                                 *dest++ = (code & 0x3F) | 0x80;
 452                         } else {
 453                                 /* Error...  */
 454                                 *dest++ = '?';
 455                                 /* *src may be valid. Don't eat it.  */
 456                                 src--;
 457                         }
 458
 459                         code_high = 0;
 460                 } else {
 461                         if (code <= 0x007F) {
 462                                 *dest++ = code;
 463                         } else if (code <= 0x07FF) {
 464                                 *dest++ = (code >> 6) | 0xC0;
 465                                 *dest++ = (code & 0x3F) | 0x80;
 466                         } else if (code >= 0xD800 && code <= 0xDBFF) {
 467                                 code_high = code;
 468                                 continue;
 469                         } else if (code >= 0xDC00 && code <= 0xDFFF) {
 470                                 /* Error... */
 471                                 *dest++ = '?';
 472                         } else if (code < 0x10000) {
 473                                 *dest++ = (code >> 12) | 0xE0;
 474                                 *dest++ = ((code >> 6) & 0x3F) | 0x80;
 475                                 *dest++ = (code & 0x3F) | 0x80;
 476                         } else {
 477                                 *dest++ = (code >> 18) | 0xF0;
 478                                 *dest++ = ((code >> 12) & 0x3F) | 0x80;
 479                                 *dest++ = ((code >> 6) & 0x3F) | 0x80;
 480                                 *dest++ = (code & 0x3F) | 0x80;
 481                         }
 482                 }
 483         }
 484
 485         return dest;
 486 }
 487
 488 int utf_to_cp(s32 *c, const u16 *codepage)
 489 {
 490         if (*c >= 0x80) {
 491                 int j;
 492
 493                 /* Look up codepage translation */
 494                 for (j = 0; j < 0x80; ++j) {
 495                         if (*c == codepage[j]) {
 496                                 *c = j + 0x80;
 497                                 return 0;
 498                         }
 499                 }
 500                 *c = '?';
 501                 return -ENOENT;
 502         }
 503         return 0;
 504 }
 505
 506 int utf8_to_cp437_stream(u8 c, char *buffer)
 507 {
 508         char *end;
 509         const char *pos;
 510         s32 s;
 511         int ret;
 512
 513         for (;;) {
 514                 pos = buffer;
 515                 end = buffer + strlen(buffer);
 516                 *end++ = c;
 517                 *end = 0;
 518                 s = utf8_get(&pos);
 519                 if (s > 0) {
 520                         *buffer = 0;
 521                         ret = utf_to_cp(&s, codepage_437);
 522                         return s;
 523                         }
 524                 if (pos == end)
 525                         return 0;
 526                 *buffer = 0;
 527         }
 528 }
 529
 530 int utf8_to_utf32_stream(u8 c, char *buffer)
 531 {
 532         char *end;
 533         const char *pos;
 534         s32 s;
 535
 536         for (;;) {
 537                 pos = buffer;
 538                 end = buffer + strlen(buffer);
 539                 *end++ = c;
 540                 *end = 0;
 541                 s = utf8_get(&pos);
 542                 if (s > 0) {
 543                         *buffer = 0;
 544                         return s;
 545                 }
 546                 if (pos == end)
 547                         return 0;
 548                 *buffer = 0;
 549         }
 550 }