arch/all-pc/boot/grub2-aros/grub-core/gettext/gettext.c

   1 /* gettext.c - gettext module */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2009 Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/types.h>
  21 #include <grub/misc.h>
  22 #include <grub/mm.h>
  23 #include <grub/err.h>
  24 #include <grub/dl.h>
  25 #include <grub/normal.h>
  26 #include <grub/file.h>
  27 #include <grub/kernel.h>
  28 #include <grub/i18n.h>
  29
  30 GRUB_MOD_LICENSE ("GPLv3+");
  31
  32 /*
  33    .mo file information from:
  34    http://www.gnu.org/software/autoconf/manual/gettext/MO-Files.html .
  35 */
  36
  37 static const char *(*grub_gettext_original) (const char *s);
  38
  39 struct grub_gettext_msg
  40 {
  41   char *name;
  42   char *translated;
  43 };
  44
  45 struct header
  46 {
  47   grub_uint32_t magic;
  48   grub_uint32_t version;
  49   grub_uint32_t number_of_strings;
  50   grub_uint32_t offset_original;
  51   grub_uint32_t offset_translation;
  52 };
  53
  54 struct string_descriptor
  55 {
  56   grub_uint32_t length;
  57   grub_uint32_t offset;
  58 };
  59
  60 struct grub_gettext_context
  61 {
  62   grub_file_t fd_mo;
  63   grub_off_t grub_gettext_offset_original;
  64   grub_off_t grub_gettext_offset_translation;
  65   grub_size_t grub_gettext_max;
  66   int grub_gettext_max_log;
  67   struct grub_gettext_msg *grub_gettext_msg_list;
  68 };
  69
  70 static struct grub_gettext_context main_context, secondary_context;
  71
  72 #define MO_MAGIC_NUMBER                 0x950412de
  73
  74 static grub_err_t
  75 grub_gettext_pread (grub_file_t file, void *buf, grub_size_t len,
  76                     grub_off_t offset)
  77 {
  78   if (len == 0)
  79     return GRUB_ERR_NONE;
  80   if (grub_file_seek (file, offset) == (grub_off_t) - 1)
  81     return grub_errno;
  82   if (grub_file_read (file, buf, len) != (grub_ssize_t) len)
  83     {
  84       if (!grub_errno)
  85         grub_error (GRUB_ERR_READ_ERROR, N_("premature end of file"));
  86       return grub_errno;
  87     }
  88   return GRUB_ERR_NONE;
  89 }
  90
  91 static char *
  92 grub_gettext_getstr_from_position (struct grub_gettext_context *ctx,
  93                                    grub_off_t off,
  94                                    grub_size_t position)
  95 {
  96   grub_off_t internal_position;
  97   grub_size_t length;
  98   grub_off_t offset;
  99   char *translation;
 100   struct string_descriptor desc;
 101   grub_err_t err;
 102
 103   internal_position = (off + position * sizeof (desc));
 104
 105   err = grub_gettext_pread (ctx->fd_mo, (char *) &desc,
 106                             sizeof (desc), internal_position);
 107   if (err)
 108     return NULL;
 109   length = grub_cpu_to_le32 (desc.length);
 110   offset = grub_cpu_to_le32 (desc.offset);
 111
 112   translation = grub_malloc (length + 1);
 113   if (!translation)
 114     return NULL;
 115
 116   err = grub_gettext_pread (ctx->fd_mo, translation, length, offset);
 117   if (err)
 118     {
 119       grub_free (translation);
 120       return NULL;
 121     }
 122   translation[length] = '\0';
 123
 124   return translation;
 125 }
 126
 127 static const char *
 128 grub_gettext_gettranslation_from_position (struct grub_gettext_context *ctx,
 129                                            grub_size_t position)
 130 {
 131   if (!ctx->grub_gettext_msg_list[position].translated)
 132     ctx->grub_gettext_msg_list[position].translated
 133       = grub_gettext_getstr_from_position (ctx,
 134                                            ctx->grub_gettext_offset_translation,
 135                                            position);
 136   return ctx->grub_gettext_msg_list[position].translated;
 137 }
 138
 139 static const char *
 140 grub_gettext_getstring_from_position (struct grub_gettext_context *ctx,
 141                                       grub_size_t position)
 142 {
 143   if (!ctx->grub_gettext_msg_list[position].name)
 144     ctx->grub_gettext_msg_list[position].name
 145       = grub_gettext_getstr_from_position (ctx,
 146                                            ctx->grub_gettext_offset_original,
 147                                            position);
 148   return ctx->grub_gettext_msg_list[position].name;
 149 }
 150
 151 static const char *
 152 grub_gettext_translate_real (struct grub_gettext_context *ctx,
 153                              const char *orig)
 154 {
 155   grub_size_t current = 0;
 156   int i;
 157   const char *current_string;
 158   static int depth = 0;
 159
 160   if (!ctx->grub_gettext_msg_list || !ctx->fd_mo)
 161     return NULL;
 162
 163   /* Shouldn't happen. Just a precaution if our own code
 164      calls gettext somehow.  */
 165   if (depth > 2)
 166     return NULL;
 167   depth++;
 168
 169   /* Make sure we can use grub_gettext_translate for error messages.  Push
 170      active error message to error stack and reset error message.  */
 171   grub_error_push ();
 172
 173   for (i = ctx->grub_gettext_max_log; i >= 0; i--)
 174     {
 175       grub_size_t test;
 176       int cmp;
 177
 178       test = current | (1 << i);
 179       if (test >= ctx->grub_gettext_max)
 180         continue;
 181
 182       current_string = grub_gettext_getstring_from_position (ctx, test);
 183
 184       if (!current_string)
 185         {
 186           grub_errno = GRUB_ERR_NONE;
 187           grub_error_pop ();
 188           depth--;
 189           return NULL;
 190         }
 191
 192       /* Search by bisection.  */
 193       cmp = grub_strcmp (current_string, orig);
 194       if (cmp <= 0)
 195         current = test;
 196       if (cmp == 0)
 197         {
 198           const char *ret = 0;
 199           ret = grub_gettext_gettranslation_from_position (ctx, current);
 200           if (!ret)
 201             {
 202               grub_errno = GRUB_ERR_NONE;
 203               grub_error_pop ();
 204               depth--;
 205               return NULL;
 206             }
 207           grub_error_pop ();
 208           depth--;
 209           return ret;
 210         }
 211     }
 212
 213   if (current == 0 && ctx->grub_gettext_max != 0)
 214     {
 215       current_string = grub_gettext_getstring_from_position (ctx, 0);
 216
 217       if (!current_string)
 218         {
 219           grub_errno = GRUB_ERR_NONE;
 220           grub_error_pop ();
 221           depth--;
 222           return NULL;
 223         }
 224
 225       if (grub_strcmp (current_string, orig) == 0)
 226         {
 227           const char *ret = 0;
 228           ret = grub_gettext_gettranslation_from_position (ctx, current);
 229           if (!ret)
 230             {
 231               grub_errno = GRUB_ERR_NONE;
 232               grub_error_pop ();
 233               depth--;
 234               return NULL;
 235             }
 236           grub_error_pop ();
 237           depth--;
 238           return ret;
 239         }
 240     }
 241
 242   grub_error_pop ();
 243   depth--;
 244   return NULL;
 245 }
 246
 247 static const char *
 248 grub_gettext_translate (const char *orig)
 249 {
 250   const char *ret;
 251   if (orig[0] == 0)
 252     return orig;
 253
 254   ret = grub_gettext_translate_real (&main_context, orig);
 255   if (ret)
 256     return ret;
 257   ret = grub_gettext_translate_real (&secondary_context, orig);
 258   if (ret)
 259     return ret;
 260   return orig;
 261 }
 262
 263 static void
 264 grub_gettext_delete_list (struct grub_gettext_context *ctx)
 265 {
 266   struct grub_gettext_msg *l = ctx->grub_gettext_msg_list;
 267   grub_size_t i;
 268
 269   if (!l)
 270     return;
 271   ctx->grub_gettext_msg_list = 0;
 272   for (i = 0; i < ctx->grub_gettext_max; i++)
 273     grub_free (l[i].name);
 274   /* Don't delete the translated message because could be in use.  */
 275   grub_free (l);
 276   if (ctx->fd_mo)
 277     grub_file_close (ctx->fd_mo);
 278   ctx->fd_mo = 0;
 279   grub_memset (ctx, 0, sizeof (*ctx));
 280 }
 281
 282 /* This is similar to grub_file_open. */
 283 static grub_err_t
 284 grub_mofile_open (struct grub_gettext_context *ctx,
 285                   const char *filename)
 286 {
 287   struct header head;
 288   grub_err_t err;
 289   grub_file_t fd;
 290
 291   /* Using fd_mo and not another variable because
 292      it's needed for grub_gettext_get_info.  */
 293
 294   fd = grub_file_open (filename);
 295
 296   if (!fd)
 297     return grub_errno;
 298
 299   err = grub_gettext_pread (fd, &head, sizeof (head), 0);
 300   if (err)
 301     {
 302       grub_file_close (fd);
 303       return err;
 304     }
 305
 306   if (head.magic != grub_cpu_to_le32_compile_time (MO_MAGIC_NUMBER))
 307     {
 308       grub_file_close (fd);
 309       return grub_error (GRUB_ERR_BAD_FILE_TYPE,
 310                          "mo: invalid mo magic in file: %s", filename);
 311     }
 312
 313   if (head.version != 0)
 314     {
 315       grub_file_close (fd);
 316       return grub_error (GRUB_ERR_BAD_FILE_TYPE,
 317                          "mo: invalid mo version in file: %s", filename);
 318     }
 319
 320   ctx->grub_gettext_offset_original = grub_le_to_cpu32 (head.offset_original);
 321   ctx->grub_gettext_offset_translation = grub_le_to_cpu32 (head.offset_translation);
 322   ctx->grub_gettext_max = grub_le_to_cpu32 (head.number_of_strings);
 323   for (ctx->grub_gettext_max_log = 0; ctx->grub_gettext_max >> ctx->grub_gettext_max_log;
 324        ctx->grub_gettext_max_log++);
 325
 326   ctx->grub_gettext_msg_list = grub_zalloc (ctx->grub_gettext_max
 327                                             * sizeof (ctx->grub_gettext_msg_list[0]));
 328   if (!ctx->grub_gettext_msg_list)
 329     {
 330       grub_file_close (fd);
 331       return grub_errno;
 332     }
 333   ctx->fd_mo = fd;
 334   if (grub_gettext != grub_gettext_translate)
 335     {
 336       grub_gettext_original = grub_gettext;
 337       grub_gettext = grub_gettext_translate;
 338     }
 339   return 0;
 340 }
 341
 342 /* Returning grub_file_t would be more natural, but grub_mofile_open assigns
 343    to fd_mo anyway ...  */
 344 static grub_err_t
 345 grub_mofile_open_lang (struct grub_gettext_context *ctx,
 346                        const char *part1, const char *part2, const char *locale)
 347 {
 348   char *mo_file;
 349   grub_err_t err;
 350
 351   /* mo_file e.g.: /boot/grub/locale/ca.mo   */
 352
 353   mo_file = grub_xasprintf ("%s%s/%s.mo", part1, part2, locale);
 354   if (!mo_file)
 355     return grub_errno;
 356
 357   err = grub_mofile_open (ctx, mo_file);
 358   grub_free (mo_file);
 359
 360   /* Will try adding .gz as well.  */
 361   if (err)
 362     {
 363       grub_errno = GRUB_ERR_NONE;
 364       mo_file = grub_xasprintf ("%s%s/%s.mo.gz", part1, part2, locale);
 365       if (!mo_file)
 366         return grub_errno;
 367       err = grub_mofile_open (ctx, mo_file);
 368       grub_free (mo_file);
 369     }
 370
 371   /* Will try adding .gmo as well.  */
 372   if (err)
 373     {
 374       grub_errno = GRUB_ERR_NONE;
 375       mo_file = grub_xasprintf ("%s%s/%s.gmo", part1, part2, locale);
 376       if (!mo_file)
 377         return grub_errno;
 378       err = grub_mofile_open (ctx, mo_file);
 379       grub_free (mo_file);
 380     }
 381
 382   return err;
 383 }
 384
 385 static grub_err_t
 386 grub_gettext_init_ext (struct grub_gettext_context *ctx,
 387                        const char *locale,
 388                        const char *locale_dir, const char *prefix)
 389 {
 390   const char *part1, *part2;
 391   grub_err_t err;
 392
 393   grub_gettext_delete_list (ctx);
 394
 395   if (!locale || locale[0] == 0)
 396     return 0;
 397
 398   part1 = locale_dir;
 399   part2 = "";
 400   if (!part1 || part1[0] == 0)
 401     {
 402       part1 = prefix;
 403       part2 = "/locale";
 404     }
 405
 406   if (!part1 || part1[0] == 0)
 407     return 0;
 408
 409   err = grub_mofile_open_lang (ctx, part1, part2, locale);
 410
 411   /* ll_CC didn't work, so try ll.  */
 412   if (err)
 413     {
 414       char *lang = grub_strdup (locale);
 415       char *underscore = lang ? grub_strchr (lang, '_') : 0;
 416
 417       if (underscore)
 418         {
 419           *underscore = '\0';
 420           grub_errno = GRUB_ERR_NONE;
 421           err = grub_mofile_open_lang (ctx, part1, part2, lang);
 422         }
 423
 424       grub_free (lang);
 425     }
 426
 427   if (locale[0] == 'e' && locale[1] == 'n'
 428       && (locale[2] == '\0' || locale[2] == '_'))
 429     grub_errno = err = GRUB_ERR_NONE;
 430   return err;
 431 }
 432
 433 static char *
 434 grub_gettext_env_write_lang (struct grub_env_var *var
 435                              __attribute__ ((unused)), const char *val)
 436 {
 437   grub_err_t err;
 438   err = grub_gettext_init_ext (&main_context, val, grub_env_get ("locale_dir"),
 439                                grub_env_get ("prefix"));
 440   if (err)
 441     grub_print_error ();
 442
 443   err = grub_gettext_init_ext (&secondary_context, val,
 444                                grub_env_get ("secondary_locale_dir"), 0);
 445   if (err)
 446     grub_print_error ();
 447
 448   return grub_strdup (val);
 449 }
 450
 451 void
 452 grub_gettext_reread_prefix (const char *val)
 453 {
 454   grub_err_t err;
 455   err = grub_gettext_init_ext (&main_context, grub_env_get ("lang"),
 456                                grub_env_get ("locale_dir"),
 457                                val);
 458   if (err)
 459     grub_print_error ();
 460 }
 461
 462 static char *
 463 read_main (struct grub_env_var *var
 464            __attribute__ ((unused)), const char *val)
 465 {
 466   grub_err_t err;
 467   err = grub_gettext_init_ext (&main_context, grub_env_get ("lang"), val,
 468                                grub_env_get ("prefix"));
 469   if (err)
 470     grub_print_error ();
 471   return grub_strdup (val);
 472 }
 473
 474 static char *
 475 read_secondary (struct grub_env_var *var
 476                 __attribute__ ((unused)), const char *val)
 477 {
 478   grub_err_t err;
 479   err = grub_gettext_init_ext (&secondary_context, grub_env_get ("lang"), val,
 480                                0);
 481   if (err)
 482     grub_print_error ();
 483
 484   return grub_strdup (val);
 485 }
 486
 487 static grub_err_t
 488 grub_cmd_translate (grub_command_t cmd __attribute__ ((unused)),
 489                     int argc, char **args)
 490 {
 491   if (argc != 1)
 492     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 493
 494   const char *translation;
 495   translation = grub_gettext_translate (args[0]);
 496   grub_printf ("%s\n", translation);
 497   return 0;
 498 }
 499
 500 GRUB_MOD_INIT (gettext)
 501 {
 502   const char *lang;
 503   grub_err_t err;
 504
 505   lang = grub_env_get ("lang");
 506
 507   err = grub_gettext_init_ext (&main_context, lang, grub_env_get ("locale_dir"),
 508                                grub_env_get ("prefix"));
 509   if (err)
 510     grub_print_error ();
 511   err = grub_gettext_init_ext (&secondary_context, lang,
 512                                grub_env_get ("secondary_locale_dir"), 0);
 513   if (err)
 514     grub_print_error ();
 515
 516   grub_register_variable_hook ("locale_dir", NULL, read_main);
 517   grub_register_variable_hook ("secondary_locale_dir", NULL, read_secondary);
 518
 519   grub_register_command_p1 ("gettext", grub_cmd_translate,
 520                             N_("STRING"),
 521                             /* TRANSLATORS: It refers to passing the string through gettext.
 522                                So it's "translate" in the same meaning as in what you're
 523                                doing now.
 524                              */
 525                             N_("Translates the string with the current settings."));
 526
 527   /* Reload .mo file information if lang changes.  */
 528   grub_register_variable_hook ("lang", NULL, grub_gettext_env_write_lang);
 529
 530   /* Preserve hooks after context changes.  */
 531   grub_env_export ("lang");
 532   grub_env_export ("locale_dir");
 533   grub_env_export ("secondary_locale_dir");
 534 }
 535
 536 GRUB_MOD_FINI (gettext)
 537 {
 538   grub_gettext_delete_list (&main_context);
 539   grub_gettext_delete_list (&secondary_context);
 540
 541   grub_gettext = grub_gettext_original;
 542 }