grub-core/kern/misc.c

   1 /* misc.c - definitions of misc functions */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010  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/misc.h>
  21 #include <grub/err.h>
  22 #include <grub/mm.h>
  23 #include <stdarg.h>
  24 #include <grub/term.h>
  25 #include <grub/env.h>
  26 #include <grub/i18n.h>
  27
  28 union printf_arg
  29 {
  30   /* Yes, type is also part of union as the moment we fill the value
  31      we don't need to store its type anymore (when we'll need it, we'll
  32      have format spec again. So save some space.  */
  33   enum
  34     {
  35       INT, LONG, LONGLONG,
  36       UNSIGNED_INT = 3, UNSIGNED_LONG, UNSIGNED_LONGLONG,
  37       STRING
  38     } type;
  39   long long ll;
  40 };
  41
  42 struct printf_args
  43 {
  44   union printf_arg prealloc[32];
  45   union printf_arg *ptr;
  46   grub_size_t count;
  47 };
  48
  49 static void
  50 parse_printf_args (const char *fmt0, struct printf_args *args,
  51                    va_list args_in);
  52 static int
  53 grub_vsnprintf_real (char *str, grub_size_t max_len, const char *fmt0,
  54                      struct printf_args *args);
  55
  56 static void
  57 free_printf_args (struct printf_args *args)
  58 {
  59   if (args->ptr != args->prealloc)
  60     grub_free (args->ptr);
  61 }
  62
  63 static int
  64 grub_iswordseparator (int c)
  65 {
  66   return (grub_isspace (c) || c == ',' || c == ';' || c == '|' || c == '&');
  67 }
  68
  69 /* grub_gettext_dummy is not translating anything.  */
  70 static const char *
  71 grub_gettext_dummy (const char *s)
  72 {
  73   return s;
  74 }
  75
  76 const char* (*grub_gettext) (const char *s) = grub_gettext_dummy;
  77
  78 void *
  79 grub_memmove (void *dest, const void *src, grub_size_t n)
  80 {
  81   char *d = (char *) dest;
  82   const char *s = (const char *) src;
  83
  84   if (d < s)
  85     while (n--)
  86       *d++ = *s++;
  87   else
  88     {
  89       d += n;
  90       s += n;
  91
  92       while (n--)
  93         *--d = *--s;
  94     }
  95
  96   return dest;
  97 }
  98
  99 char *
 100 grub_strcpy (char *dest, const char *src)
 101 {
 102   char *p = dest;
 103
 104   while ((*p++ = *src++) != '\0')
 105     ;
 106
 107   return dest;
 108 }
 109
 110 int
 111 grub_printf (const char *fmt, ...)
 112 {
 113   va_list ap;
 114   int ret;
 115
 116   va_start (ap, fmt);
 117   ret = grub_vprintf (fmt, ap);
 118   va_end (ap);
 119
 120   return ret;
 121 }
 122
 123 int
 124 grub_printf_ (const char *fmt, ...)
 125 {
 126   va_list ap;
 127   int ret;
 128
 129   va_start (ap, fmt);
 130   ret = grub_vprintf (_(fmt), ap);
 131   va_end (ap);
 132
 133   return ret;
 134 }
 135
 136 int
 137 grub_puts_ (const char *s)
 138 {
 139   return grub_puts (_(s));
 140 }
 141
 142 #if defined (__APPLE__) && ! defined (GRUB_UTIL)
 143 int
 144 grub_err_printf (const char *fmt, ...)
 145 {
 146         va_list ap;
 147         int ret;
 148
 149         va_start (ap, fmt);
 150         ret = grub_vprintf (fmt, ap);
 151         va_end (ap);
 152
 153         return ret;
 154 }
 155 #endif
 156
 157 #if ! defined (__APPLE__) && ! defined (GRUB_UTIL)
 158 int grub_err_printf (const char *fmt, ...)
 159 __attribute__ ((alias("grub_printf")));
 160 #endif
 161
 162 int
 163 grub_debug_enabled (const char * condition)
 164 {
 165   const char *debug;
 166
 167   debug = grub_env_get ("debug");
 168   if (!debug)
 169     return 0;
 170
 171   if (grub_strword (debug, "all") || grub_strword (debug, condition))
 172     return 1;
 173
 174   return 0;
 175 }
 176
 177 void
 178 grub_real_dprintf (const char *file, const int line, const char *condition,
 179                    const char *fmt, ...)
 180 {
 181   va_list args;
 182
 183   if (grub_debug_enabled (condition))
 184     {
 185       grub_printf ("%s:%d: ", file, line);
 186       va_start (args, fmt);
 187       grub_vprintf (fmt, args);
 188       va_end (args);
 189       grub_refresh ();
 190     }
 191 }
 192
 193 #define PREALLOC_SIZE 255
 194
 195 int
 196 grub_vprintf (const char *fmt, va_list ap)
 197 {
 198   grub_size_t s;
 199   static char buf[PREALLOC_SIZE + 1];
 200   char *curbuf = buf;
 201   struct printf_args args;
 202
 203   parse_printf_args (fmt, &args, ap);
 204
 205   s = grub_vsnprintf_real (buf, PREALLOC_SIZE, fmt, &args);
 206   if (s > PREALLOC_SIZE)
 207     {
 208       curbuf = grub_malloc (s + 1);
 209       if (!curbuf)
 210         {
 211           grub_errno = GRUB_ERR_NONE;
 212           buf[PREALLOC_SIZE - 3] = '.';
 213           buf[PREALLOC_SIZE - 2] = '.';
 214           buf[PREALLOC_SIZE - 1] = '.';
 215           buf[PREALLOC_SIZE] = 0;
 216           curbuf = buf;
 217         }
 218       else
 219         s = grub_vsnprintf_real (curbuf, s, fmt, &args);
 220     }
 221
 222   free_printf_args (&args);
 223
 224   grub_xputs (curbuf);
 225
 226   if (curbuf != buf)
 227     grub_free (curbuf);
 228
 229   return s;
 230 }
 231
 232 int
 233 grub_memcmp (const void *s1, const void *s2, grub_size_t n)
 234 {
 235   const grub_uint8_t *t1 = s1;
 236   const grub_uint8_t *t2 = s2;
 237
 238   while (n--)
 239     {
 240       if (*t1 != *t2)
 241         return (int) *t1 - (int) *t2;
 242
 243       t1++;
 244       t2++;
 245     }
 246
 247   return 0;
 248 }
 249
 250 int
 251 grub_strcmp (const char *s1, const char *s2)
 252 {
 253   while (*s1 && *s2)
 254     {
 255       if (*s1 != *s2)
 256         break;
 257
 258       s1++;
 259       s2++;
 260     }
 261
 262   return (int) (grub_uint8_t) *s1 - (int) (grub_uint8_t) *s2;
 263 }
 264
 265 int
 266 grub_strncmp (const char *s1, const char *s2, grub_size_t n)
 267 {
 268   if (n == 0)
 269     return 0;
 270
 271   while (*s1 && *s2 && --n)
 272     {
 273       if (*s1 != *s2)
 274         break;
 275
 276       s1++;
 277       s2++;
 278     }
 279
 280   return (int) (grub_uint8_t) *s1 - (int) (grub_uint8_t)  *s2;
 281 }
 282
 283 char *
 284 grub_strchr (const char *s, int c)
 285 {
 286   do
 287     {
 288       if (*s == c)
 289         return (char *) s;
 290     }
 291   while (*s++);
 292
 293   return 0;
 294 }
 295
 296 char *
 297 grub_strrchr (const char *s, int c)
 298 {
 299   char *p = NULL;
 300
 301   do
 302     {
 303       if (*s == c)
 304         p = (char *) s;
 305     }
 306   while (*s++);
 307
 308   return p;
 309 }
 310
 311 int
 312 grub_strword (const char *haystack, const char *needle)
 313 {
 314   const char *n_pos = needle;
 315
 316   while (grub_iswordseparator (*haystack))
 317     haystack++;
 318
 319   while (*haystack)
 320     {
 321       /* Crawl both the needle and the haystack word we're on.  */
 322       while(*haystack && !grub_iswordseparator (*haystack)
 323             && *haystack == *n_pos)
 324         {
 325           haystack++;
 326           n_pos++;
 327         }
 328
 329       /* If we reached the end of both words at the same time, the word
 330       is found. If not, eat everything in the haystack that isn't the
 331       next word (or the end of string) and "reset" the needle.  */
 332       if ( (!*haystack || grub_iswordseparator (*haystack))
 333          && (!*n_pos || grub_iswordseparator (*n_pos)))
 334         return 1;
 335       else
 336         {
 337           n_pos = needle;
 338           while (*haystack && !grub_iswordseparator (*haystack))
 339             haystack++;
 340           while (grub_iswordseparator (*haystack))
 341             haystack++;
 342         }
 343     }
 344
 345   return 0;
 346 }
 347
 348 int
 349 grub_isspace (int c)
 350 {
 351   return (c == '\n' || c == '\r' || c == ' ' || c == '\t');
 352 }
 353
 354 unsigned long
 355 grub_strtoul (const char * restrict str, const char ** const restrict end,
 356               int base)
 357 {
 358   unsigned long long num;
 359
 360   num = grub_strtoull (str, end, base);
 361 #if GRUB_CPU_SIZEOF_LONG != 8
 362   if (num > ~0UL)
 363     {
 364       grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));
 365       return ~0UL;
 366     }
 367 #endif
 368
 369   return (unsigned long) num;
 370 }
 371
 372 unsigned long long
 373 grub_strtoull (const char * restrict str, const char ** const restrict end,
 374                int base)
 375 {
 376   unsigned long long num = 0;
 377   int found = 0;
 378
 379   /* Skip white spaces.  */
 380   /* grub_isspace checks that *str != '\0'.  */
 381   while (grub_isspace (*str))
 382     str++;
 383
 384   /* Guess the base, if not specified. The prefix `0x' means 16, and
 385      the prefix `0' means 8.  */
 386   if (str[0] == '0')
 387     {
 388       if (str[1] == 'x')
 389         {
 390           if (base == 0 || base == 16)
 391             {
 392               base = 16;
 393               str += 2;
 394             }
 395         }
 396       else if (base == 0 && str[1] >= '0' && str[1] <= '7')
 397         base = 8;
 398     }
 399
 400   if (base == 0)
 401     base = 10;
 402
 403   while (*str)
 404     {
 405       unsigned long digit;
 406
 407       digit = grub_tolower (*str) - '0';
 408       if (digit >= 'a' - '0')
 409         digit += '0' - 'a' + 10;
 410       else if (digit > 9)
 411         break;
 412
 413       if (digit >= (unsigned long) base)
 414         break;
 415
 416       found = 1;
 417
 418       /* NUM * BASE + DIGIT > ~0ULL */
 419       if (num > grub_divmod64 (~0ULL - digit, base, 0))
 420         {
 421           grub_error (GRUB_ERR_OUT_OF_RANGE,
 422                       N_("overflow is detected"));
 423
 424           if (end)
 425             *end = (char *) str;
 426
 427           return ~0ULL;
 428         }
 429
 430       num = num * base + digit;
 431       str++;
 432     }
 433
 434   if (! found)
 435     {
 436       grub_error (GRUB_ERR_BAD_NUMBER,
 437                   N_("unrecognized number"));
 438
 439       if (end)
 440         *end = (char *) str;
 441
 442       return 0;
 443     }
 444
 445   if (end)
 446     *end = (char *) str;
 447
 448   return num;
 449 }
 450
 451 char *
 452 grub_strdup (const char *s)
 453 {
 454   grub_size_t len;
 455   char *p;
 456
 457   len = grub_strlen (s) + 1;
 458   p = (char *) grub_malloc (len);
 459   if (! p)
 460     return 0;
 461
 462   return grub_memcpy (p, s, len);
 463 }
 464
 465 char *
 466 grub_strndup (const char *s, grub_size_t n)
 467 {
 468   grub_size_t len;
 469   char *p;
 470
 471   len = grub_strlen (s);
 472   if (len > n)
 473     len = n;
 474   p = (char *) grub_malloc (len + 1);
 475   if (! p)
 476     return 0;
 477
 478   grub_memcpy (p, s, len);
 479   p[len] = '\0';
 480   return p;
 481 }
 482
 483 /* clang detects that we're implementing here a memset so it decides to
 484    optimise and calls memset resulting in infinite recursion. With volatile
 485    we make it not optimise in this way.  */
 486 #ifdef __clang__
 487 #define VOLATILE_CLANG volatile
 488 #else
 489 #define VOLATILE_CLANG
 490 #endif
 491
 492 void *
 493 grub_memset (void *s, int c, grub_size_t len)
 494 {
 495   void *p = s;
 496   grub_uint8_t pattern8 = c;
 497
 498   if (len >= 3 * sizeof (unsigned long))
 499     {
 500       unsigned long patternl = 0;
 501       grub_size_t i;
 502
 503       for (i = 0; i < sizeof (unsigned long); i++)
 504         patternl |= ((unsigned long) pattern8) << (8 * i);
 505
 506       while (len > 0 && (((grub_addr_t) p) & (sizeof (unsigned long) - 1)))
 507         {
 508           *(VOLATILE_CLANG grub_uint8_t *) p = pattern8;
 509           p = (grub_uint8_t *) p + 1;
 510           len--;
 511         }
 512       while (len >= sizeof (unsigned long))
 513         {
 514           *(VOLATILE_CLANG unsigned long *) p = patternl;
 515           p = (unsigned long *) p + 1;
 516           len -= sizeof (unsigned long);
 517         }
 518     }
 519
 520   while (len > 0)
 521     {
 522       *(VOLATILE_CLANG grub_uint8_t *) p = pattern8;
 523       p = (grub_uint8_t *) p + 1;
 524       len--;
 525     }
 526
 527   return s;
 528 }
 529
 530 grub_size_t
 531 grub_strlen (const char *s)
 532 {
 533   const char *p = s;
 534
 535   while (*p)
 536     p++;
 537
 538   return p - s;
 539 }
 540
 541 static inline void
 542 grub_reverse (char *str)
 543 {
 544   char *p = str + grub_strlen (str) - 1;
 545
 546   while (str < p)
 547     {
 548       char tmp;
 549
 550       tmp = *str;
 551       *str = *p;
 552       *p = tmp;
 553       str++;
 554       p--;
 555     }
 556 }
 557
 558 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 559 grub_uint64_t
 560 grub_divmod64 (grub_uint64_t n, grub_uint64_t d, grub_uint64_t *r)
 561 {
 562   /* This algorithm is typically implemented by hardware. The idea
 563      is to get the highest bit in N, 64 times, by keeping
 564      upper(N * 2^i) = (Q * D + M), where upper
 565      represents the high 64 bits in 128-bits space.  */
 566   unsigned bits = 64;
 567   grub_uint64_t q = 0;
 568   grub_uint64_t m = 0;
 569
 570   /* ARM and IA64 don't have a fast 32-bit division.
 571      Using that code would just make us use software division routines, calling
 572      ourselves indirectly and hence getting infinite recursion.
 573   */
 574 #if !GRUB_DIVISION_IN_SOFTWARE
 575   /* Skip the slow computation if 32-bit arithmetic is possible.  */
 576   if (n < 0xffffffff && d < 0xffffffff)
 577     {
 578       if (r)
 579         *r = ((grub_uint32_t) n) % (grub_uint32_t) d;
 580
 581       return ((grub_uint32_t) n) / (grub_uint32_t) d;
 582     }
 583 #endif
 584
 585   while (bits--)
 586     {
 587       m <<= 1;
 588
 589       if (n & (1ULL << 63))
 590         m |= 1;
 591
 592       q <<= 1;
 593       n <<= 1;
 594
 595       if (m >= d)
 596         {
 597           q |= 1;
 598           m -= d;
 599         }
 600     }
 601
 602   if (r)
 603     *r = m;
 604
 605   return q;
 606 }
 607
 608 /* Convert a long long value to a string. This function avoids 64-bit
 609    modular arithmetic or divisions.  */
 610 static inline char *
 611 grub_lltoa (char *str, int c, unsigned long long n)
 612 {
 613   unsigned base = ((c == 'x') || (c == 'X')) ? 16 : 10;
 614   char *p;
 615
 616   if ((long long) n < 0 && c == 'd')
 617     {
 618       n = (unsigned long long) (-((long long) n));
 619       *str++ = '-';
 620     }
 621
 622   p = str;
 623
 624   if (base == 16)
 625     do
 626       {
 627         unsigned d = (unsigned) (n & 0xf);
 628         *p++ = (d > 9) ? d + ((c == 'x') ? 'a' : 'A') - 10 : d + '0';
 629       }
 630     while (n >>= 4);
 631   else
 632     /* BASE == 10 */
 633     do
 634       {
 635         grub_uint64_t m;
 636
 637         n = grub_divmod64 (n, 10, &m);
 638         *p++ = m + '0';
 639       }
 640     while (n);
 641
 642   *p = 0;
 643
 644   grub_reverse (str);
 645   return p;
 646 }
 647
 648 /*
 649  * Parse printf() fmt0 string into args arguments.
 650  *
 651  * The parsed arguments are either used by a printf() function to format the fmt0
 652  * string or they are used to compare a format string from an untrusted source
 653  * against a format string with expected arguments.
 654  *
 655  * When the fmt_check is set to !0, e.g. 1, then this function is executed in
 656  * printf() format check mode. This enforces stricter rules for parsing the
 657  * fmt0 to limit exposure to possible errors in printf() handling. It also
 658  * disables positional parameters, "$", because some formats, e.g "%s%1$d",
 659  * cannot be validated with the current implementation.
 660  *
 661  * The max_args allows to set a maximum number of accepted arguments. If the fmt0
 662  * string defines more arguments than the max_args then the parse_printf_arg_fmt()
 663  * function returns an error. This is currently used for format check only.
 664  */
 665 static grub_err_t
 666 parse_printf_arg_fmt (const char *fmt0, struct printf_args *args,
 667                       int fmt_check, grub_size_t max_args)
 668 {
 669   const char *fmt;
 670   char c;
 671   grub_size_t n = 0;
 672
 673   args->count = 0;
 674
 675   COMPILE_TIME_ASSERT (sizeof (int) == sizeof (grub_uint32_t));
 676   COMPILE_TIME_ASSERT (sizeof (int) <= sizeof (long long));
 677   COMPILE_TIME_ASSERT (sizeof (long) <= sizeof (long long));
 678   COMPILE_TIME_ASSERT (sizeof (long long) == sizeof (void *)
 679                        || sizeof (int) == sizeof (void *));
 680
 681   fmt = fmt0;
 682   while ((c = *fmt++) != 0)
 683     {
 684       if (c != '%')
 685         continue;
 686
 687       if (*fmt =='-')
 688         fmt++;
 689
 690       while (grub_isdigit (*fmt))
 691         fmt++;
 692
 693       if (*fmt == '$')
 694         {
 695           if (fmt_check)
 696             return grub_error (GRUB_ERR_BAD_ARGUMENT,
 697                                "positional arguments are not supported");
 698           fmt++;
 699         }
 700
 701       if (*fmt =='-')
 702         fmt++;
 703
 704       while (grub_isdigit (*fmt))
 705         fmt++;
 706
 707       if (*fmt =='.')
 708         fmt++;
 709
 710       while (grub_isdigit (*fmt))
 711         fmt++;
 712
 713       c = *fmt++;
 714       if (c == 'l')
 715         c = *fmt++;
 716       if (c == 'l')
 717         c = *fmt++;
 718
 719       switch (c)
 720         {
 721         case 'p':
 722         case 'x':
 723         case 'X':
 724         case 'u':
 725         case 'd':
 726         case 'c':
 727         case 'C':
 728         case 's':
 729           args->count++;
 730           break;
 731         case '%':
 732           /* "%%" is the escape sequence to output "%". */
 733           break;
 734         default:
 735           if (fmt_check)
 736             return grub_error (GRUB_ERR_BAD_ARGUMENT, "unexpected format");
 737           break;
 738         }
 739     }
 740
 741   if (fmt_check && args->count > max_args)
 742     return grub_error (GRUB_ERR_BAD_ARGUMENT, "too many arguments");
 743
 744   if (args->count <= ARRAY_SIZE (args->prealloc))
 745     args->ptr = args->prealloc;
 746   else
 747     {
 748       args->ptr = grub_calloc (args->count, sizeof (args->ptr[0]));
 749       if (!args->ptr)
 750         {
 751           if (fmt_check)
 752             return grub_errno;
 753
 754           grub_errno = GRUB_ERR_NONE;
 755           args->ptr = args->prealloc;
 756           args->count = ARRAY_SIZE (args->prealloc);
 757         }
 758     }
 759
 760   grub_memset (args->ptr, 0, args->count * sizeof (args->ptr[0]));
 761
 762   fmt = fmt0;
 763   n = 0;
 764   while ((c = *fmt++) != 0)
 765     {
 766       int longfmt = 0;
 767       grub_size_t curn;
 768       const char *p;
 769
 770       if (c != '%')
 771         continue;
 772
 773       curn = n++;
 774
 775       if (*fmt =='-')
 776         fmt++;
 777
 778       p = fmt;
 779
 780       while (grub_isdigit (*fmt))
 781         fmt++;
 782
 783       if (*fmt == '$')
 784         {
 785           curn = grub_strtoull (p, 0, 10) - 1;
 786           fmt++;
 787         }
 788
 789       if (*fmt =='-')
 790         fmt++;
 791
 792       while (grub_isdigit (*fmt))
 793         fmt++;
 794
 795       if (*fmt =='.')
 796         fmt++;
 797
 798       while (grub_isdigit (*fmt))
 799         fmt++;
 800
 801       c = *fmt++;
 802       if (c == '%')
 803         {
 804           n--;
 805           continue;
 806         }
 807
 808       if (c == 'l')
 809         {
 810           c = *fmt++;
 811           longfmt = 1;
 812         }
 813       if (c == 'l')
 814         {
 815           c = *fmt++;
 816           longfmt = 2;
 817         }
 818       if (curn >= args->count)
 819         continue;
 820       switch (c)
 821         {
 822         case 'x':
 823         case 'X':
 824         case 'u':
 825           args->ptr[curn].type = UNSIGNED_INT + longfmt;
 826           break;
 827         case 'd':
 828           args->ptr[curn].type = INT + longfmt;
 829           break;
 830         case 'p':
 831           if (sizeof (void *) == sizeof (long long))
 832             args->ptr[curn].type = UNSIGNED_LONGLONG;
 833           else
 834             args->ptr[curn].type = UNSIGNED_INT;
 835           break;
 836         case 's':
 837           args->ptr[curn].type = STRING;
 838           break;
 839         case 'C':
 840         case 'c':
 841           args->ptr[curn].type = INT;
 842           break;
 843         }
 844     }
 845
 846   return GRUB_ERR_NONE;
 847 }
 848
 849 static void
 850 parse_printf_args (const char *fmt0, struct printf_args *args, va_list args_in)
 851 {
 852   grub_size_t n;
 853
 854   parse_printf_arg_fmt (fmt0, args, 0, 0);
 855
 856   for (n = 0; n < args->count; n++)
 857     switch (args->ptr[n].type)
 858       {
 859       case INT:
 860         args->ptr[n].ll = va_arg (args_in, int);
 861         break;
 862       case LONG:
 863         args->ptr[n].ll = va_arg (args_in, long);
 864         break;
 865       case UNSIGNED_INT:
 866         args->ptr[n].ll = va_arg (args_in, unsigned int);
 867         break;
 868       case UNSIGNED_LONG:
 869         args->ptr[n].ll = va_arg (args_in, unsigned long);
 870         break;
 871       case LONGLONG:
 872       case UNSIGNED_LONGLONG:
 873         args->ptr[n].ll = va_arg (args_in, long long);
 874         break;
 875       case STRING:
 876         if (sizeof (void *) == sizeof (long long))
 877           args->ptr[n].ll = va_arg (args_in, long long);
 878         else
 879           args->ptr[n].ll = va_arg (args_in, unsigned int);
 880         break;
 881       }
 882 }
 883
 884 static inline void __attribute__ ((always_inline))
 885 write_char (char *str, grub_size_t *count, grub_size_t max_len, unsigned char ch)
 886 {
 887   if (*count < max_len)
 888     str[*count] = ch;
 889
 890   (*count)++;
 891 }
 892
 893 static int
 894 grub_vsnprintf_real (char *str, grub_size_t max_len, const char *fmt0,
 895                      struct printf_args *args)
 896 {
 897   char c;
 898   grub_size_t n = 0;
 899   grub_size_t count = 0;
 900   const char *fmt;
 901
 902   fmt = fmt0;
 903
 904   while ((c = *fmt++) != 0)
 905     {
 906       unsigned int format1 = 0;
 907       unsigned int format2 = ~ 0U;
 908       char zerofill = ' ';
 909       char rightfill = 0;
 910       grub_size_t curn;
 911
 912       if (c != '%')
 913         {
 914           write_char (str, &count, max_len,c);
 915           continue;
 916         }
 917
 918       curn = n++;
 919
 920     rescan:;
 921
 922       if (*fmt =='-')
 923         {
 924           rightfill = 1;
 925           fmt++;
 926         }
 927
 928       /* Read formatting parameters.  */
 929       if (grub_isdigit (*fmt))
 930         {
 931           if (fmt[0] == '0')
 932             zerofill = '0';
 933           format1 = grub_strtoul (fmt, &fmt, 10);
 934         }
 935
 936       if (*fmt == '.')
 937         fmt++;
 938
 939       if (grub_isdigit (*fmt))
 940         format2 = grub_strtoul (fmt, &fmt, 10);
 941
 942       if (*fmt == '$')
 943         {
 944           curn = format1 - 1;
 945           fmt++;
 946           format1 = 0;
 947           format2 = ~ 0U;
 948           zerofill = ' ';
 949           rightfill = 0;
 950
 951           goto rescan;
 952         }
 953
 954       c = *fmt++;
 955       if (c == 'l')
 956         c = *fmt++;
 957       if (c == 'l')
 958         c = *fmt++;
 959
 960       if (c == '%')
 961         {
 962           write_char (str, &count, max_len,c);
 963           n--;
 964           continue;
 965         }
 966
 967       if (curn >= args->count)
 968         continue;
 969
 970       long long curarg = args->ptr[curn].ll;
 971
 972       switch (c)
 973         {
 974         case 'p':
 975           write_char (str, &count, max_len, '0');
 976           write_char (str, &count, max_len, 'x');
 977           c = 'x';
 978           /* Fall through. */
 979         case 'x':
 980         case 'X':
 981         case 'u':
 982         case 'd':
 983           {
 984             char tmp[32];
 985             const char *p = tmp;
 986             grub_size_t len;
 987             grub_size_t fill;
 988
 989             len = grub_lltoa (tmp, c, curarg) - tmp;
 990             fill = len < format1 ? format1 - len : 0;
 991             if (! rightfill)
 992               while (fill--)
 993                 write_char (str, &count, max_len, zerofill);
 994             while (*p)
 995               write_char (str, &count, max_len, *p++);
 996             if (rightfill)
 997               while (fill--)
 998                 write_char (str, &count, max_len, zerofill);
 999           }
1000           break;
1001
1002         case 'c':
1003           write_char (str, &count, max_len,curarg & 0xff);
1004           break;
1005
1006         case 'C':
1007           {
1008             grub_uint32_t code = curarg;
1009             int shift;
1010             unsigned mask;
1011
1012             if (code <= 0x7f)
1013               {
1014                 shift = 0;
1015                 mask = 0;
1016               }
1017             else if (code <= 0x7ff)
1018               {
1019                 shift = 6;
1020                 mask = 0xc0;
1021               }
1022             else if (code <= 0xffff)
1023               {
1024                 shift = 12;
1025                 mask = 0xe0;
1026               }
1027             else if (code <= 0x10ffff)
1028               {
1029                 shift = 18;
1030                 mask = 0xf0;
1031               }
1032             else
1033               {
1034                 code = '?';
1035                 shift = 0;
1036                 mask = 0;
1037               }
1038
1039             write_char (str, &count, max_len,mask | (code >> shift));
1040
1041             for (shift -= 6; shift >= 0; shift -= 6)
1042               write_char (str, &count, max_len,0x80 | (0x3f & (code >> shift)));
1043           }
1044           break;
1045
1046         case 's':
1047           {
1048             grub_size_t len = 0;
1049             grub_size_t fill;
1050             const char *p = ((char *) (grub_addr_t) curarg) ? : "(null)";
1051             grub_size_t i;
1052
1053             while (len < format2 && p[len])
1054               len++;
1055
1056             fill = len < format1 ? format1 - len : 0;
1057
1058             if (!rightfill)
1059               while (fill--)
1060                 write_char (str, &count, max_len, zerofill);
1061
1062             for (i = 0; i < len; i++)
1063               write_char (str, &count, max_len,*p++);
1064
1065             if (rightfill)
1066               while (fill--)
1067                 write_char (str, &count, max_len, zerofill);
1068           }
1069
1070           break;
1071
1072         default:
1073           write_char (str, &count, max_len,c);
1074           break;
1075         }
1076     }
1077
1078   if (count < max_len)
1079     str[count] = '\0';
1080   else
1081     str[max_len] = '\0';
1082   return count;
1083 }
1084
1085 int
1086 grub_vsnprintf (char *str, grub_size_t n, const char *fmt, va_list ap)
1087 {
1088   grub_size_t ret;
1089   struct printf_args args;
1090
1091   if (!n)
1092     return 0;
1093
1094   n--;
1095
1096   parse_printf_args (fmt, &args, ap);
1097
1098   ret = grub_vsnprintf_real (str, n, fmt, &args);
1099
1100   free_printf_args (&args);
1101
1102   return ret < n ? ret : n;
1103 }
1104
1105 int
1106 grub_snprintf (char *str, grub_size_t n, const char *fmt, ...)
1107 {
1108   va_list ap;
1109   int ret;
1110
1111   va_start (ap, fmt);
1112   ret = grub_vsnprintf (str, n, fmt, ap);
1113   va_end (ap);
1114
1115   return ret;
1116 }
1117
1118 char *
1119 grub_xvasprintf (const char *fmt, va_list ap)
1120 {
1121   grub_size_t s, as = PREALLOC_SIZE;
1122   char *ret;
1123   struct printf_args args;
1124
1125   parse_printf_args (fmt, &args, ap);
1126
1127   while (1)
1128     {
1129       ret = grub_malloc (as + 1);
1130       if (!ret)
1131         {
1132           free_printf_args (&args);
1133           return NULL;
1134         }
1135
1136       s = grub_vsnprintf_real (ret, as, fmt, &args);
1137
1138       if (s <= as)
1139         {
1140           free_printf_args (&args);
1141           return ret;
1142         }
1143
1144       grub_free (ret);
1145       as = s;
1146     }
1147 }
1148
1149 char *
1150 grub_xasprintf (const char *fmt, ...)
1151 {
1152   va_list ap;
1153   char *ret;
1154
1155   va_start (ap, fmt);
1156   ret = grub_xvasprintf (fmt, ap);
1157   va_end (ap);
1158
1159   return ret;
1160 }
1161
1162 grub_err_t
1163 grub_printf_fmt_check (const char *fmt, const char *fmt_expected)
1164 {
1165   struct printf_args args_expected, args_fmt;
1166   grub_err_t ret;
1167   grub_size_t n;
1168
1169   if (fmt == NULL || fmt_expected == NULL)
1170     return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid format");
1171
1172   ret = parse_printf_arg_fmt (fmt_expected, &args_expected, 1, GRUB_SIZE_MAX);
1173   if (ret != GRUB_ERR_NONE)
1174     return ret;
1175
1176   /* Limit parsing to the number of expected arguments. */
1177   ret = parse_printf_arg_fmt (fmt, &args_fmt, 1, args_expected.count);
1178   if (ret != GRUB_ERR_NONE)
1179     {
1180       free_printf_args (&args_expected);
1181       return ret;
1182     }
1183
1184   for (n = 0; n < args_fmt.count; n++)
1185     if (args_fmt.ptr[n].type != args_expected.ptr[n].type)
1186      {
1187         ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "arguments types do not match");
1188         break;
1189      }
1190
1191   free_printf_args (&args_expected);
1192   free_printf_args (&args_fmt);
1193
1194   return ret;
1195 }
1196
1197
1198 /* Abort GRUB. This function does not return.  */
1199 static void __attribute__ ((noreturn))
1200 grub_abort (void)
1201 {
1202   grub_printf ("\nAborted.");
1203
1204 #ifndef GRUB_UTIL
1205   if (grub_term_inputs)
1206 #endif
1207     {
1208       grub_printf (" Press any key to exit.");
1209       grub_getkey ();
1210     }
1211
1212   grub_exit ();
1213 }
1214
1215 void
1216 grub_fatal (const char *fmt, ...)
1217 {
1218   va_list ap;
1219
1220   va_start (ap, fmt);
1221   grub_vprintf (_(fmt), ap);
1222   va_end (ap);
1223
1224   grub_refresh ();
1225
1226   grub_abort ();
1227 }
1228
1229 #if BOOT_TIME_STATS
1230
1231 #include <grub/time.h>
1232
1233 struct grub_boot_time *grub_boot_time_head;
1234 static struct grub_boot_time **boot_time_last = &grub_boot_time_head;
1235
1236 void
1237 grub_real_boot_time (const char *file,
1238                      const int line,
1239                      const char *fmt, ...)
1240 {
1241   struct grub_boot_time *n;
1242   va_list args;
1243
1244   grub_error_push ();
1245   n = grub_malloc (sizeof (*n));
1246   if (!n)
1247     {
1248       grub_errno = 0;
1249       grub_error_pop ();
1250       return;
1251     }
1252   n->file = file;
1253   n->line = line;
1254   n->tp = grub_get_time_ms ();
1255   n->next = 0;
1256
1257   va_start (args, fmt);
1258   n->msg = grub_xvasprintf (fmt, args);
1259   va_end (args);
1260
1261   *boot_time_last = n;
1262   boot_time_last = &n->next;
1263
1264   grub_errno = 0;
1265   grub_error_pop ();
1266 }
1267 #endif