lib/widget/input_complete.c

   1 /*
   2    Input line filename/username/hostname/variable/command completion.
   3    (Let mc type for you...)
   4
   5    Copyright (C) 1995-2024
   6    Free Software Foundation, Inc.
   7
   8    Written by:
   9    Jakub Jelinek, 1995
  10    Slava Zanko <slavazanko@gmail.com>, 2013
  11    Andrew Borodin <aborodin@vmail.ru>, 2013-2022
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /** \file lib/widget/input_complete.c
  30  *  \brief Source: Input line filename/username/hostname/variable/command completion
  31  */
  32
  33 #include <config.h>
  34
  35 #include <ctype.h>
  36 #include <limits.h>             /* MB_LEN_MAX */
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <dirent.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <pwd.h>
  44 #include <unistd.h>
  45
  46 #include "lib/global.h"
  47
  48 #include "lib/tty/tty.h"
  49 #include "lib/tty/key.h"        /* XCTRL and ALT macros */
  50 #include "lib/vfs/vfs.h"
  51 #include "lib/strutil.h"
  52 #include "lib/util.h"
  53 #include "lib/widget.h"
  54
  55 /*** global variables ****************************************************************************/
  56
  57 /* Linux declares environ in <unistd.h>, so don't repeat it here. */
  58 #if (!(defined(__linux__) && defined (__USE_GNU)) && !defined(__CYGWIN__))
  59 extern char **environ;
  60 #endif
  61
  62 /*** file scope macro definitions ****************************************************************/
  63
  64 /* #define DO_COMPLETION_DEBUG */
  65 #ifdef DO_COMPLETION_DEBUG
  66 #define SHOW_C_CTX(func) fprintf(stderr, "%s: text='%s' flags=%s\n", func, text, show_c_flags(flags))
  67 #else
  68 #define SHOW_C_CTX(func)
  69 #endif /* DO_CMPLETION_DEBUG */
  70
  71 #define DO_INSERTION 1
  72 #define DO_QUERY     2
  73
  74 /*** file scope type declarations ****************************************************************/
  75
  76 typedef char *CompletionFunction (const char *text, int state, input_complete_t flags);
  77
  78 typedef struct
  79 {
  80     size_t in_command_position;
  81     char *word;
  82     char *p;
  83     char *q;
  84     char *r;
  85     gboolean is_cd;
  86     input_complete_t flags;
  87 } try_complete_automation_state_t;
  88
  89 /*** forward declarations (file scope functions) *************************************************/
  90
  91 char **try_complete (char *text, int *lc_start, int *lc_end, input_complete_t flags);
  92 void complete_engine_fill_completions (WInput * in);
  93
  94 /*** file scope variables ************************************************************************/
  95
  96 static char **hosts = NULL;
  97 static char **hosts_p = NULL;
  98 static int hosts_alloclen = 0;
  99
 100 static WInput *input;
 101 static int min_end;
 102 static int start = 0;
 103 static int end = 0;
 104
 105 /* --------------------------------------------------------------------------------------------- */
 106 /*** file scope functions ************************************************************************/
 107 /* --------------------------------------------------------------------------------------------- */
 108
 109 #ifdef DO_COMPLETION_DEBUG
 110 /**
 111  * Useful to print/debug completion flags
 112  */
 113 static const char *
 114 show_c_flags (input_complete_t flags)
 115 {
 116     static char s_cf[] = "FHCVUDS";
 117
 118     s_cf[0] = (flags & INPUT_COMPLETE_FILENAMES) != 0 ? 'F' : ' ';
 119     s_cf[1] = (flags & INPUT_COMPLETE_HOSTNAMES) != 0 ? 'H' : ' ';
 120     s_cf[2] = (flags & INPUT_COMPLETE_COMMANDS) != 0 ? 'C' : ' ';
 121     s_cf[3] = (flags & INPUT_COMPLETE_VARIABLES) != 0 ? 'V' : ' ';
 122     s_cf[4] = (flags & INPUT_COMPLETE_USERNAMES) != 0 ? 'U' : ' ';
 123     s_cf[5] = (flags & INPUT_COMPLETE_CD) != 0 ? 'D' : ' ';
 124     s_cf[6] = (flags & INPUT_COMPLETE_SHELL_ESC) != 0 ? 'S' : ' ';
 125
 126     return s_cf;
 127 }
 128 #endif /* DO_CMPLETION_DEBUG */
 129
 130 /* --------------------------------------------------------------------------------------------- */
 131
 132 static char *
 133 filename_completion_function (const char *text, int state, input_complete_t flags)
 134 {
 135     static DIR *directory = NULL;
 136     static char *filename = NULL;
 137     static char *dirname = NULL;
 138     static char *users_dirname = NULL;
 139     static size_t filename_len = 0;
 140     static vfs_path_t *dirname_vpath = NULL;
 141
 142     gboolean isdir = TRUE, isexec = FALSE;
 143     struct vfs_dirent *entry = NULL;
 144
 145     SHOW_C_CTX ("filename_completion_function");
 146
 147     if (text != NULL && (flags & INPUT_COMPLETE_SHELL_ESC) != 0)
 148     {
 149         char *u_text;
 150         char *result;
 151         char *e_result;
 152
 153         u_text = str_shell_unescape (text);
 154
 155         result = filename_completion_function (u_text, state, flags & (~INPUT_COMPLETE_SHELL_ESC));
 156         g_free (u_text);
 157
 158         e_result = str_shell_escape (result);
 159         g_free (result);
 160
 161         return e_result;
 162     }
 163
 164     /* If we're starting the match process, initialize us a bit. */
 165     if (state == 0)
 166     {
 167         const char *temp;
 168
 169         g_free (dirname);
 170         g_free (filename);
 171         g_free (users_dirname);
 172         vfs_path_free (dirname_vpath, TRUE);
 173
 174         if ((*text != '\0') && (temp = strrchr (text, PATH_SEP)) != NULL)
 175         {
 176             filename = g_strdup (++temp);
 177             dirname = g_strndup (text, temp - text);
 178         }
 179         else
 180         {
 181             dirname = g_strdup (".");
 182             filename = g_strdup (text);
 183         }
 184
 185         /* We aren't done yet.  We also support the "~user" syntax. */
 186
 187         /* Save the version of the directory that the user typed. */
 188         users_dirname = dirname;
 189         dirname = tilde_expand (dirname);
 190         canonicalize_pathname (dirname);
 191         dirname_vpath = vfs_path_from_str (dirname);
 192
 193         /* Here we should do something with variable expansion
 194            and `command`.
 195            Maybe a dream - UNIMPLEMENTED yet. */
 196
 197         directory = mc_opendir (dirname_vpath);
 198         filename_len = strlen (filename);
 199     }
 200
 201     /* Now that we have some state, we can read the directory. */
 202
 203     while (directory != NULL && (entry = mc_readdir (directory)) != NULL)
 204     {
 205         if (!str_is_valid_string (entry->d_name))
 206             continue;
 207
 208         /* Special case for no filename.
 209            All entries except "." and ".." match. */
 210         if (filename_len == 0)
 211         {
 212             if (DIR_IS_DOT (entry->d_name) || DIR_IS_DOTDOT (entry->d_name))
 213                 continue;
 214         }
 215         else
 216         {
 217             /* Otherwise, if these match up to the length of filename, then
 218                it may be a match. */
 219             if ((entry->d_name[0] != filename[0]) ||
 220                 ((NLENGTH (entry)) < filename_len) ||
 221                 strncmp (filename, entry->d_name, filename_len) != 0)
 222                 continue;
 223         }
 224
 225         isdir = TRUE;
 226         isexec = FALSE;
 227
 228         {
 229             struct stat tempstat;
 230             vfs_path_t *tmp_vpath;
 231
 232             tmp_vpath = vfs_path_build_filename (dirname, entry->d_name, (char *) NULL);
 233
 234             /* Unix version */
 235             if (mc_stat (tmp_vpath, &tempstat) == 0)
 236             {
 237                 uid_t my_uid;
 238                 gid_t my_gid;
 239
 240                 my_uid = getuid ();
 241                 my_gid = getgid ();
 242
 243                 if (!S_ISDIR (tempstat.st_mode))
 244                 {
 245                     isdir = FALSE;
 246
 247                     if ((my_uid == 0 && (tempstat.st_mode & 0111) != 0) ||
 248                         (my_uid == tempstat.st_uid && (tempstat.st_mode & 0100) != 0) ||
 249                         (my_gid == tempstat.st_gid && (tempstat.st_mode & 0010) != 0) ||
 250                         (tempstat.st_mode & 0001) != 0)
 251                         isexec = TRUE;
 252                 }
 253             }
 254             else
 255             {
 256                 /* stat failed, strange. not a dir in any case */
 257                 isdir = FALSE;
 258             }
 259             vfs_path_free (tmp_vpath, TRUE);
 260         }
 261
 262         if ((flags & INPUT_COMPLETE_COMMANDS) != 0 && (isexec || isdir))
 263             break;
 264         if ((flags & INPUT_COMPLETE_CD) != 0 && isdir)
 265             break;
 266         if ((flags & INPUT_COMPLETE_FILENAMES) != 0)
 267             break;
 268     }
 269
 270     if (entry == NULL)
 271     {
 272         if (directory != NULL)
 273         {
 274             mc_closedir (directory);
 275             directory = NULL;
 276         }
 277         MC_PTR_FREE (dirname);
 278         vfs_path_free (dirname_vpath, TRUE);
 279         dirname_vpath = NULL;
 280         MC_PTR_FREE (filename);
 281         MC_PTR_FREE (users_dirname);
 282         return NULL;
 283     }
 284
 285     {
 286         GString *temp;
 287
 288         temp = g_string_sized_new (16);
 289
 290         if (users_dirname != NULL && (users_dirname[0] != '.' || users_dirname[1] != '\0'))
 291         {
 292             g_string_append (temp, users_dirname);
 293
 294             /* We need a '/' at the end. */
 295             if (!IS_PATH_SEP (temp->str[temp->len - 1]))
 296                 g_string_append_c (temp, PATH_SEP);
 297         }
 298         g_string_append (temp, entry->d_name);
 299         if (isdir)
 300             g_string_append_c (temp, PATH_SEP);
 301
 302         return g_string_free (temp, FALSE);
 303     }
 304 }
 305
 306 /* --------------------------------------------------------------------------------------------- */
 307 /** We assume here that text[0] == '~' , if you want to call it in another way,
 308    you have to change the code */
 309
 310 static char *
 311 username_completion_function (const char *text, int state, input_complete_t flags)
 312 {
 313     static struct passwd *entry = NULL;
 314     static size_t userlen = 0;
 315
 316     (void) flags;
 317     SHOW_C_CTX ("username_completion_function");
 318
 319     if (text[0] == '\\' && text[1] == '~')
 320         text++;
 321     if (state == 0)
 322     {                           /* Initialization stuff */
 323         setpwent ();
 324         userlen = strlen (text + 1);
 325     }
 326
 327     while ((entry = getpwent ()) != NULL)
 328     {
 329         /* Null usernames should result in all users as possible completions. */
 330         if (userlen == 0)
 331             break;
 332         if (text[1] == entry->pw_name[0] && strncmp (text + 1, entry->pw_name, userlen) == 0)
 333             break;
 334     }
 335
 336     if (entry != NULL)
 337         return g_strconcat ("~", entry->pw_name, PATH_SEP_STR, (char *) NULL);
 338
 339     endpwent ();
 340     return NULL;
 341 }
 342
 343 /* --------------------------------------------------------------------------------------------- */
 344 /** We assume text [0] == '$' and want to have a look at text [1], if it is
 345    equal to '{', so that we should append '}' at the end */
 346
 347 static char *
 348 variable_completion_function (const char *text, int state, input_complete_t flags)
 349 {
 350     static char **env_p = NULL;
 351     static gboolean isbrace = FALSE;
 352     static size_t varlen = 0;
 353     const char *p = NULL;
 354
 355     (void) flags;
 356     SHOW_C_CTX ("variable_completion_function");
 357
 358     if (state == 0)
 359     {                           /* Initialization stuff */
 360         isbrace = (text[1] == '{');
 361         varlen = strlen (text + 1 + isbrace);
 362         env_p = environ;
 363     }
 364
 365     while (*env_p != NULL)
 366     {
 367         p = strchr (*env_p, '=');
 368         if (p != NULL && ((size_t) (p - *env_p) >= varlen)
 369             && strncmp (text + 1 + isbrace, *env_p, varlen) == 0)
 370             break;
 371         env_p++;
 372     }
 373
 374     if (*env_p == NULL)
 375         return NULL;
 376
 377     {
 378         GString *temp;
 379
 380         temp = g_string_new_len (*env_p, p - *env_p);
 381
 382         if (isbrace)
 383         {
 384             g_string_prepend_c (temp, '{');
 385             g_string_append_c (temp, '}');
 386         }
 387         g_string_prepend_c (temp, '$');
 388
 389         env_p++;
 390
 391         return g_string_free (temp, FALSE);
 392     }
 393 }
 394
 395 /* --------------------------------------------------------------------------------------------- */
 396
 397 static void
 398 fetch_hosts (const char *filename)
 399 {
 400     FILE *file;
 401     char buffer[256];
 402     char *name;
 403     char *lc_start;
 404     char *bi;
 405
 406     file = fopen (filename, "r");
 407     if (file == NULL)
 408         return;
 409
 410     while (fgets (buffer, sizeof (buffer) - 1, file) != NULL)
 411     {
 412         /* Skip to first character. */
 413         for (bi = buffer; bi[0] != '\0' && str_isspace (bi); str_next_char (&bi))
 414             ;
 415
 416         /* Ignore comments... */
 417         if (bi[0] == '#')
 418             continue;
 419
 420         /* Handle $include. */
 421         if (strncmp (bi, "$include ", 9) == 0)
 422         {
 423             char *includefile, *t;
 424
 425             /* Find start of filename. */
 426             includefile = bi + 9;
 427             while (*includefile != '\0' && whitespace (*includefile))
 428                 includefile++;
 429             t = includefile;
 430
 431             /* Find end of filename. */
 432             while (t[0] != '\0' && !str_isspace (t))
 433                 str_next_char (&t);
 434             *t = '\0';
 435
 436             fetch_hosts (includefile);
 437             continue;
 438         }
 439
 440         /* Skip IP #s. */
 441         while (bi[0] != '\0' && !str_isspace (bi))
 442             str_next_char (&bi);
 443
 444         /* Get the host names separated by white space. */
 445         while (bi[0] != '\0' && bi[0] != '#')
 446         {
 447             while (bi[0] != '\0' && str_isspace (bi))
 448                 str_next_char (&bi);
 449             if (bi[0] == '#')
 450                 continue;
 451             for (lc_start = bi; bi[0] != '\0' && !str_isspace (bi); str_next_char (&bi))
 452                 ;
 453
 454             if (bi == lc_start)
 455                 continue;
 456
 457             name = g_strndup (lc_start, bi - lc_start);
 458
 459             {
 460                 char **host_p;
 461                 int j;
 462
 463                 j = hosts_p - hosts;
 464
 465                 if (j >= hosts_alloclen)
 466                 {
 467                     hosts_alloclen += 30;
 468                     hosts = g_renew (char *, hosts, hosts_alloclen + 1);
 469                     hosts_p = hosts + j;
 470                 }
 471
 472                 for (host_p = hosts; host_p < hosts_p; host_p++)
 473                     if (strcmp (name, *host_p) == 0)
 474                         break;  /* We do not want any duplicates */
 475
 476                 if (host_p == hosts_p)
 477                 {
 478                     *(hosts_p++) = name;
 479                     *hosts_p = NULL;
 480                 }
 481                 else
 482                     g_free (name);
 483             }
 484         }
 485     }
 486
 487     fclose (file);
 488 }
 489
 490 /* --------------------------------------------------------------------------------------------- */
 491
 492 static char *
 493 hostname_completion_function (const char *text, int state, input_complete_t flags)
 494 {
 495     static char **host_p = NULL;
 496     static size_t textstart = 0;
 497     static size_t textlen = 0;
 498
 499     (void) flags;
 500     SHOW_C_CTX ("hostname_completion_function");
 501
 502     if (state == 0)
 503     {                           /* Initialization stuff */
 504         const char *p;
 505
 506         g_strfreev (hosts);
 507         hosts_alloclen = 30;
 508         hosts = g_new (char *, hosts_alloclen + 1);
 509         *hosts = NULL;
 510         hosts_p = hosts;
 511         p = getenv ("HOSTFILE");
 512         fetch_hosts (p != NULL ? p : "/etc/hosts");
 513         host_p = hosts;
 514         textstart = (*text == '@') ? 1 : 0;
 515         textlen = strlen (text + textstart);
 516     }
 517
 518     for (; *host_p != NULL; host_p++)
 519     {
 520         if (textlen == 0)
 521             break;              /* Match all of them */
 522         if (strncmp (text + textstart, *host_p, textlen) == 0)
 523             break;
 524     }
 525
 526     if (*host_p == NULL)
 527     {
 528         g_strfreev (hosts);
 529         hosts = NULL;
 530         return NULL;
 531     }
 532
 533     {
 534         GString *temp;
 535
 536         temp = g_string_sized_new (8);
 537
 538         if (textstart != 0)
 539             g_string_append_c (temp, '@');
 540         g_string_append (temp, *host_p);
 541         host_p++;
 542
 543         return g_string_free (temp, FALSE);
 544     }
 545 }
 546
 547 /* --------------------------------------------------------------------------------------------- */
 548 /**
 549  * This is the function to call when the word to complete is in a position
 550  * where a command word can be found. It looks around $PATH, looking for
 551  * commands that match. It also scans aliases, function names, and the
 552  * table of shell built-ins.
 553  */
 554
 555 static char *
 556 command_completion_function (const char *text, int state, input_complete_t flags)
 557 {
 558     static const char *path_end = NULL;
 559     static gboolean isabsolute = FALSE;
 560     static int phase = 0;
 561     static size_t text_len = 0;
 562     static const char *const *words = NULL;
 563     static char *path = NULL;
 564     static char *cur_path = NULL;
 565     static char *cur_word = NULL;
 566     static int init_state = 0;
 567     static const char *const bash_reserved[] = {
 568         "if", "then", "else", "elif", "fi", "case", "esac", "for",
 569         "select", "while", "until", "do", "done", "in", "function", 0
 570     };
 571     static const char *const bash_builtins[] = {
 572         "alias", "bg", "bind", "break", "builtin", "cd", "command",
 573         "continue", "declare", "dirs", "echo", "enable", "eval",
 574         "exec", "exit", "export", "fc", "fg", "getopts", "hash",
 575         "help", "history", "jobs", "kill", "let", "local", "logout",
 576         "popd", "pushd", "pwd", "read", "readonly", "return", "set",
 577         "shift", "source", "suspend", "test", "times", "trap", "type",
 578         "typeset", "ulimit", "umask", "unalias", "unset", "wait", 0
 579     };
 580
 581     char *u_text;
 582     char *p, *found;
 583
 584     SHOW_C_CTX ("command_completion_function");
 585
 586     if ((flags & INPUT_COMPLETE_COMMANDS) == 0)
 587         return NULL;
 588
 589     u_text = str_shell_unescape (text);
 590     flags &= ~INPUT_COMPLETE_SHELL_ESC;
 591
 592     if (state == 0)
 593     {                           /* Initialize us a little bit */
 594         isabsolute = strchr (u_text, PATH_SEP) != NULL;
 595         if (!isabsolute)
 596         {
 597             words = bash_reserved;
 598             phase = 0;
 599             text_len = strlen (u_text);
 600
 601             if (path == NULL)
 602             {
 603                 path = g_strdup (getenv ("PATH"));
 604                 if (path != NULL)
 605                 {
 606                     p = path;
 607                     path_end = strchr (p, '\0');
 608                     while ((p = strchr (p, PATH_ENV_SEP)) != NULL)
 609                         *p++ = '\0';
 610                 }
 611             }
 612         }
 613     }
 614
 615     if (isabsolute)
 616     {
 617         p = filename_completion_function (u_text, state, flags);
 618
 619         if (p != NULL)
 620         {
 621             char *temp_p = p;
 622
 623             p = str_shell_escape (p);
 624             g_free (temp_p);
 625         }
 626
 627         g_free (u_text);
 628         return p;
 629     }
 630
 631     found = NULL;
 632     switch (phase)
 633     {
 634     case 0:                    /* Reserved words */
 635         for (; *words != NULL; words++)
 636             if (strncmp (*words, u_text, text_len) == 0)
 637             {
 638                 g_free (u_text);
 639                 return g_strdup (*(words++));
 640             }
 641         phase++;
 642         words = bash_builtins;
 643         MC_FALLTHROUGH;
 644     case 1:                    /* Builtin commands */
 645         for (; *words != NULL; words++)
 646             if (strncmp (*words, u_text, text_len) == 0)
 647             {
 648                 g_free (u_text);
 649                 return g_strdup (*(words++));
 650             }
 651         phase++;
 652         if (path == NULL)
 653             break;
 654         cur_path = path;
 655         cur_word = NULL;
 656         MC_FALLTHROUGH;
 657     case 2:                    /* And looking through the $PATH */
 658         while (found == NULL)
 659         {
 660             if (cur_word == NULL)
 661             {
 662                 char *expanded;
 663
 664                 if (cur_path >= path_end)
 665                     break;
 666                 expanded = tilde_expand (*cur_path != '\0' ? cur_path : ".");
 667                 cur_word = mc_build_filename (expanded, u_text, (char *) NULL);
 668                 g_free (expanded);
 669                 cur_path = strchr (cur_path, '\0') + 1;
 670                 init_state = state;
 671             }
 672             found = filename_completion_function (cur_word, state - init_state, flags);
 673             if (found == NULL)
 674                 MC_PTR_FREE (cur_word);
 675         }
 676         MC_FALLTHROUGH;
 677     default:
 678         break;
 679     }
 680
 681     if (found == NULL)
 682         MC_PTR_FREE (path);
 683     else
 684     {
 685         p = strrchr (found, PATH_SEP);
 686         if (p != NULL)
 687         {
 688             char *tmp = found;
 689
 690             found = str_shell_escape (p + 1);
 691             g_free (tmp);
 692         }
 693     }
 694
 695     g_free (u_text);
 696     return found;
 697 }
 698
 699 /* --------------------------------------------------------------------------------------------- */
 700
 701 static int
 702 match_compare (const void *a, const void *b)
 703 {
 704     return strcmp (*(char *const *) a, *(char *const *) b);
 705 }
 706
 707 /* --------------------------------------------------------------------------------------------- */
 708 /** Returns an array of char * matches with the longest common denominator
 709    in the 1st entry. Then a NULL terminated list of different possible
 710    completions follows.
 711    You have to supply your own CompletionFunction with the word you
 712    want to complete as the first argument and an count of previous matches
 713    as the second.
 714    In case no matches were found we return NULL. */
 715
 716 static char **
 717 completion_matches (const char *text, CompletionFunction entry_function, input_complete_t flags)
 718 {
 719     /* Number of slots in match_list. */
 720     size_t match_list_size = 30;
 721     /* The list of matches. */
 722     char **match_list;
 723     /* Number of matches actually found. */
 724     size_t matches = 0;
 725
 726     /* Temporary string binder. */
 727     char *string;
 728
 729     match_list = g_new (char *, match_list_size + 1);
 730     match_list[1] = NULL;
 731
 732     while ((string = (*entry_function) (text, matches, flags)) != NULL)
 733     {
 734         if (matches + 1 == match_list_size)
 735         {
 736             match_list_size += 30;
 737             match_list = (char **) g_renew (char *, match_list, match_list_size + 1);
 738         }
 739         match_list[++matches] = string;
 740         match_list[matches + 1] = NULL;
 741     }
 742
 743     /* If there were any matches, then look through them finding out the
 744        lowest common denominator.  That then becomes match_list[0]. */
 745     if (matches == 0)
 746         MC_PTR_FREE (match_list);       /* There were no matches. */
 747     else
 748     {
 749         /* If only one match, just use that. */
 750         if (matches == 1)
 751         {
 752             match_list[0] = match_list[1];
 753             match_list[1] = NULL;
 754         }
 755         else
 756         {
 757             size_t i = 1;
 758             int low = 4096;     /* Count of max-matched characters. */
 759             size_t j;
 760
 761             qsort (match_list + 1, matches, sizeof (char *), match_compare);
 762
 763             /* And compare each member of the list with
 764                the next, finding out where they stop matching.
 765                If we find two equal strings, we have to put one away... */
 766
 767             j = i + 1;
 768             while (j < matches + 1)
 769             {
 770                 char *si, *sj;
 771                 char *ni, *nj;
 772
 773                 for (si = match_list[i], sj = match_list[j]; si[0] != '\0' && sj[0] != '\0';)
 774                 {
 775
 776                     ni = str_get_next_char (si);
 777                     nj = str_get_next_char (sj);
 778
 779                     if (ni - si != nj - sj)
 780                         break;
 781                     if (strncmp (si, sj, ni - si) != 0)
 782                         break;
 783
 784                     si = ni;
 785                     sj = nj;
 786                 }
 787
 788                 if (si[0] == '\0' && sj[0] == '\0')
 789                 {               /* Two equal strings */
 790                     g_free (match_list[j]);
 791                     j++;
 792                     if (j > matches)
 793                         break;
 794                     continue;   /* Look for a run of equal strings */
 795                 }
 796                 else if (low > si - match_list[i])
 797                     low = si - match_list[i];
 798                 if (i + 1 != j) /* So there's some gap */
 799                     match_list[i + 1] = match_list[j];
 800                 i++;
 801                 j++;
 802             }
 803             matches = i;
 804             match_list[matches + 1] = NULL;
 805             match_list[0] = g_strndup (match_list[1], low);
 806         }
 807     }
 808
 809     return match_list;
 810 }
 811
 812 /* --------------------------------------------------------------------------------------------- */
 813 /** Check if directory completion is needed */
 814 static gboolean
 815 check_is_cd (const char *text, int lc_start, input_complete_t flags)
 816 {
 817     const char *p, *q;
 818
 819     SHOW_C_CTX ("check_is_cd");
 820
 821     if ((flags & INPUT_COMPLETE_CD) == 0)
 822         return FALSE;
 823
 824     /* Skip initial spaces */
 825     p = text;
 826     q = text + lc_start;
 827     while (p < q && p[0] != '\0' && str_isspace (p))
 828         str_cnext_char (&p);
 829
 830     /* Check if the command is "cd" and the cursor is after it */
 831     return (p[0] == 'c' && p[1] == 'd' && str_isspace (p + 2) && p + 2 < q);
 832 }
 833
 834 /* --------------------------------------------------------------------------------------------- */
 835
 836 static void
 837 try_complete_commands_prepare (try_complete_automation_state_t * state, char *text, int *lc_start)
 838 {
 839     const char *command_separator_chars = ";|&{(`";
 840     char *ti;
 841
 842     if (*lc_start == 0)
 843         ti = text;
 844     else
 845     {
 846         ti = str_get_prev_char (&text[*lc_start]);
 847         while (ti > text && whitespace (ti[0]))
 848             str_prev_char (&ti);
 849     }
 850
 851     if (ti == text)
 852         state->in_command_position++;
 853     else if (strchr (command_separator_chars, ti[0]) != NULL)
 854     {
 855         state->in_command_position++;
 856         if (ti != text)
 857         {
 858             int this_char, prev_char;
 859
 860             /* Handle the two character tokens '>&', '<&', and '>|'.
 861                We are not in a command position after one of these. */
 862             this_char = ti[0];
 863             prev_char = str_get_prev_char (ti)[0];
 864
 865             /* Quoted */
 866             if ((this_char == '&' && (prev_char == '<' || prev_char == '>'))
 867                 || (this_char == '|' && prev_char == '>') || (ti != text
 868                                                               && str_get_prev_char (ti)[0] == '\\'))
 869                 state->in_command_position = 0;
 870         }
 871     }
 872 }
 873
 874 /* --------------------------------------------------------------------------------------------- */
 875
 876 static void
 877 try_complete_find_start_sign (try_complete_automation_state_t * state)
 878 {
 879     if ((state->flags & INPUT_COMPLETE_COMMANDS) != 0)
 880         state->p = strrchr (state->word, '`');
 881     if ((state->flags & (INPUT_COMPLETE_COMMANDS | INPUT_COMPLETE_VARIABLES)) != 0)
 882     {
 883         state->q = strrchr (state->word, '$');
 884
 885         /* don't substitute variable in \$ case */
 886         if (str_is_char_escaped (state->word, state->q))
 887         {
 888             /* drop '\\' */
 889             str_move (state->q - 1, state->q);
 890             /* adjust flags */
 891             state->flags &= ~INPUT_COMPLETE_VARIABLES;
 892             state->q = NULL;
 893         }
 894     }
 895     if ((state->flags & INPUT_COMPLETE_HOSTNAMES) != 0)
 896         state->r = strrchr (state->word, '@');
 897     if (state->q != NULL && state->q[1] == '(' && (state->flags & INPUT_COMPLETE_COMMANDS) != 0)
 898     {
 899         if (state->q > state->p)
 900             state->p = str_get_next_char (state->q);
 901         state->q = NULL;
 902     }
 903 }
 904
 905 /* --------------------------------------------------------------------------------------------- */
 906
 907 static char **
 908 try_complete_all_possible (try_complete_automation_state_t * state, char *text, int *lc_start)
 909 {
 910     char **matches = NULL;
 911
 912     if (state->in_command_position != 0)
 913     {
 914         SHOW_C_CTX ("try_complete:cmd_subst");
 915         matches =
 916             completion_matches (state->word, command_completion_function,
 917                                 state->flags & (~INPUT_COMPLETE_FILENAMES));
 918     }
 919     else if ((state->flags & INPUT_COMPLETE_FILENAMES) != 0)
 920     {
 921         if (state->is_cd)
 922             state->flags &= ~(INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_COMMANDS);
 923         SHOW_C_CTX ("try_complete:filename_subst_1");
 924         matches = completion_matches (state->word, filename_completion_function, state->flags);
 925
 926         if (matches == NULL && state->is_cd && !IS_PATH_SEP (*state->word) && *state->word != '~')
 927         {
 928             state->q = text + *lc_start;
 929             for (state->p = text;
 930                  *state->p != '\0' && state->p < state->q && whitespace (*state->p);
 931                  str_next_char (&state->p))
 932                 ;
 933             if (strncmp (state->p, "cd", 2) == 0)
 934                 for (state->p += 2;
 935                      *state->p != '\0' && state->p < state->q && whitespace (*state->p);
 936                      str_next_char (&state->p))
 937                     ;
 938             if (state->p == state->q)
 939             {
 940                 char *cdpath_ref, *cdpath;
 941                 char c;
 942
 943                 cdpath_ref = g_strdup (getenv ("CDPATH"));
 944                 cdpath = cdpath_ref;
 945                 c = (cdpath == NULL) ? '\0' : ':';
 946
 947                 while (matches == NULL && c == ':')
 948                 {
 949                     char *s;
 950
 951                     s = strchr (cdpath, ':');
 952                     /* cppcheck-suppress nullPointer */
 953                     if (s == NULL)
 954                         s = strchr (cdpath, '\0');
 955                     c = *s;
 956                     *s = '\0';
 957                     if (*cdpath != '\0')
 958                     {
 959                         state->r = mc_build_filename (cdpath, state->word, (char *) NULL);
 960                         SHOW_C_CTX ("try_complete:filename_subst_2");
 961                         matches =
 962                             completion_matches (state->r, filename_completion_function,
 963                                                 state->flags);
 964                         g_free (state->r);
 965                     }
 966                     *s = c;
 967                     cdpath = str_get_next_char (s);
 968                 }
 969                 g_free (cdpath_ref);
 970             }
 971         }
 972     }
 973     return matches;
 974 }
 975
 976 /* --------------------------------------------------------------------------------------------- */
 977
 978 static gboolean
 979 insert_text (WInput * in, char *text, ssize_t size)
 980 {
 981     size_t text_len;
 982     int buff_len;
 983     ssize_t new_size;
 984
 985     text_len = strlen (text);
 986     buff_len = str_length (in->buffer->str);
 987     if (size < 0)
 988         size = (ssize_t) text_len;
 989     else
 990         size = MIN (size, (ssize_t) text_len);
 991
 992     new_size = size + start - end;
 993     if (new_size != 0)
 994     {
 995         /* make a hole within buffer */
 996
 997         size_t tail_len;
 998
 999         tail_len = in->buffer->len - end;
1000         if (tail_len != 0)
1001         {
1002             char *tail;
1003             size_t hole_end;
1004
1005             tail = g_strndup (in->buffer->str + end, tail_len);
1006
1007             hole_end = end + new_size;
1008             if (in->buffer->len < hole_end)
1009                 g_string_set_size (in->buffer, hole_end + tail_len);
1010
1011             g_string_overwrite_len (in->buffer, hole_end, tail, tail_len);
1012
1013             g_free (tail);
1014         }
1015     }
1016
1017     g_string_overwrite_len (in->buffer, start, text, size);
1018
1019     in->point += str_length (in->buffer->str) - buff_len;
1020     input_update (in, TRUE);
1021     end += new_size;
1022
1023     return new_size != 0;
1024 }
1025
1026 /* --------------------------------------------------------------------------------------------- */
1027
1028 static cb_ret_t
1029 complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
1030 {
1031     static int bl = 0;
1032
1033     WGroup *g = GROUP (w);
1034     WDialog *h = DIALOG (w);
1035
1036     switch (msg)
1037     {
1038     case MSG_KEY:
1039         switch (parm)
1040         {
1041         case KEY_LEFT:
1042         case KEY_RIGHT:
1043             bl = 0;
1044             h->ret_value = 0;
1045             dlg_close (h);
1046             return MSG_HANDLED;
1047
1048         case KEY_BACKSPACE:
1049             bl = 0;
1050             /* exit from completion list if input line is empty */
1051             if (end == 0)
1052             {
1053                 h->ret_value = 0;
1054                 dlg_close (h);
1055             }
1056             /* Refill the list box and start again */
1057             else if (end == min_end)
1058             {
1059                 end = str_get_prev_char (input->buffer->str + end) - input->buffer->str;
1060                 input_handle_char (input, parm);
1061                 h->ret_value = B_USER;
1062                 dlg_close (h);
1063             }
1064             else
1065             {
1066                 int new_end;
1067                 int i;
1068                 GList *e;
1069
1070                 new_end = str_get_prev_char (input->buffer->str + end) - input->buffer->str;
1071
1072                 for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data));
1073                      e != NULL; i++, e = g_list_next (e))
1074                 {
1075                     WLEntry *le = LENTRY (e->data);
1076
1077                     if (strncmp (input->buffer->str + start, le->text, new_end - start) == 0)
1078                     {
1079                         listbox_set_current (LISTBOX (g->current->data), i);
1080                         end = new_end;
1081                         input_handle_char (input, parm);
1082                         widget_draw (WIDGET (g->current->data));
1083                         break;
1084                     }
1085                 }
1086             }
1087             return MSG_HANDLED;
1088
1089         default:
1090             if (parm < 32 || parm > 255)
1091             {
1092                 bl = 0;
1093                 if (widget_lookup_key (WIDGET (input), parm) != CK_Complete)
1094                     return MSG_NOT_HANDLED;
1095
1096                 if (end == min_end)
1097                     return MSG_HANDLED;
1098
1099                 /* This means we want to refill the list box and start again */
1100                 h->ret_value = B_USER;
1101                 dlg_close (h);
1102             }
1103             else
1104             {
1105                 static char buff[MB_LEN_MAX] = "";
1106                 GList *e;
1107                 int i;
1108                 int need_redraw = 0;
1109                 int low = 4096;
1110                 char *last_text = NULL;
1111
1112                 buff[bl++] = (char) parm;
1113                 buff[bl] = '\0';
1114
1115                 switch (str_is_valid_char (buff, bl))
1116                 {
1117                 case -1:
1118                     bl = 0;
1119                     MC_FALLTHROUGH;
1120                 case -2:
1121                     return MSG_HANDLED;
1122                 default:
1123                     break;
1124                 }
1125
1126                 for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data));
1127                      e != NULL; i++, e = g_list_next (e))
1128                 {
1129                     WLEntry *le = LENTRY (e->data);
1130
1131                     if (strncmp (input->buffer->str + start, le->text, end - start) == 0
1132                         && strncmp (le->text + end - start, buff, bl) == 0)
1133                     {
1134                         if (need_redraw == 0)
1135                         {
1136                             need_redraw = 1;
1137                             listbox_set_current (LISTBOX (g->current->data), i);
1138                             last_text = le->text;
1139                         }
1140                         else
1141                         {
1142                             char *si, *sl;
1143                             int si_num = 0;
1144                             int sl_num = 0;
1145
1146                             /* count symbols between start and end */
1147                             for (si = le->text + start; si < le->text + end;
1148                                  str_next_char (&si), si_num++)
1149                                 ;
1150                             for (sl = last_text + start; sl < last_text + end;
1151                                  str_next_char (&sl), sl_num++)
1152                                 ;
1153
1154                             /* pointers to next symbols */
1155                             si = &le->text[str_offset_to_pos (le->text, ++si_num)];
1156                             sl = &last_text[str_offset_to_pos (last_text, ++sl_num)];
1157
1158                             while (si[0] != '\0' && sl[0] != '\0')
1159                             {
1160                                 char *nexti, *nextl;
1161
1162                                 nexti = str_get_next_char (si);
1163                                 nextl = str_get_next_char (sl);
1164
1165                                 if (nexti - si != nextl - sl || strncmp (si, sl, nexti - si) != 0)
1166                                     break;
1167
1168                                 si = nexti;
1169                                 sl = nextl;
1170
1171                                 si_num++;
1172                             }
1173
1174                             last_text = le->text;
1175
1176                             si = &last_text[str_offset_to_pos (last_text, si_num)];
1177                             if (low > si - last_text)
1178                                 low = si - last_text;
1179
1180                             need_redraw = 2;
1181                         }
1182                     }
1183                 }
1184
1185                 if (need_redraw == 2)
1186                 {
1187                     insert_text (input, last_text, low);
1188                     widget_draw (WIDGET (g->current->data));
1189                 }
1190                 else if (need_redraw == 1)
1191                 {
1192                     h->ret_value = B_ENTER;
1193                     dlg_close (h);
1194                 }
1195                 bl = 0;
1196             }
1197         }
1198         return MSG_HANDLED;
1199
1200     default:
1201         return dlg_default_callback (w, sender, msg, parm, data);
1202     }
1203 }
1204
1205 /* --------------------------------------------------------------------------------------------- */
1206
1207 /** Returns TRUE if the user would like to see us again */
1208 static gboolean
1209 complete_engine (WInput * in, int what_to_do)
1210 {
1211     if (in->completions != NULL && str_offset_to_pos (in->buffer->str, in->point) != end)
1212         input_complete_free (in);
1213
1214     if (in->completions == NULL)
1215         complete_engine_fill_completions (in);
1216
1217     if (in->completions == NULL)
1218         tty_beep ();
1219     else
1220     {
1221         if ((what_to_do & DO_INSERTION) != 0
1222             || ((what_to_do & DO_QUERY) != 0 && in->completions[1] == NULL))
1223         {
1224             char *lc_complete = in->completions[0];
1225
1226             if (!insert_text (in, lc_complete, -1) || in->completions[1] != NULL)
1227                 tty_beep ();
1228             else
1229                 input_complete_free (in);
1230         }
1231
1232         if ((what_to_do & DO_QUERY) != 0 && in->completions != NULL && in->completions[1] != NULL)
1233         {
1234             int maxlen = 0, count = 0, i;
1235             int x, y, w, h;
1236             int start_x, start_y;
1237             char **p, *q;
1238             WDialog *complete_dlg;
1239             WListbox *complete_list;
1240
1241             for (p = in->completions + 1; *p != NULL; count++, p++)
1242             {
1243                 i = str_term_width1 (*p);
1244                 if (i > maxlen)
1245                     maxlen = i;
1246             }
1247
1248             start_x = WIDGET (in)->rect.x;
1249             start_y = WIDGET (in)->rect.y;
1250             if (start_y - 2 >= count)
1251             {
1252                 y = start_y - 2 - count;
1253                 h = 2 + count;
1254             }
1255             else if (start_y >= LINES - start_y - 1)
1256             {
1257                 y = 0;
1258                 h = start_y;
1259             }
1260             else
1261             {
1262                 y = start_y + 1;
1263                 h = LINES - start_y - 1;
1264             }
1265             x = start - in->term_first_shown - 2 + start_x;
1266             w = maxlen + 4;
1267             if (x + w > COLS)
1268                 x = COLS - w;
1269             if (x < 0)
1270                 x = 0;
1271             if (x + w > COLS)
1272                 w = COLS;
1273
1274             input = in;
1275             min_end = end;
1276
1277             complete_dlg =
1278                 dlg_create (TRUE, y, x, h, w, WPOS_KEEP_DEFAULT, TRUE,
1279                             dialog_colors, complete_callback, NULL, "[Completion]", NULL);
1280             complete_list = listbox_new (1, 1, h - 2, w - 2, FALSE, NULL);
1281             group_add_widget (GROUP (complete_dlg), complete_list);
1282
1283             for (p = in->completions + 1; *p != NULL; p++)
1284                 listbox_add_item (complete_list, LISTBOX_APPEND_AT_END, 0, *p, NULL, FALSE);
1285
1286             i = dlg_run (complete_dlg);
1287             q = NULL;
1288             if (i == B_ENTER)
1289             {
1290                 listbox_get_current (complete_list, &q, NULL);
1291                 if (q != NULL)
1292                     insert_text (in, q, -1);
1293             }
1294             if (q != NULL || end != min_end)
1295                 input_complete_free (in);
1296             widget_destroy (WIDGET (complete_dlg));
1297
1298             /* B_USER if user wants to start over again */
1299             return (i == B_USER);
1300         }
1301     }
1302
1303     return FALSE;
1304 }
1305
1306 /* --------------------------------------------------------------------------------------------- */
1307 /*** public functions ****************************************************************************/
1308 /* --------------------------------------------------------------------------------------------- */
1309
1310 /** Returns an array of matches, or NULL if none. */
1311 char **
1312 try_complete (char *text, int *lc_start, int *lc_end, input_complete_t flags)
1313 {
1314     try_complete_automation_state_t state;
1315     char **matches = NULL;
1316
1317     memset (&state, 0, sizeof (state));
1318     state.flags = flags;
1319
1320     SHOW_C_CTX ("try_complete");
1321     state.word = g_strndup (text + *lc_start, *lc_end - *lc_start);
1322
1323     state.is_cd = check_is_cd (text, *lc_start, state.flags);
1324
1325     /* Determine if this could be a command word. It is if it appears at
1326        the start of the line (ignoring preceding whitespace), or if it
1327        appears after a character that separates commands. And we have to
1328        be in a INPUT_COMPLETE_COMMANDS flagged Input line. */
1329     if (!state.is_cd && (flags & INPUT_COMPLETE_COMMANDS) != 0)
1330         try_complete_commands_prepare (&state, text, lc_start);
1331
1332     try_complete_find_start_sign (&state);
1333
1334     /* Command substitution? */
1335     if (state.p > state.q && state.p > state.r)
1336     {
1337         SHOW_C_CTX ("try_complete:cmd_backq_subst");
1338         matches = completion_matches (str_cget_next_char (state.p),
1339                                       command_completion_function,
1340                                       state.flags & (~INPUT_COMPLETE_FILENAMES));
1341         if (matches != NULL)
1342             *lc_start += str_get_next_char (state.p) - state.word;
1343     }
1344
1345     /* Variable name? */
1346     else if (state.q > state.p && state.q > state.r)
1347     {
1348         SHOW_C_CTX ("try_complete:var_subst");
1349         matches = completion_matches (state.q, variable_completion_function, state.flags);
1350         if (matches != NULL)
1351             *lc_start += state.q - state.word;
1352     }
1353
1354     /* Starts with '@', then look through the known hostnames for
1355        completion first. */
1356     else if (state.r > state.p && state.r > state.q)
1357     {
1358         SHOW_C_CTX ("try_complete:host_subst");
1359         matches = completion_matches (state.r, hostname_completion_function, state.flags);
1360         if (matches != NULL)
1361             *lc_start += state.r - state.word;
1362     }
1363
1364     /* Starts with '~' and there is no slash in the word, then
1365        try completing this word as a username. */
1366     if (matches == NULL && *state.word == '~' && (state.flags & INPUT_COMPLETE_USERNAMES) != 0
1367         && strchr (state.word, PATH_SEP) == NULL)
1368     {
1369         SHOW_C_CTX ("try_complete:user_subst");
1370         matches = completion_matches (state.word, username_completion_function, state.flags);
1371     }
1372
1373     /* If this word is in a command position, then
1374        complete over possible command names, including aliases, functions,
1375        and command names. */
1376     if (matches == NULL)
1377         matches = try_complete_all_possible (&state, text, lc_start);
1378
1379     /* And finally if nothing found, try complete directory name */
1380     if (matches == NULL)
1381     {
1382         state.in_command_position = 0;
1383         matches = try_complete_all_possible (&state, text, lc_start);
1384     }
1385
1386     g_free (state.word);
1387
1388     if (matches != NULL &&
1389         (flags & (INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_SHELL_ESC)) !=
1390         (INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_SHELL_ESC))
1391     {
1392         /* FIXME: HACK? INPUT_COMPLETE_SHELL_ESC is used only in command line. */
1393         char **m;
1394
1395         for (m = matches; *m != NULL; m++)
1396         {
1397             char *p;
1398
1399             p = *m;
1400             *m = str_shell_escape (*m);
1401             g_free (p);
1402         }
1403     }
1404
1405     return matches;
1406 }
1407
1408 /* --------------------------------------------------------------------------------------------- */
1409
1410 void
1411 complete_engine_fill_completions (WInput * in)
1412 {
1413     char *s;
1414     const char *word_separators;
1415
1416     word_separators = (in->completion_flags & INPUT_COMPLETE_SHELL_ESC) ? " \t;|<>" : "\t;|<>";
1417
1418     end = str_offset_to_pos (in->buffer->str, in->point);
1419
1420     s = in->buffer->str;
1421     if (in->point != 0)
1422     {
1423         /* get symbol before in->point */
1424         size_t i;
1425
1426         for (i = in->point - 1; i > 0; i--)
1427             str_next_char (&s);
1428     }
1429
1430     for (; s >= in->buffer->str; str_prev_char (&s))
1431     {
1432         start = s - in->buffer->str;
1433         if (strchr (word_separators, *s) != NULL && !str_is_char_escaped (in->buffer->str, s))
1434             break;
1435     }
1436
1437     if (start < end)
1438     {
1439         str_next_char (&s);
1440         start = s - in->buffer->str;
1441     }
1442
1443     in->completions = try_complete (in->buffer->str, &start, &end, in->completion_flags);
1444 }
1445
1446 /* --------------------------------------------------------------------------------------------- */
1447
1448 /* declared in lib/widget/input.h */
1449 void
1450 input_complete (WInput * in)
1451 {
1452     int engine_flags;
1453
1454     if (!str_is_valid_string (in->buffer->str))
1455         return;
1456
1457     if (in->completions != NULL)
1458         engine_flags = DO_QUERY;
1459     else
1460     {
1461         engine_flags = DO_INSERTION;
1462
1463         if (mc_global.widget.show_all_if_ambiguous)
1464             engine_flags |= DO_QUERY;
1465     }
1466
1467     while (complete_engine (in, engine_flags))
1468         ;
1469 }
1470
1471 /* --------------------------------------------------------------------------------------------- */
1472
1473 void
1474 input_complete_free (WInput * in)
1475 {
1476     g_strfreev (in->completions);
1477     in->completions = NULL;
1478 }
1479
1480 /* --------------------------------------------------------------------------------------------- */