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

   1 /* completion.c - complete a command, a disk, a partition or a file */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2008,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/normal.h>
  21 #include <grub/misc.h>
  22 #include <grub/err.h>
  23 #include <grub/mm.h>
  24 #include <grub/partition.h>
  25 #include <grub/disk.h>
  26 #include <grub/file.h>
  27 #include <grub/parser.h>
  28 #include <grub/extcmd.h>
  29 #include <grub/charset.h>
  30
  31 /* The current word.  */
  32 static const char *current_word;
  33
  34 /* The matched string.  */
  35 static char *match;
  36
  37 /* The count of candidates.  */
  38 static int num_found;
  39
  40 /* The string to be appended.  */
  41 static const char *suffix;
  42
  43 /* The callback function to print items.  */
  44 static void (*print_func) (const char *, grub_completion_type_t, int);
  45
  46 /* The state the command line is in.  */
  47 static grub_parser_state_t cmdline_state;
  48 \f
  49
  50 /* Add a string to the list of possible completions. COMPLETION is the
  51    string that should be added. EXTRA will be appended if COMPLETION
  52    matches uniquely. The type TYPE specifies what kind of data is added.  */
  53 static int
  54 add_completion (const char *completion, const char *extra,
  55                 grub_completion_type_t type)
  56 {
  57   if (grub_strncmp (current_word, completion, grub_strlen (current_word)) == 0)
  58     {
  59       num_found++;
  60
  61       switch (num_found)
  62         {
  63         case 1:
  64           match = grub_strdup (completion);
  65           if (! match)
  66             return 1;
  67           suffix = extra;
  68           break;
  69
  70         case 2:
  71           if (print_func)
  72             print_func (match, type, 0);
  73
  74           /* Fall through.  */
  75
  76         default:
  77           {
  78             char *s = match;
  79             const char *t = completion;
  80
  81             if (print_func)
  82               print_func (completion, type, num_found - 1);
  83
  84             /* Detect the matched portion.  */
  85             while (*s && *t && *s == *t)
  86               {
  87                 s++;
  88                 t++;
  89               }
  90             s = match + grub_getend (match, s);
  91
  92             *s = '\0';
  93           }
  94           break;
  95         }
  96     }
  97
  98   return 0;
  99 }
 100
 101 static int
 102 iterate_partition (grub_disk_t disk, const grub_partition_t p,
 103                    void *data __attribute__ ((unused)))
 104 {
 105   const char *disk_name = disk->name;
 106   char *name;
 107   int ret;
 108   char *part_name;
 109
 110   part_name = grub_partition_get_name (p);
 111   if (! part_name)
 112     return 1;
 113
 114   name = grub_xasprintf ("%s,%s", disk_name, part_name);
 115   grub_free (part_name);
 116
 117   if (! name)
 118     return 1;
 119
 120   ret = add_completion (name, ")", GRUB_COMPLETION_TYPE_PARTITION);
 121   grub_free (name);
 122   return ret;
 123 }
 124
 125 static int
 126 iterate_dir (const char *filename, const struct grub_dirhook_info *info,
 127              void *data __attribute__ ((unused)))
 128 {
 129   if (! info->dir)
 130     {
 131       const char *prefix;
 132       if (cmdline_state == GRUB_PARSER_STATE_DQUOTE)
 133         prefix = "\" ";
 134       else if (cmdline_state == GRUB_PARSER_STATE_QUOTE)
 135         prefix = "\' ";
 136       else
 137         prefix = " ";
 138
 139       if (add_completion (filename, prefix, GRUB_COMPLETION_TYPE_FILE))
 140         return 1;
 141     }
 142   else if (grub_strcmp (filename, ".") && grub_strcmp (filename, ".."))
 143     {
 144       char *fname;
 145
 146       fname = grub_xasprintf ("%s/", filename);
 147       if (add_completion (fname, "", GRUB_COMPLETION_TYPE_FILE))
 148         {
 149           grub_free (fname);
 150           return 1;
 151         }
 152       grub_free (fname);
 153     }
 154
 155   return 0;
 156 }
 157
 158 static int
 159 iterate_dev (const char *devname, void *data __attribute__ ((unused)))
 160 {
 161   grub_device_t dev;
 162
 163   /* Complete the partition part.  */
 164   dev = grub_device_open (devname);
 165
 166   if (!dev)
 167     {
 168       grub_errno = GRUB_ERR_NONE;
 169       return 0;
 170     }
 171
 172   if (grub_strcmp (devname, current_word) == 0)
 173     {
 174       if (add_completion (devname, ")", GRUB_COMPLETION_TYPE_PARTITION))
 175         {
 176           grub_device_close (dev);
 177           return 1;
 178         }
 179
 180       if (dev->disk)
 181         if (grub_partition_iterate (dev->disk, iterate_partition, NULL))
 182           {
 183             grub_device_close (dev);
 184             return 1;
 185           }
 186     }
 187   else if (add_completion (devname, "", GRUB_COMPLETION_TYPE_DEVICE))
 188     {
 189       grub_device_close (dev);
 190       return 1;
 191     }
 192
 193   grub_device_close (dev);
 194   grub_errno = GRUB_ERR_NONE;
 195   return 0;
 196 }
 197
 198 /* Complete a device.  */
 199 static int
 200 complete_device (void)
 201 {
 202   /* Check if this is a device or a partition.  */
 203   char *p = grub_strchr (++current_word, ',');
 204   grub_device_t dev;
 205
 206   if (! p)
 207     {
 208       /* Complete the disk part.  */
 209       if (grub_disk_dev_iterate (iterate_dev, NULL))
 210         return 1;
 211     }
 212   else
 213     {
 214       /* Complete the partition part.  */
 215       *p = '\0';
 216       dev = grub_device_open (current_word);
 217       *p = ',';
 218       grub_errno = GRUB_ERR_NONE;
 219
 220       if (dev)
 221         {
 222           if (dev->disk)
 223             {
 224               if (grub_partition_iterate (dev->disk, iterate_partition, NULL))
 225                 {
 226                   grub_device_close (dev);
 227                   return 1;
 228                 }
 229             }
 230
 231           grub_device_close (dev);
 232         }
 233       else
 234         return 1;
 235     }
 236
 237   return 0;
 238 }
 239
 240 /* Complete a file.  */
 241 static int
 242 complete_file (void)
 243 {
 244   char *device;
 245   char *dir;
 246   char *last_dir;
 247   grub_fs_t fs;
 248   grub_device_t dev;
 249   int ret = 0;
 250
 251   device = grub_file_get_device_name (current_word);
 252   if (grub_errno != GRUB_ERR_NONE)
 253     return 1;
 254
 255   dev = grub_device_open (device);
 256   if (! dev)
 257     {
 258       ret = 1;
 259       goto fail;
 260     }
 261
 262   fs = grub_fs_probe (dev);
 263   if (! fs)
 264     {
 265       ret = 1;
 266       goto fail;
 267     }
 268
 269   dir = grub_strchr (current_word + (device ? 2 + grub_strlen (device) : 0),
 270                      '/');
 271   last_dir = grub_strrchr (current_word, '/');
 272   if (dir)
 273     {
 274       char *dirfile;
 275
 276       current_word = last_dir + 1;
 277
 278       dir = grub_strdup (dir);
 279       if (! dir)
 280         {
 281           ret = 1;
 282           goto fail;
 283         }
 284
 285       /* Cut away the filename part.  */
 286       dirfile = grub_strrchr (dir, '/');
 287       dirfile[1] = '\0';
 288
 289       /* Iterate the directory.  */
 290       (fs->dir) (dev, dir, iterate_dir, NULL);
 291
 292       grub_free (dir);
 293
 294       if (grub_errno)
 295         {
 296           ret = 1;
 297           goto fail;
 298         }
 299     }
 300   else
 301     {
 302       current_word += grub_strlen (current_word);
 303       match = grub_strdup ("/");
 304       if (! match)
 305         {
 306           ret = 1;
 307           goto fail;
 308         }
 309
 310       suffix = "";
 311       num_found = 1;
 312     }
 313
 314  fail:
 315   if (dev)
 316     grub_device_close (dev);
 317   grub_free (device);
 318   return ret;
 319 }
 320
 321 /* Complete an argument.  */
 322 static int
 323 complete_arguments (char *command)
 324 {
 325   grub_command_t cmd;
 326   grub_extcmd_t ext;
 327   const struct grub_arg_option *option;
 328   char shortarg[] = "- ";
 329
 330   cmd = grub_command_find (command);
 331
 332   if (!cmd || !(cmd->flags & GRUB_COMMAND_FLAG_EXTCMD))
 333     return 0;
 334
 335   ext = cmd->data;
 336   if (!ext->options)
 337     return 0;
 338
 339   if (add_completion ("-u", " ", GRUB_COMPLETION_TYPE_ARGUMENT))
 340     return 1;
 341
 342   /* Add the short arguments.  */
 343   for (option = ext->options; option->doc; option++)
 344     {
 345       if (! option->shortarg)
 346         continue;
 347
 348       shortarg[1] = option->shortarg;
 349       if (add_completion (shortarg, " ", GRUB_COMPLETION_TYPE_ARGUMENT))
 350         return 1;
 351
 352     }
 353
 354   /* First add the built-in arguments.  */
 355   if (add_completion ("--help", " ", GRUB_COMPLETION_TYPE_ARGUMENT))
 356     return 1;
 357   if (add_completion ("--usage", " ", GRUB_COMPLETION_TYPE_ARGUMENT))
 358     return 1;
 359
 360   /* Add the long arguments.  */
 361   for (option = ext->options; option->doc; option++)
 362     {
 363       char *longarg;
 364       if (!option->longarg)
 365         continue;
 366
 367       longarg = grub_xasprintf ("--%s", option->longarg);
 368       if (!longarg)
 369         return 1;
 370
 371       if (add_completion (longarg, " ", GRUB_COMPLETION_TYPE_ARGUMENT))
 372         {
 373           grub_free (longarg);
 374           return 1;
 375         }
 376       grub_free (longarg);
 377     }
 378
 379   return 0;
 380 }
 381
 382
 383 static grub_parser_state_t
 384 get_state (const char *cmdline)
 385 {
 386   grub_parser_state_t state = GRUB_PARSER_STATE_TEXT;
 387   char use;
 388
 389   while (*cmdline)
 390     state = grub_parser_cmdline_state (state, *(cmdline++), &use);
 391   return state;
 392 }
 393
 394
 395 /* Try to complete the string in BUF. Return the characters that
 396    should be added to the string.  This command outputs the possible
 397    completions by calling HOOK, in that case set RESTORE to 1 so the
 398    caller can restore the prompt.  */
 399 char *
 400 grub_normal_do_completion (char *buf, int *restore,
 401                            void (*hook) (const char *, grub_completion_type_t, int))
 402 {
 403   int argc;
 404   char **argv;
 405
 406   /* Initialize variables.  */
 407   match = 0;
 408   num_found = 0;
 409   suffix = "";
 410   print_func = hook;
 411
 412   *restore = 1;
 413
 414   if (grub_parser_split_cmdline (buf, 0, 0, &argc, &argv))
 415     return 0;
 416
 417   if (argc == 0)
 418     current_word = "";
 419   else
 420     current_word = argv[argc - 1];
 421
 422   if (argc > 1 && ! grub_strcmp (argv[0], "set"))
 423     {
 424       char *equals = grub_strchr (current_word, '=');
 425       if (equals)
 426         /* Complete the value of the variable.  */
 427         current_word = equals + 1;
 428     }
 429
 430   /* Determine the state the command line is in, depending on the
 431      state, it can be determined how to complete.  */
 432   cmdline_state = get_state (buf);
 433
 434   if (argc == 1 || argc == 0)
 435     {
 436       /* Complete a command.  */
 437       grub_command_t cmd;
 438       FOR_COMMANDS(cmd)
 439       {
 440         if (cmd->prio & GRUB_COMMAND_FLAG_ACTIVE)
 441           {
 442             if (add_completion (cmd->name, " ", GRUB_COMPLETION_TYPE_COMMAND))
 443               goto fail;
 444           }
 445       }
 446     }
 447   else if (*current_word == '-')
 448     {
 449       if (complete_arguments (buf))
 450         goto fail;
 451     }
 452   else if (*current_word == '(' && ! grub_strchr (current_word, ')'))
 453     {
 454       /* Complete a device.  */
 455       if (complete_device ())
 456             goto fail;
 457     }
 458   else
 459     {
 460       /* Complete a file.  */
 461       if (complete_file ())
 462         goto fail;
 463     }
 464
 465   /* If more than one match is found those matches will be printed and
 466      the prompt should be restored.  */
 467   if (num_found > 1)
 468     *restore = 1;
 469   else
 470     *restore = 0;
 471
 472   /* Return the part that matches.  */
 473   if (match)
 474     {
 475       char *ret;
 476       char *escstr;
 477       char *newstr;
 478       int current_len;
 479       int match_len;
 480       int spaces = 0;
 481
 482       current_len = grub_strlen (current_word);
 483       match_len = grub_strlen (match);
 484
 485       /* Count the number of spaces that have to be escaped.  XXX:
 486          More than just spaces have to be escaped.  */
 487       for (escstr = match + current_len; *escstr; escstr++)
 488         if (*escstr == ' ')
 489           spaces++;
 490
 491       ret = grub_malloc (match_len - current_len + grub_strlen (suffix) + spaces + 1);
 492       newstr = ret;
 493       for (escstr = match + current_len; *escstr; escstr++)
 494         {
 495           if (*escstr == ' ' && cmdline_state != GRUB_PARSER_STATE_QUOTE
 496               && cmdline_state != GRUB_PARSER_STATE_QUOTE)
 497             *(newstr++) = '\\';
 498           *(newstr++) = *escstr;
 499         }
 500       *newstr = '\0';
 501
 502       if (num_found == 1)
 503         grub_strcpy (newstr, suffix);
 504
 505       if (*ret == '\0')
 506         {
 507           grub_free (ret);
 508           goto fail;
 509         }
 510
 511       if (argc != 0)
 512         grub_free (argv[0]);
 513       grub_free (match);
 514       return ret;
 515     }
 516
 517  fail:
 518   if (argc != 0)
 519     {
 520       grub_free (argv[0]);
 521       grub_free (argv);
 522     }
 523   grub_free (match);
 524   grub_errno = GRUB_ERR_NONE;
 525
 526   return 0;
 527 }