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

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2009  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/normal.h>
  20 #include <grub/misc.h>
  21 #include <grub/term.h>
  22 #include <grub/err.h>
  23 #include <grub/types.h>
  24 #include <grub/mm.h>
  25 #include <grub/partition.h>
  26 #include <grub/disk.h>
  27 #include <grub/file.h>
  28 #include <grub/env.h>
  29 #include <grub/i18n.h>
  30 #include <grub/charset.h>
  31
  32 static grub_uint32_t *kill_buf;
  33
  34 static int hist_size;
  35 static grub_uint32_t **hist_lines = 0;
  36 static int hist_pos = 0;
  37 static int hist_end = 0;
  38 static int hist_used = 0;
  39
  40 grub_err_t
  41 grub_set_history (int newsize)
  42 {
  43   grub_uint32_t **old_hist_lines = hist_lines;
  44   hist_lines = grub_malloc (sizeof (grub_uint32_t *) * newsize);
  45
  46   /* Copy the old lines into the new buffer.  */
  47   if (old_hist_lines)
  48     {
  49       /* Remove the lines that don't fit in the new buffer.  */
  50       if (newsize < hist_used)
  51         {
  52           grub_size_t i;
  53           grub_size_t delsize = hist_used - newsize;
  54           hist_used = newsize;
  55
  56           for (i = 1; i < delsize + 1; i++)
  57             {
  58               grub_ssize_t pos = hist_end - i;
  59               if (pos < 0)
  60                 pos += hist_size;
  61               grub_free (old_hist_lines[pos]);
  62             }
  63
  64           hist_end -= delsize;
  65           if (hist_end < 0)
  66             hist_end += hist_size;
  67         }
  68
  69       if (hist_pos < hist_end)
  70         grub_memmove (hist_lines, old_hist_lines + hist_pos,
  71                       (hist_end - hist_pos) * sizeof (grub_uint32_t *));
  72       else if (hist_used)
  73         {
  74           /* Copy the older part.  */
  75           grub_memmove (hist_lines, old_hist_lines + hist_pos,
  76                         (hist_size - hist_pos) * sizeof (grub_uint32_t *));
  77
  78           /* Copy the newer part. */
  79           grub_memmove (hist_lines + hist_size - hist_pos, old_hist_lines,
  80                         hist_end * sizeof (grub_uint32_t *));
  81         }
  82     }
  83
  84   grub_free (old_hist_lines);
  85
  86   hist_size = newsize;
  87   hist_pos = 0;
  88   hist_end = hist_used;
  89   return 0;
  90 }
  91
  92 /* Get the entry POS from the history where `0' is the newest
  93    entry.  */
  94 static grub_uint32_t *
  95 grub_history_get (int pos)
  96 {
  97   pos = (hist_pos + pos) % hist_size;
  98   return hist_lines[pos];
  99 }
 100
 101 static grub_size_t
 102 strlen_ucs4 (const grub_uint32_t *s)
 103 {
 104   const grub_uint32_t *p = s;
 105
 106   while (*p)
 107     p++;
 108
 109   return p - s;
 110 }
 111
 112 /* Replace the history entry on position POS with the string S.  */
 113 static void
 114 grub_history_set (int pos, grub_uint32_t *s, grub_size_t len)
 115 {
 116   grub_free (hist_lines[pos]);
 117   hist_lines[pos] = grub_malloc ((len + 1) * sizeof (grub_uint32_t));
 118   if (!hist_lines[pos])
 119     {
 120       grub_print_error ();
 121       grub_errno = GRUB_ERR_NONE;
 122       return ;
 123     }
 124   grub_memcpy (hist_lines[pos], s, len * sizeof (grub_uint32_t));
 125   hist_lines[pos][len] = 0;
 126 }
 127
 128 /* Insert a new history line S on the top of the history.  */
 129 static void
 130 grub_history_add (grub_uint32_t *s, grub_size_t len)
 131 {
 132   /* Remove the oldest entry in the history to make room for a new
 133      entry.  */
 134   if (hist_used + 1 > hist_size)
 135     {
 136       hist_end--;
 137       if (hist_end < 0)
 138         hist_end = hist_size + hist_end;
 139
 140       grub_free (hist_lines[hist_end]);
 141     }
 142   else
 143     hist_used++;
 144
 145   /* Move to the next position.  */
 146   hist_pos--;
 147   if (hist_pos < 0)
 148     hist_pos = hist_size + hist_pos;
 149
 150   /* Insert into history.  */
 151   hist_lines[hist_pos] = NULL;
 152   grub_history_set (hist_pos, s, len);
 153 }
 154
 155 /* Replace the history entry on position POS with the string S.  */
 156 static void
 157 grub_history_replace (int pos, grub_uint32_t *s, grub_size_t len)
 158 {
 159   grub_history_set ((hist_pos + pos) % hist_size, s, len);
 160 }
 161
 162 /* A completion hook to print items.  */
 163 static void
 164 print_completion (const char *item, grub_completion_type_t type, int count)
 165 {
 166   if (count == 0)
 167     {
 168       /* If this is the first time, print a label.  */
 169
 170       grub_puts ("");
 171       switch (type)
 172         {
 173         case GRUB_COMPLETION_TYPE_COMMAND:
 174           grub_puts_ (N_("Possible commands are:"));
 175           break;
 176         case GRUB_COMPLETION_TYPE_DEVICE:
 177           grub_puts_ (N_("Possible devices are:"));
 178           break;
 179         case GRUB_COMPLETION_TYPE_FILE:
 180           grub_puts_ (N_("Possible files are:"));
 181           break;
 182         case GRUB_COMPLETION_TYPE_PARTITION:
 183           grub_puts_ (N_("Possible partitions are:"));
 184           break;
 185         case GRUB_COMPLETION_TYPE_ARGUMENT:
 186           grub_puts_ (N_("Possible arguments are:"));
 187           break;
 188         default:
 189           /* TRANSLATORS: this message is used if none of above matches.
 190              This shouldn't happen but please use the general term for
 191              "thing" or "object".  */
 192           grub_puts_ (N_("Possible things are:"));
 193           break;
 194         }
 195       grub_puts ("");
 196     }
 197
 198   if (type == GRUB_COMPLETION_TYPE_PARTITION)
 199     {
 200       grub_normal_print_device_info (item);
 201       grub_errno = GRUB_ERR_NONE;
 202     }
 203   else
 204     grub_printf (" %s", item);
 205 }
 206
 207 struct cmdline_term
 208 {
 209   unsigned xpos, ypos, ystart, width, height;
 210   unsigned prompt_len;
 211   struct grub_term_output *term;
 212 };
 213
 214 /* Get a command-line. If ESC is pushed, return zero,
 215    otherwise return command line.  */
 216 /* FIXME: The dumb interface is not supported yet.  */
 217 char *
 218 grub_cmdline_get (const char *prompt_translated)
 219 {
 220   grub_size_t lpos, llen;
 221   grub_uint32_t *buf;
 222   grub_size_t max_len = 256;
 223   int key;
 224   int histpos = 0;
 225   auto void cl_insert (const grub_uint32_t *str);
 226   auto void cl_delete (unsigned len);
 227   auto inline void __attribute__ ((always_inline)) cl_print (struct cmdline_term *cl_term, int pos,
 228                         grub_uint32_t c);
 229   auto void cl_set_pos (struct cmdline_term *cl_term);
 230   auto void cl_print_all (int pos, grub_uint32_t c);
 231   auto void cl_set_pos_all (void);
 232   auto void init_clterm (struct cmdline_term *cl_term_cur);
 233   auto void init_clterm_all (void);
 234   struct cmdline_term *cl_terms;
 235   char *ret;
 236   unsigned nterms;
 237
 238   void cl_set_pos (struct cmdline_term *cl_term)
 239   {
 240     cl_term->xpos = (cl_term->prompt_len + lpos) % (cl_term->width - 1);
 241     cl_term->ypos = cl_term->ystart
 242       + (cl_term->prompt_len + lpos) / (cl_term->width - 1);
 243     grub_term_gotoxy (cl_term->term, cl_term->xpos, cl_term->ypos);
 244   }
 245
 246   void cl_set_pos_all (void)
 247   {
 248     unsigned i;
 249     for (i = 0; i < nterms; i++)
 250       cl_set_pos (&cl_terms[i]);
 251   }
 252
 253   inline void __attribute__ ((always_inline)) cl_print (struct cmdline_term *cl_term, int pos, grub_uint32_t c)
 254     {
 255       grub_uint32_t *p;
 256
 257       for (p = buf + pos; p < buf + llen; p++)
 258         {
 259           if (c)
 260             grub_putcode (c, cl_term->term);
 261           else
 262             grub_putcode (*p, cl_term->term);
 263           cl_term->xpos++;
 264           if (cl_term->xpos >= cl_term->width - 1)
 265             {
 266               cl_term->xpos = 0;
 267               if (cl_term->ypos >= (unsigned) (cl_term->height - 1))
 268                 cl_term->ystart--;
 269               else
 270                 cl_term->ypos++;
 271               grub_putcode ('\n', cl_term->term);
 272             }
 273         }
 274     }
 275
 276   void cl_print_all (int pos, grub_uint32_t c)
 277   {
 278     unsigned i;
 279     for (i = 0; i < nterms; i++)
 280       cl_print (&cl_terms[i], pos, c);
 281   }
 282
 283   void cl_insert (const grub_uint32_t *str)
 284     {
 285       grub_size_t len = strlen_ucs4 (str);
 286
 287       if (len + llen >= max_len)
 288         {
 289           grub_uint32_t *nbuf;
 290           max_len *= 2;
 291           nbuf = grub_realloc (buf, sizeof (grub_uint32_t) * max_len);
 292           if (nbuf)
 293             buf = nbuf;
 294           else
 295             {
 296               grub_print_error ();
 297               grub_errno = GRUB_ERR_NONE;
 298               max_len /= 2;
 299             }
 300         }
 301
 302       if (len + llen < max_len)
 303         {
 304           grub_memmove (buf + lpos + len, buf + lpos,
 305                         (llen - lpos + 1) * sizeof (grub_uint32_t));
 306           grub_memmove (buf + lpos, str, len * sizeof (grub_uint32_t));
 307
 308           llen += len;
 309           cl_set_pos_all ();
 310           cl_print_all (lpos, 0);
 311           lpos += len;
 312           cl_set_pos_all ();
 313         }
 314     }
 315
 316   void cl_delete (unsigned len)
 317     {
 318       if (lpos + len <= llen)
 319         {
 320           grub_size_t saved_lpos = lpos;
 321
 322           lpos = llen - len;
 323           cl_set_pos_all ();
 324           cl_print_all (lpos, ' ');
 325           lpos = saved_lpos;
 326           cl_set_pos_all ();
 327
 328           grub_memmove (buf + lpos, buf + lpos + len,
 329                         sizeof (grub_uint32_t) * (llen - lpos + 1));
 330           llen -= len;
 331           cl_print_all (lpos, 0);
 332           cl_set_pos_all ();
 333         }
 334     }
 335
 336   void init_clterm (struct cmdline_term *cl_term_cur)
 337   {
 338     cl_term_cur->xpos = cl_term_cur->prompt_len;
 339     cl_term_cur->ypos = (grub_term_getxy (cl_term_cur->term) & 0xFF);
 340     cl_term_cur->ystart = cl_term_cur->ypos;
 341     cl_term_cur->width = grub_term_width (cl_term_cur->term);
 342     cl_term_cur->height = grub_term_height (cl_term_cur->term);
 343   }
 344
 345   void init_clterm_all (void)
 346   {
 347     unsigned i;
 348     for (i = 0; i < nterms; i++)
 349       init_clterm (&cl_terms[i]);
 350   }
 351
 352   buf = grub_malloc (max_len * sizeof (grub_uint32_t));
 353   if (!buf)
 354     return 0;
 355
 356   lpos = llen = 0;
 357   buf[0] = '\0';
 358
 359   {
 360     grub_term_output_t term;
 361
 362     FOR_ACTIVE_TERM_OUTPUTS(term)
 363       if ((grub_term_getxy (term) >> 8) != 0)
 364         grub_putcode ('\n', term);
 365   }
 366   grub_xputs (prompt_translated);
 367   grub_xputs (" ");
 368   grub_normal_reset_more ();
 369
 370   {
 371     struct cmdline_term *cl_term_cur;
 372     struct grub_term_output *cur;
 373     grub_uint32_t *unicode_msg;
 374     grub_size_t msg_len = grub_strlen (prompt_translated) + 3;
 375
 376     nterms = 0;
 377     FOR_ACTIVE_TERM_OUTPUTS(cur)
 378       nterms++;
 379
 380     cl_terms = grub_malloc (sizeof (cl_terms[0]) * nterms);
 381     if (!cl_terms)
 382       return 0;
 383     cl_term_cur = cl_terms;
 384
 385     unicode_msg = grub_malloc (msg_len * sizeof (grub_uint32_t));
 386     if (!unicode_msg)
 387       return 0;;
 388     msg_len = grub_utf8_to_ucs4 (unicode_msg, msg_len - 1,
 389                                  (grub_uint8_t *) prompt_translated, -1, 0);
 390     unicode_msg[msg_len++] = ' ';
 391
 392     FOR_ACTIVE_TERM_OUTPUTS(cur)
 393     {
 394       cl_term_cur->term = cur;
 395       cl_term_cur->prompt_len = grub_getstringwidth (unicode_msg,
 396                                                      unicode_msg + msg_len,
 397                                                      cur);
 398       init_clterm (cl_term_cur);
 399       cl_term_cur++;
 400     }
 401     grub_free (unicode_msg);
 402   }
 403
 404   if (hist_used == 0)
 405     grub_history_add (buf, llen);
 406
 407   grub_refresh ();
 408
 409   while ((key = grub_getkey ()) != '\n' && key != '\r')
 410     {
 411       switch (key)
 412         {
 413         case GRUB_TERM_CTRL | 'a':
 414         case GRUB_TERM_KEY_HOME:
 415           lpos = 0;
 416           cl_set_pos_all ();
 417           break;
 418
 419         case GRUB_TERM_CTRL | 'b':
 420         case GRUB_TERM_KEY_LEFT:
 421           if (lpos > 0)
 422             {
 423               lpos--;
 424               cl_set_pos_all ();
 425             }
 426           break;
 427
 428         case GRUB_TERM_CTRL | 'e':
 429         case GRUB_TERM_KEY_END:
 430           lpos = llen;
 431           cl_set_pos_all ();
 432           break;
 433
 434         case GRUB_TERM_CTRL | 'f':
 435         case GRUB_TERM_KEY_RIGHT:
 436           if (lpos < llen)
 437             {
 438               lpos++;
 439               cl_set_pos_all ();
 440             }
 441           break;
 442
 443         case GRUB_TERM_CTRL | 'i':
 444         case '\t':
 445           {
 446             int restore;
 447             char *insertu8;
 448             char *bufu8;
 449             grub_uint32_t c;
 450
 451             c = buf[lpos];
 452             buf[lpos] = '\0';
 453
 454             bufu8 = grub_ucs4_to_utf8_alloc (buf, lpos);
 455             buf[lpos] = c;
 456             if (!bufu8)
 457               {
 458                 grub_print_error ();
 459                 grub_errno = GRUB_ERR_NONE;
 460                 break;
 461               }
 462
 463             insertu8 = grub_normal_do_completion (bufu8, &restore,
 464                                                   print_completion);
 465             grub_free (bufu8);
 466
 467             grub_normal_reset_more ();
 468
 469             if (restore)
 470               {
 471                 /* Restore the prompt.  */
 472                 grub_xputs ("\n");
 473                 grub_xputs (prompt_translated);
 474                 grub_xputs (" ");
 475                 init_clterm_all ();
 476                 cl_print_all (0, 0);
 477               }
 478
 479             if (insertu8)
 480               {
 481                 grub_size_t insertlen;
 482                 grub_ssize_t t;
 483                 grub_uint32_t *insert;
 484
 485                 insertlen = grub_strlen (insertu8);
 486                 insert = grub_malloc ((insertlen + 1) * sizeof (grub_uint32_t));
 487                 if (!insert)
 488                   {
 489                     grub_free (insertu8);
 490                     grub_print_error ();
 491                     grub_errno = GRUB_ERR_NONE;
 492                     break;
 493                   }
 494                 t = grub_utf8_to_ucs4 (insert, insertlen,
 495                                        (grub_uint8_t *) insertu8,
 496                                        insertlen, 0);
 497                 if (t > 0)
 498                   {
 499                     if (insert[t-1] == ' ' && buf[lpos] == ' ')
 500                       {
 501                         insert[t-1] = 0;
 502                         if (t != 1)
 503                           cl_insert (insert);
 504                         lpos++;
 505                       }
 506                     else
 507                       {
 508                         insert[t] = 0;
 509                         cl_insert (insert);
 510                       }
 511                   }
 512
 513                 grub_free (insertu8);
 514                 grub_free (insert);
 515               }
 516             cl_set_pos_all ();
 517           }
 518           break;
 519
 520         case GRUB_TERM_CTRL | 'k':
 521           if (lpos < llen)
 522             {
 523               grub_free (kill_buf);
 524
 525               kill_buf = grub_malloc ((llen - lpos + 1)
 526                                       * sizeof (grub_uint32_t));
 527               if (grub_errno)
 528                 {
 529                   grub_print_error ();
 530                   grub_errno = GRUB_ERR_NONE;
 531                 }
 532               else
 533                 {
 534                   grub_memcpy (kill_buf, buf + lpos,
 535                                (llen - lpos + 1) * sizeof (grub_uint32_t));
 536                   kill_buf[llen - lpos] = 0;
 537                 }
 538
 539               cl_delete (llen - lpos);
 540             }
 541           break;
 542
 543         case GRUB_TERM_CTRL | 'n':
 544         case GRUB_TERM_KEY_DOWN:
 545           {
 546             grub_uint32_t *hist;
 547
 548             lpos = 0;
 549
 550             if (histpos > 0)
 551               {
 552                 grub_history_replace (histpos, buf, llen);
 553                 histpos--;
 554               }
 555
 556             cl_delete (llen);
 557             hist = grub_history_get (histpos);
 558             cl_insert (hist);
 559
 560             break;
 561           }
 562
 563         case GRUB_TERM_KEY_UP:
 564         case GRUB_TERM_CTRL | 'p':
 565           {
 566             grub_uint32_t *hist;
 567
 568             lpos = 0;
 569
 570             if (histpos < hist_used - 1)
 571               {
 572                 grub_history_replace (histpos, buf, llen);
 573                 histpos++;
 574               }
 575
 576             cl_delete (llen);
 577             hist = grub_history_get (histpos);
 578
 579             cl_insert (hist);
 580           }
 581           break;
 582
 583         case GRUB_TERM_CTRL | 'u':
 584           if (lpos > 0)
 585             {
 586               grub_size_t n = lpos;
 587
 588               grub_free (kill_buf);
 589
 590               kill_buf = grub_malloc (n + 1);
 591               if (grub_errno)
 592                 {
 593                   grub_print_error ();
 594                   grub_errno = GRUB_ERR_NONE;
 595                 }
 596               if (kill_buf)
 597                 {
 598                   grub_memcpy (kill_buf, buf, n);
 599                   kill_buf[n] = '\0';
 600                 }
 601
 602               lpos = 0;
 603               cl_set_pos_all ();
 604               cl_delete (n);
 605             }
 606           break;
 607
 608         case GRUB_TERM_CTRL | 'y':
 609           if (kill_buf)
 610             cl_insert (kill_buf);
 611           break;
 612
 613         case '\e':
 614           grub_free (cl_terms);
 615           return 0;
 616
 617         case '\b':
 618           if (lpos > 0)
 619             {
 620               lpos--;
 621               cl_set_pos_all ();
 622             }
 623           else
 624             break;
 625           /* fall through */
 626
 627         case GRUB_TERM_CTRL | 'd':
 628         case GRUB_TERM_KEY_DC:
 629           if (lpos < llen)
 630             cl_delete (1);
 631           break;
 632
 633         default:
 634           if (grub_isprint (key))
 635             {
 636               grub_uint32_t str[2];
 637
 638               str[0] = key;
 639               str[1] = '\0';
 640               cl_insert (str);
 641             }
 642           break;
 643         }
 644
 645       grub_refresh ();
 646     }
 647
 648   grub_xputs ("\n");
 649   grub_refresh ();
 650
 651   histpos = 0;
 652   if (strlen_ucs4 (buf) > 0)
 653     {
 654       grub_uint32_t empty[] = { 0 };
 655       grub_history_replace (histpos, buf, llen);
 656       grub_history_add (empty, 0);
 657     }
 658
 659   ret = grub_ucs4_to_utf8_alloc (buf, llen + 1);
 660   grub_free (buf);
 661   grub_free (cl_terms);
 662   return ret;
 663 }