contrib/libedit/filecomplete.c

   1 /*      $NetBSD: filecomplete.c,v 1.58 2019/09/08 05:50:58 abhinav Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1997 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jaromir Dolecek.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33 #if !defined(lint) && !defined(SCCSID)
  34 __RCSID("$NetBSD: filecomplete.c,v 1.58 2019/09/08 05:50:58 abhinav Exp $");
  35 #endif /* not lint && not SCCSID */
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <dirent.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <limits.h>
  43 #include <pwd.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48
  49 #include "el.h"
  50 #include "filecomplete.h"
  51
  52 static const wchar_t break_chars[] = L" \t\n\"\\'`@$><=;|&{(";
  53
  54 /********************************/
  55 /* completion functions */
  56
  57 /*
  58  * does tilde expansion of strings of type ``~user/foo''
  59  * if ``user'' isn't valid user name or ``txt'' doesn't start
  60  * w/ '~', returns pointer to strdup()ed copy of ``txt''
  61  *
  62  * it's the caller's responsibility to free() the returned string
  63  */
  64 char *
  65 fn_tilde_expand(const char *txt)
  66 {
  67 #if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)
  68         struct passwd pwres;
  69         char pwbuf[1024];
  70 #endif
  71         struct passwd *pass;
  72         char *temp;
  73         size_t len = 0;
  74
  75         if (txt[0] != '~')
  76                 return strdup(txt);
  77
  78         temp = strchr(txt + 1, '/');
  79         if (temp == NULL) {
  80                 temp = strdup(txt + 1);
  81                 if (temp == NULL)
  82                         return NULL;
  83         } else {
  84                 /* text until string after slash */
  85                 len = (size_t)(temp - txt + 1);
  86                 temp = el_calloc(len, sizeof(*temp));
  87                 if (temp == NULL)
  88                         return NULL;
  89                 (void)strncpy(temp, txt + 1, len - 2);
  90                 temp[len - 2] = '\0';
  91         }
  92         if (temp[0] == 0) {
  93 #ifdef HAVE_GETPW_R_POSIX
  94                 if (getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf),
  95                     &pass) != 0)
  96                         pass = NULL;
  97 #elif HAVE_GETPW_R_DRAFT
  98                 pass = getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf));
  99 #else
 100                 pass = getpwuid(getuid());
 101 #endif
 102         } else {
 103 #ifdef HAVE_GETPW_R_POSIX
 104                 if (getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf), &pass) != 0)
 105                         pass = NULL;
 106 #elif HAVE_GETPW_R_DRAFT
 107                 pass = getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf));
 108 #else
 109                 pass = getpwnam(temp);
 110 #endif
 111         }
 112         el_free(temp);          /* value no more needed */
 113         if (pass == NULL)
 114                 return strdup(txt);
 115
 116         /* update pointer txt to point at string immedially following */
 117         /* first slash */
 118         txt += len;
 119
 120         len = strlen(pass->pw_dir) + 1 + strlen(txt) + 1;
 121         temp = el_calloc(len, sizeof(*temp));
 122         if (temp == NULL)
 123                 return NULL;
 124         (void)snprintf(temp, len, "%s/%s", pass->pw_dir, txt);
 125
 126         return temp;
 127 }
 128
 129 static int
 130 needs_escaping(char c)
 131 {
 132         switch (c) {
 133         case '\'':
 134         case '"':
 135         case '(':
 136         case ')':
 137         case '\\':
 138         case '<':
 139         case '>':
 140         case '$':
 141         case '#':
 142         case ' ':
 143         case '\n':
 144         case '\t':
 145         case '?':
 146         case ';':
 147         case '`':
 148         case '@':
 149         case '=':
 150         case '|':
 151         case '{':
 152         case '}':
 153         case '&':
 154         case '*':
 155         case '[':
 156                 return 1;
 157         default:
 158                 return 0;
 159         }
 160 }
 161
 162 static int
 163 needs_dquote_escaping(char c)
 164 {
 165         switch (c) {
 166         case '"':
 167         case '\\':
 168         case '`':
 169         case '$':
 170                 return 1;
 171         default:
 172                 return 0;
 173         }
 174 }
 175
 176
 177 static wchar_t *
 178 unescape_string(const wchar_t *string, size_t length)
 179 {
 180         size_t i;
 181         size_t j = 0;
 182         wchar_t *unescaped = el_calloc(length + 1, sizeof(*string));
 183         if (unescaped == NULL)
 184                 return NULL;
 185         for (i = 0; i < length ; i++) {
 186                 if (string[i] == '\\')
 187                         continue;
 188                 unescaped[j++] = string[i];
 189         }
 190         unescaped[j] = 0;
 191         return unescaped;
 192 }
 193
 194 static char *
 195 escape_filename(EditLine * el, const char *filename, int single_match,
 196                 const char *(*app_func)(const char *))
 197 {
 198         size_t original_len = 0;
 199         size_t escaped_character_count = 0;
 200         size_t offset = 0;
 201         size_t newlen;
 202         const char *s;
 203         char c;
 204         size_t s_quoted = 0;    /* does the input contain a single quote */
 205         size_t d_quoted = 0;    /* does the input contain a double quote */
 206         char *escaped_str;
 207         wchar_t *temp = el->el_line.buffer;
 208         const char *append_char = NULL;
 209
 210         if (filename == NULL)
 211                 return NULL;
 212
 213         while (temp != el->el_line.cursor) {
 214                 /*
 215                  * If we see a single quote but have not seen a double quote
 216                  * so far set/unset s_quote
 217                  */
 218                 if (temp[0] == '\'' && !d_quoted)
 219                         s_quoted = !s_quoted;
 220                 /*
 221                  * vice versa to the above condition
 222                  */
 223                 else if (temp[0] == '"' && !s_quoted)
 224                         d_quoted = !d_quoted;
 225                 temp++;
 226         }
 227
 228         /* Count number of special characters so that we can calculate
 229          * number of extra bytes needed in the new string
 230          */
 231         for (s = filename; *s; s++, original_len++) {
 232                 c = *s;
 233                 /* Inside a single quote only single quotes need escaping */
 234                 if (s_quoted && c == '\'') {
 235                         escaped_character_count += 3;
 236                         continue;
 237                 }
 238                 /* Inside double quotes only ", \, ` and $ need escaping */
 239                 if (d_quoted && needs_dquote_escaping(c)) {
 240                         escaped_character_count++;
 241                         continue;
 242                 }
 243                 if (!s_quoted && !d_quoted && needs_escaping(c))
 244                         escaped_character_count++;
 245         }
 246
 247         newlen = original_len + escaped_character_count + 1;
 248         if (s_quoted || d_quoted)
 249                 newlen++;
 250
 251         if (single_match && app_func)
 252                 newlen++;
 253
 254         if ((escaped_str = el_malloc(newlen)) == NULL)
 255                 return NULL;
 256
 257         for (s = filename; *s; s++) {
 258                 c = *s;
 259                 if (!needs_escaping(c)) {
 260                         /* no escaping is required continue as usual */
 261                         escaped_str[offset++] = c;
 262                         continue;
 263                 }
 264
 265                 /* single quotes inside single quotes require special handling */
 266                 if (c == '\'' && s_quoted) {
 267                         escaped_str[offset++] = '\'';
 268                         escaped_str[offset++] = '\\';
 269                         escaped_str[offset++] = '\'';
 270                         escaped_str[offset++] = '\'';
 271                         continue;
 272                 }
 273
 274                 /* Otherwise no escaping needed inside single quotes */
 275                 if (s_quoted) {
 276                         escaped_str[offset++] = c;
 277                         continue;
 278                 }
 279
 280                 /* No escaping needed inside a double quoted string either
 281                  * unless we see a '$', '\', '`', or '"' (itself)
 282                  */
 283                 if (d_quoted && !needs_dquote_escaping(c)) {
 284                         escaped_str[offset++] = c;
 285                         continue;
 286                 }
 287
 288                 /* If we reach here that means escaping is actually needed */
 289                 escaped_str[offset++] = '\\';
 290                 escaped_str[offset++] = c;
 291         }
 292
 293         if (single_match && app_func) {
 294                 escaped_str[offset] = 0;
 295                 append_char = app_func(escaped_str);
 296                 /* we want to append space only if we are not inside quotes */
 297                 if (append_char[0] == ' ') {
 298                         if (!s_quoted && !d_quoted)
 299                                 escaped_str[offset++] = append_char[0];
 300                 } else
 301                         escaped_str[offset++] = append_char[0];
 302         }
 303
 304         /* close the quotes if single match and the match is not a directory */
 305         if (single_match && (append_char && append_char[0] == ' ')) {
 306                 if (s_quoted)
 307                         escaped_str[offset++] = '\'';
 308                 else if (d_quoted)
 309                         escaped_str[offset++] = '"';
 310         }
 311
 312         escaped_str[offset] = 0;
 313         return escaped_str;
 314 }
 315
 316 /*
 317  * return first found file name starting by the ``text'' or NULL if no
 318  * such file can be found
 319  * value of ``state'' is ignored
 320  *
 321  * it's the caller's responsibility to free the returned string
 322  */
 323 char *
 324 fn_filename_completion_function(const char *text, int state)
 325 {
 326         static DIR *dir = NULL;
 327         static char *filename = NULL, *dirname = NULL, *dirpath = NULL;
 328         static size_t filename_len = 0;
 329         struct dirent *entry;
 330         char *temp;
 331         size_t len;
 332
 333         if (state == 0 || dir == NULL) {
 334                 temp = strrchr(text, '/');
 335                 if (temp) {
 336                         char *nptr;
 337                         temp++;
 338                         nptr = el_realloc(filename, (strlen(temp) + 1) *
 339                             sizeof(*nptr));
 340                         if (nptr == NULL) {
 341                                 el_free(filename);
 342                                 filename = NULL;
 343                                 return NULL;
 344                         }
 345                         filename = nptr;
 346                         (void)strcpy(filename, temp);
 347                         len = (size_t)(temp - text);    /* including last slash */
 348
 349                         nptr = el_realloc(dirname, (len + 1) *
 350                             sizeof(*nptr));
 351                         if (nptr == NULL) {
 352                                 el_free(dirname);
 353                                 dirname = NULL;
 354                                 return NULL;
 355                         }
 356                         dirname = nptr;
 357                         (void)strncpy(dirname, text, len);
 358                         dirname[len] = '\0';
 359                 } else {
 360                         el_free(filename);
 361                         if (*text == 0)
 362                                 filename = NULL;
 363                         else {
 364                                 filename = strdup(text);
 365                                 if (filename == NULL)
 366                                         return NULL;
 367                         }
 368                         el_free(dirname);
 369                         dirname = NULL;
 370                 }
 371
 372                 if (dir != NULL) {
 373                         (void)closedir(dir);
 374                         dir = NULL;
 375                 }
 376
 377                 /* support for ``~user'' syntax */
 378
 379                 el_free(dirpath);
 380                 dirpath = NULL;
 381                 if (dirname == NULL) {
 382                         if ((dirname = strdup("")) == NULL)
 383                                 return NULL;
 384                         dirpath = strdup("./");
 385                 } else if (*dirname == '~')
 386                         dirpath = fn_tilde_expand(dirname);
 387                 else
 388                         dirpath = strdup(dirname);
 389
 390                 if (dirpath == NULL)
 391                         return NULL;
 392
 393                 dir = opendir(dirpath);
 394                 if (!dir)
 395                         return NULL;    /* cannot open the directory */
 396
 397                 /* will be used in cycle */
 398                 filename_len = filename ? strlen(filename) : 0;
 399         }
 400
 401         /* find the match */
 402         while ((entry = readdir(dir)) != NULL) {
 403                 /* skip . and .. */
 404                 if (entry->d_name[0] == '.' && (!entry->d_name[1]
 405                     || (entry->d_name[1] == '.' && !entry->d_name[2])))
 406                         continue;
 407                 if (filename_len == 0)
 408                         break;
 409                 /* otherwise, get first entry where first */
 410                 /* filename_len characters are equal      */
 411                 if (entry->d_name[0] == filename[0]
 412 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 413                     && entry->d_namlen >= filename_len
 414 #else
 415                     && strlen(entry->d_name) >= filename_len
 416 #endif
 417                     && strncmp(entry->d_name, filename,
 418                         filename_len) == 0)
 419                         break;
 420         }
 421
 422         if (entry) {            /* match found */
 423
 424 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 425                 len = entry->d_namlen;
 426 #else
 427                 len = strlen(entry->d_name);
 428 #endif
 429
 430                 len = strlen(dirname) + len + 1;
 431                 temp = el_calloc(len, sizeof(*temp));
 432                 if (temp == NULL)
 433                         return NULL;
 434                 (void)snprintf(temp, len, "%s%s", dirname, entry->d_name);
 435         } else {
 436                 (void)closedir(dir);
 437                 dir = NULL;
 438                 temp = NULL;
 439         }
 440
 441         return temp;
 442 }
 443
 444
 445 static const char *
 446 append_char_function(const char *name)
 447 {
 448         struct stat stbuf;
 449         char *expname = *name == '~' ? fn_tilde_expand(name) : NULL;
 450         const char *rs = " ";
 451
 452         if (stat(expname ? expname : name, &stbuf) == -1)
 453                 goto out;
 454         if (S_ISDIR(stbuf.st_mode))
 455                 rs = "/";
 456 out:
 457         if (expname)
 458                 el_free(expname);
 459         return rs;
 460 }
 461 /*
 462  * returns list of completions for text given
 463  * non-static for readline.
 464  */
 465 char ** completion_matches(const char *, char *(*)(const char *, int));
 466 char **
 467 completion_matches(const char *text, char *(*genfunc)(const char *, int))
 468 {
 469         char **match_list = NULL, *retstr, *prevstr;
 470         size_t match_list_len, max_equal, which, i;
 471         size_t matches;
 472
 473         matches = 0;
 474         match_list_len = 1;
 475         while ((retstr = (*genfunc) (text, (int)matches)) != NULL) {
 476                 /* allow for list terminator here */
 477                 if (matches + 3 >= match_list_len) {
 478                         char **nmatch_list;
 479                         while (matches + 3 >= match_list_len)
 480                                 match_list_len <<= 1;
 481                         nmatch_list = el_realloc(match_list,
 482                             match_list_len * sizeof(*nmatch_list));
 483                         if (nmatch_list == NULL) {
 484                                 el_free(match_list);
 485                                 return NULL;
 486                         }
 487                         match_list = nmatch_list;
 488
 489                 }
 490                 match_list[++matches] = retstr;
 491         }
 492
 493         if (!match_list)
 494                 return NULL;    /* nothing found */
 495
 496         /* find least denominator and insert it to match_list[0] */
 497         which = 2;
 498         prevstr = match_list[1];
 499         max_equal = strlen(prevstr);
 500         for (; which <= matches; which++) {
 501                 for (i = 0; i < max_equal &&
 502                     prevstr[i] == match_list[which][i]; i++)
 503                         continue;
 504                 max_equal = i;
 505         }
 506
 507         retstr = el_calloc(max_equal + 1, sizeof(*retstr));
 508         if (retstr == NULL) {
 509                 el_free(match_list);
 510                 return NULL;
 511         }
 512         (void)strncpy(retstr, match_list[1], max_equal);
 513         retstr[max_equal] = '\0';
 514         match_list[0] = retstr;
 515
 516         /* add NULL as last pointer to the array */
 517         match_list[matches + 1] = NULL;
 518
 519         return match_list;
 520 }
 521
 522 /*
 523  * Sort function for qsort(). Just wrapper around strcasecmp().
 524  */
 525 static int
 526 _fn_qsort_string_compare(const void *i1, const void *i2)
 527 {
 528         const char *s1 = ((const char * const *)i1)[0];
 529         const char *s2 = ((const char * const *)i2)[0];
 530
 531         return strcasecmp(s1, s2);
 532 }
 533
 534 /*
 535  * Display list of strings in columnar format on readline's output stream.
 536  * 'matches' is list of strings, 'num' is number of strings in 'matches',
 537  * 'width' is maximum length of string in 'matches'.
 538  *
 539  * matches[0] is not one of the match strings, but it is counted in
 540  * num, so the strings are matches[1] *through* matches[num-1].
 541  */
 542 void
 543 fn_display_match_list(EditLine * el, char **matches, size_t num, size_t width,
 544     const char *(*app_func) (const char *))
 545 {
 546         size_t line, lines, col, cols, thisguy;
 547         int screenwidth = el->el_terminal.t_size.h;
 548         if (app_func == NULL)
 549                 app_func = append_char_function;
 550
 551         /* Ignore matches[0]. Avoid 1-based array logic below. */
 552         matches++;
 553         num--;
 554
 555         /*
 556          * Find out how many entries can be put on one line; count
 557          * with one space between strings the same way it's printed.
 558          */
 559         cols = (size_t)screenwidth / (width + 2);
 560         if (cols == 0)
 561                 cols = 1;
 562
 563         /* how many lines of output, rounded up */
 564         lines = (num + cols - 1) / cols;
 565
 566         /* Sort the items. */
 567         qsort(matches, num, sizeof(char *), _fn_qsort_string_compare);
 568
 569         /*
 570          * On the ith line print elements i, i+lines, i+lines*2, etc.
 571          */
 572         for (line = 0; line < lines; line++) {
 573                 for (col = 0; col < cols; col++) {
 574                         thisguy = line + col * lines;
 575                         if (thisguy >= num)
 576                                 break;
 577                         (void)fprintf(el->el_outfile, "%s%s%s",
 578                             col == 0 ? "" : " ", matches[thisguy],
 579                                 (*app_func)(matches[thisguy]));
 580                         (void)fprintf(el->el_outfile, "%-*s",
 581                                 (int) (width - strlen(matches[thisguy])), "");
 582                 }
 583                 (void)fprintf(el->el_outfile, "\n");
 584         }
 585 }
 586
 587 static wchar_t *
 588 find_word_to_complete(const wchar_t * cursor, const wchar_t * buffer,
 589     const wchar_t * word_break, const wchar_t * special_prefixes, size_t * length)
 590 {
 591         /* We now look backwards for the start of a filename/variable word */
 592         const wchar_t *ctemp = cursor;
 593         size_t len;
 594
 595         /* if the cursor is placed at a slash or a quote, we need to find the
 596          * word before it
 597          */
 598         if (ctemp > buffer) {
 599                 switch (ctemp[-1]) {
 600                 case '\\':
 601                 case '\'':
 602                 case '"':
 603                         ctemp--;
 604                         break;
 605                 default:
 606                         break;
 607                 }
 608         }
 609
 610         for (;;) {
 611                 if (ctemp <= buffer)
 612                         break;
 613                 if (wcschr(word_break, ctemp[-1])) {
 614                         if (ctemp - buffer >= 2 && ctemp[-2] == '\\') {
 615                                 ctemp -= 2;
 616                                 continue;
 617                         } else if (ctemp - buffer >= 2 &&
 618                             (ctemp[-2] == '\'' || ctemp[-2] == '"')) {
 619                                 ctemp--;
 620                                 continue;
 621                         } else
 622                                 break;
 623                 }
 624                 if (special_prefixes && wcschr(special_prefixes, ctemp[-1]))
 625                         break;
 626                 ctemp--;
 627         }
 628
 629         len = (size_t) (cursor - ctemp);
 630         if (len == 1 && (ctemp[0] == '\'' || ctemp[0] == '"')) {
 631                 len = 0;
 632                 ctemp++;
 633         }
 634         *length = len;
 635         wchar_t *unescaped_word = unescape_string(ctemp, len);
 636         if (unescaped_word == NULL)
 637                 return NULL;
 638         return unescaped_word;
 639 }
 640
 641 /*
 642  * Complete the word at or before point,
 643  * 'what_to_do' says what to do with the completion.
 644  * \t   means do standard completion.
 645  * `?' means list the possible completions.
 646  * `*' means insert all of the possible completions.
 647  * `!' means to do standard completion, and list all possible completions if
 648  * there is more than one.
 649  *
 650  * Note: '*' support is not implemented
 651  *       '!' could never be invoked
 652  */
 653 int
 654 fn_complete(EditLine *el,
 655         char *(*complet_func)(const char *, int),
 656         char **(*attempted_completion_function)(const char *, int, int),
 657         const wchar_t *word_break, const wchar_t *special_prefixes,
 658         const char *(*app_func)(const char *), size_t query_items,
 659         int *completion_type, int *over, int *point, int *end)
 660 {
 661         const LineInfoW *li;
 662         wchar_t *temp;
 663         char **matches;
 664         char *completion;
 665         size_t len;
 666         int what_to_do = '\t';
 667         int retval = CC_NORM;
 668
 669         if (el->el_state.lastcmd == el->el_state.thiscmd)
 670                 what_to_do = '?';
 671
 672         /* readline's rl_complete() has to be told what we did... */
 673         if (completion_type != NULL)
 674                 *completion_type = what_to_do;
 675
 676         if (!complet_func)
 677                 complet_func = fn_filename_completion_function;
 678         if (!app_func)
 679                 app_func = append_char_function;
 680
 681         li = el_wline(el);
 682         temp = find_word_to_complete(li->cursor,
 683             li->buffer, word_break, special_prefixes, &len);
 684         if (temp == NULL)
 685                 goto out;
 686
 687         /* these can be used by function called in completion_matches() */
 688         /* or (*attempted_completion_function)() */
 689         if (point != NULL)
 690                 *point = (int)(li->cursor - li->buffer);
 691         if (end != NULL)
 692                 *end = (int)(li->lastchar - li->buffer);
 693
 694         if (attempted_completion_function) {
 695                 int cur_off = (int)(li->cursor - li->buffer);
 696                 matches = (*attempted_completion_function)(
 697                     ct_encode_string(temp, &el->el_scratch),
 698                     cur_off - (int)len, cur_off);
 699         } else
 700                 matches = NULL;
 701         if (!attempted_completion_function ||
 702             (over != NULL && !*over && !matches))
 703                 matches = completion_matches(
 704                     ct_encode_string(temp, &el->el_scratch), complet_func);
 705
 706         if (over != NULL)
 707                 *over = 0;
 708
 709         if (matches) {
 710                 int i;
 711                 size_t matches_num, maxlen, match_len, match_display=1;
 712                 int single_match = matches[2] == NULL &&
 713                         (matches[1] == NULL || strcmp(matches[0], matches[1]) == 0);
 714
 715                 retval = CC_REFRESH;
 716
 717                 if (matches[0][0] != '\0') {
 718                         el_deletestr(el, (int)len);
 719                         if (!attempted_completion_function)
 720                                 completion = escape_filename(el, matches[0],
 721                                     single_match, app_func);
 722                         else
 723                                 completion = strdup(matches[0]);
 724                         if (completion == NULL)
 725                                 goto out;
 726                         if (single_match) {
 727                                 /* We found exact match. Add a space after it,
 728                                  * unless we do filename completion and the
 729                                  * object is a directory. Also do necessary
 730                                  * escape quoting
 731                                  */
 732                                 el_winsertstr(el,
 733                                     ct_decode_string(completion, &el->el_scratch));
 734                         } else {
 735                                 /* Only replace the completed string with
 736                                  * common part of possible matches if there is
 737                                  * possible completion.
 738                                  */
 739                                 el_winsertstr(el,
 740                                     ct_decode_string(completion, &el->el_scratch));
 741                         }
 742                         free(completion);
 743                 }
 744
 745
 746                 if (!single_match && (what_to_do == '!' || what_to_do == '?')) {
 747                         /*
 748                          * More than one match and requested to list possible
 749                          * matches.
 750                          */
 751
 752                         for(i = 1, maxlen = 0; matches[i]; i++) {
 753                                 match_len = strlen(matches[i]);
 754                                 if (match_len > maxlen)
 755                                         maxlen = match_len;
 756                         }
 757                         /* matches[1] through matches[i-1] are available */
 758                         matches_num = (size_t)(i - 1);
 759
 760                         /* newline to get on next line from command line */
 761                         (void)fprintf(el->el_outfile, "\n");
 762
 763                         /*
 764                          * If there are too many items, ask user for display
 765                          * confirmation.
 766                          */
 767                         if (matches_num > query_items) {
 768                                 (void)fprintf(el->el_outfile,
 769                                     "Display all %zu possibilities? (y or n) ",
 770                                     matches_num);
 771                                 (void)fflush(el->el_outfile);
 772                                 if (getc(stdin) != 'y')
 773                                         match_display = 0;
 774                                 (void)fprintf(el->el_outfile, "\n");
 775                         }
 776
 777                         if (match_display) {
 778                                 /*
 779                                  * Interface of this function requires the
 780                                  * strings be matches[1..num-1] for compat.
 781                                  * We have matches_num strings not counting
 782                                  * the prefix in matches[0], so we need to
 783                                  * add 1 to matches_num for the call.
 784                                  */
 785                                 fn_display_match_list(el, matches,
 786                                     matches_num+1, maxlen, app_func);
 787                         }
 788                         retval = CC_REDISPLAY;
 789                 } else if (matches[0][0]) {
 790                         /*
 791                          * There was some common match, but the name was
 792                          * not complete enough. Next tab will print possible
 793                          * completions.
 794                          */
 795                         el_beep(el);
 796                 } else {
 797                         /* lcd is not a valid object - further specification */
 798                         /* is needed */
 799                         el_beep(el);
 800                         retval = CC_NORM;
 801                 }
 802
 803                 /* free elements of array and the array itself */
 804                 for (i = 0; matches[i]; i++)
 805                         el_free(matches[i]);
 806                 el_free(matches);
 807                 matches = NULL;
 808         }
 809
 810 out:
 811         el_free(temp);
 812         return retval;
 813 }
 814
 815 /*
 816  * el-compatible wrapper around rl_complete; needed for key binding
 817  */
 818 /* ARGSUSED */
 819 unsigned char
 820 _el_fn_complete(EditLine *el, int ch __attribute__((__unused__)))
 821 {
 822         return (unsigned char)fn_complete(el, NULL, NULL,
 823             break_chars, NULL, NULL, (size_t)100,
 824             NULL, NULL, NULL, NULL);
 825 }
 826
 827 /*
 828  * el-compatible wrapper around rl_complete; needed for key binding
 829  */
 830 /* ARGSUSED */
 831 unsigned char
 832 _el_fn_sh_complete(EditLine *el, int ch)
 833 {
 834         return _el_fn_complete(el, ch);
 835 }