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 struct grub_gettext_context main_context, secondary_context;
  38
  39 static const char *(*grub_gettext_original) (const char *s);
  40
  41 struct grub_gettext_msg
  42 {
  43   char *name;
  44   char *translated;
  45 };
  46
  47 struct header
  48 {
  49   grub_uint32_t magic;
  50   grub_uint32_t version;
  51   grub_uint32_t number_of_strings;
  52   grub_uint32_t offset_original;
  53   grub_uint32_t offset_translation;
  54 };
  55
  56 struct string_descriptor
  57 {
  58   grub_uint32_t length;
  59   grub_uint32_t offset;
  60 };
  61
  62 struct grub_gettext_context
  63 {
  64   grub_file_t fd_mo;
  65   grub_off_t grub_gettext_offset_original;
  66   grub_off_t grub_gettext_offset_translation;
  67   grub_size_t grub_gettext_max;
  68   int grub_gettext_max_log;
  69   struct grub_gettext_msg *grub_gettext_msg_list;
  70 };
  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
 359   /* Will try adding .gz as well.  */
 360   if (err)
 361     {
 362       char *mo_file_old;
 363       grub_errno = GRUB_ERR_NONE;
 364       mo_file_old = mo_file;
 365       mo_file = grub_xasprintf ("%s.gz", mo_file);
 366       grub_free (mo_file_old);
 367       if (!mo_file)
 368         return grub_errno;
 369       err = grub_mofile_open (ctx, mo_file);
 370     }
 371   return err;
 372 }
 373
 374 static grub_err_t
 375 grub_gettext_init_ext (struct grub_gettext_context *ctx,
 376                        const char *locale,
 377                        const char *locale_dir, const char *prefix)
 378 {
 379   const char *part1, *part2;
 380   grub_err_t err;
 381
 382   grub_gettext_delete_list (ctx);
 383
 384   if (!locale || locale[0] == 0)
 385     return 0;
 386
 387   part1 = locale_dir;
 388   part2 = "";
 389   if (!part1 || part1[0] == 0)
 390     {
 391       part1 = prefix;
 392       part2 = "/locale";
 393     }
 394
 395   if (!part1 || part1[0] == 0)
 396     return 0;
 397
 398   err = grub_mofile_open_lang (ctx, part1, part2, locale);
 399
 400   /* ll_CC didn't work, so try ll.  */
 401   if (err)
 402     {
 403       char *lang = grub_strdup (locale);
 404       char *underscore = lang ? grub_strchr (lang, '_') : 0;
 405
 406       if (underscore)
 407         {
 408           *underscore = '\0';
 409           grub_errno = GRUB_ERR_NONE;
 410           err = grub_mofile_open_lang (ctx, part1, part2, lang);
 411         }
 412
 413       grub_free (lang);
 414     }
 415   return err;
 416 }
 417
 418 static char *
 419 grub_gettext_env_write_lang (struct grub_env_var *var
 420                              __attribute__ ((unused)), const char *val)
 421 {
 422   grub_err_t err;
 423   err = grub_gettext_init_ext (&main_context, val, grub_env_get ("locale_dir"),
 424                                grub_env_get ("prefix"));
 425   if (err)
 426     grub_print_error ();
 427
 428   err = grub_gettext_init_ext (&secondary_context, val,
 429                                grub_env_get ("secondary_locale_dir"), 0);
 430   if (err)
 431     grub_print_error ();
 432
 433   return grub_strdup (val);
 434 }
 435
 436 void
 437 grub_gettext_reread_prefix (const char *val)
 438 {
 439   grub_err_t err;
 440   err = grub_gettext_init_ext (&main_context, grub_env_get ("lang"),
 441                                grub_env_get ("locale_dir"),
 442                                val);
 443   if (err)
 444     grub_print_error ();
 445 }
 446
 447 static char *
 448 read_main (struct grub_env_var *var
 449            __attribute__ ((unused)), const char *val)
 450 {
 451   grub_err_t err;
 452   err = grub_gettext_init_ext (&main_context, grub_env_get ("lang"), val,
 453                                grub_env_get ("prefix"));
 454   if (err)
 455     grub_print_error ();
 456   return grub_strdup (val);
 457 }
 458
 459 static char *
 460 read_secondary (struct grub_env_var *var
 461                 __attribute__ ((unused)), const char *val)
 462 {
 463   grub_err_t err;
 464   err = grub_gettext_init_ext (&secondary_context, grub_env_get ("lang"), val,
 465                                0);
 466   if (err)
 467     grub_print_error ();
 468
 469   return grub_strdup (val);
 470 }
 471
 472 static grub_err_t
 473 grub_cmd_translate (grub_command_t cmd __attribute__ ((unused)),
 474                     int argc, char **args)
 475 {
 476   if (argc != 1)
 477     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 478
 479   const char *translation;
 480   translation = grub_gettext_translate (args[0]);
 481   grub_printf ("%s\n", translation);
 482   return 0;
 483 }
 484
 485 GRUB_MOD_INIT (gettext)
 486 {
 487   const char *lang;
 488   grub_err_t err;
 489
 490   lang = grub_env_get ("lang");
 491
 492   err = grub_gettext_init_ext (&main_context, lang, grub_env_get ("locale_dir"),
 493                                grub_env_get ("prefix"));
 494   if (err)
 495     grub_print_error ();
 496   err = grub_gettext_init_ext (&secondary_context, lang,
 497                                grub_env_get ("secondary_locale_dir"), 0);
 498   if (err)
 499     grub_print_error ();
 500
 501   grub_register_variable_hook ("locale_dir", NULL, read_main);
 502   grub_register_variable_hook ("secondary_locale_dir", NULL, read_secondary);
 503
 504   grub_register_command_p1 ("gettext", grub_cmd_translate,
 505                             N_("STRING"),
 506                             /* TRANSLATORS: It refers to passing the string through gettext.
 507                                So it's "translate" in the same meaning as in what you're
 508                                doing now.
 509                              */
 510                             N_("Translates the string with the current settings."));
 511
 512   /* Reload .mo file information if lang changes.  */
 513   grub_register_variable_hook ("lang", NULL, grub_gettext_env_write_lang);
 514
 515   /* Preserve hooks after context changes.  */
 516   grub_env_export ("lang");
 517   grub_env_export ("locale_dir");
 518   grub_env_export ("secondary_locale_dir");
 519 }
 520
 521 GRUB_MOD_FINI (gettext)
 522 {
 523   grub_gettext_delete_list (&main_context);
 524   grub_gettext_delete_list (&secondary_context);
 525
 526   grub_gettext = grub_gettext_original;
 527 }