X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=fish%2Fdestpaths.c;h=5ed93ec78f2eafebdc86b45df7146633dc064f2c;hp=90970dea2fabc03bdfe37552317ded02f62fb885;hb=21bd2db7cf259a17cc3922409937b849e4b83c0f;hpb=f20854ec61eef1aea313920f0cf193a78c1a9219 diff --git a/fish/destpaths.c b/fish/destpaths.c index 90970de..5ed93ec 100644 --- a/fish/destpaths.c +++ b/fish/destpaths.c @@ -18,8 +18,6 @@ #include -#define _GNU_SOURCE // for strndup, asprintf - #include #include #include @@ -33,6 +31,7 @@ #include "fish.h" +#ifdef HAVE_LIBREADLINE // From gnulib's xalloc.h: /* Return 1 if an array of N objects, each of size S, cannot exist due to size arithmetic overflow. S must be positive and N must be @@ -48,22 +47,39 @@ branch when S is known to be 1. */ # define xalloc_oversized(n, s) \ ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) +#endif /* Readline completion for paths on the guest filesystem, also for * devices and LVM names. */ -int complete_dest_paths = 0; /* SEE NOTE */ +int complete_dest_paths = 1; -/* NOTE: This is currently disabled by default (with no way to - * enable it). That's because it's not particularly natural. - * - * Also there is a quite serious performance problem. When listing - * even moderately long directories, this takes many seconds. The - * reason is because it calls guestfs_is_dir on each directory - * entry, thus lots of round trips to the server. We could have - * a "readdir and stat each entry" call to ease this. - */ +struct word { + char *name; + int is_dir; +}; + +#ifdef HAVE_LIBREADLINE +static void +free_words (struct word *words, size_t nr_words) +{ + size_t i; + + /* NB. 'words' array is NOT NULL-terminated. */ + for (i = 0; i < nr_words; ++i) + free (words[i].name); + free (words); +} + +static int +compare_words (const void *vp1, const void *vp2) +{ + const struct word *w1 = (const struct word *) vp1; + const struct word *w2 = (const struct word *) vp2; + return strcmp (w1->name, w2->name); +} +#endif char * complete_dest_paths_generator (const char *text, int state) @@ -71,9 +87,8 @@ complete_dest_paths_generator (const char *text, int state) #ifdef HAVE_LIBREADLINE static size_t len, index; - static char **words = NULL; + static struct word *words = NULL; static size_t nr_words = 0; - char *word; guestfs_error_handler_cb old_error_cb; void *old_error_cb_data; @@ -94,13 +109,7 @@ complete_dest_paths_generator (const char *text, int state) len = strlen (text); index = 0; - if (words) { - size_t i; - /* NB. 'words' array is NOT NULL-terminated. */ - for (i = 0; i < nr_words; ++i) - free (words[i]); - free (words); - } + if (words) free_words (words, nr_words); words = NULL; nr_words = 0; @@ -111,25 +120,32 @@ complete_dest_paths_generator (const char *text, int state) #define APPEND_STRS_AND_FREE \ do { \ if (strs) { \ + size_t i; \ size_t n = count_strings (strs); \ - if ( ! xalloc_oversized (nr_words + n, sizeof (char *))) { \ - char *w = realloc (words, sizeof (char *) * (nr_words + n)); \ - if (w == NULL) { \ - free (words); \ - words = NULL; \ - nr_words = 0; \ - } else { \ - size_t i; \ - for (i = 0; i < n; ++i) \ - words[nr_words++] = strs[i]; \ - } \ - free (strs); \ + \ + if ( n > 0 && ! xalloc_oversized (nr_words + n, sizeof (struct word))) { \ + struct word *w; \ + w = realloc (words, sizeof (struct word) * (nr_words + n)); \ + \ + if (w == NULL) { \ + free_words (words, nr_words); \ + words = NULL; \ + nr_words = 0; \ + } else { \ + words = w; \ + for (i = 0; i < n; ++i) { \ + words[nr_words].name = strs[i]; \ + words[nr_words].is_dir = 0; \ + nr_words++; \ + } \ + } \ } \ + free (strs); \ } \ } while (0) /* Is it a device? */ - if (len < 5 || strncmp (text, "/dev/", 5) == 0) { + if (len < 5 || STREQLEN (text, "/dev/", 5)) { /* Get a list of everything that can possibly begin with /dev/ */ strs = guestfs_list_devices (g); APPEND_STRS_AND_FREE; @@ -146,30 +162,51 @@ complete_dest_paths_generator (const char *text, int state) * in that directory, otherwise list everything in / */ char *p, *dir; + struct guestfs_dirent_list *dirents; p = strrchr (text, '/'); dir = p && p > text ? strndup (text, p - text) : strdup ("/"); if (dir) { - strs = guestfs_ls (g, dir); - - /* Prepend directory to names. */ - if (strs) { - size_t i; - for (i = 0; strs[i]; ++i) { - int err; - if (strcmp (dir, "/") == 0) - err = asprintf (&p, "/%s", strs[i]); - else - err = asprintf (&p, "%s/%s", dir, strs[i]); - if (0 <= err) { - free (strs[i]); - strs[i] = p; - } - } - } - - free (dir); - APPEND_STRS_AND_FREE; + dirents = guestfs_readdir (g, dir); + + /* Prepend directory to names before adding them to the list + * of words. + */ + if (dirents) { + size_t i; + + for (i = 0; i < dirents->len; ++i) { + int err; + + if (STRNEQ (dirents->val[i].name, ".") && + STRNEQ (dirents->val[i].name, "..")) { + if (STREQ (dir, "/")) + err = asprintf (&p, "/%s", dirents->val[i].name); + else + err = asprintf (&p, "%s/%s", dir, dirents->val[i].name); + if (err >= 0) { + if (!xalloc_oversized (nr_words+1, sizeof (struct word))) { + struct word *w; + + w = realloc (words, sizeof (struct word) * (nr_words+1)); + if (w == NULL) { + free_words (words, nr_words); + words = NULL; + nr_words = 0; + } + else { + words = w; + words[nr_words].name = p; + words[nr_words].is_dir = dirents->val[i].ftyp == 'd'; + nr_words++; + } + } + } + } + } + + guestfs_free_dirent_list (dirents); + } } } @@ -183,20 +220,34 @@ complete_dest_paths_generator (const char *text, int state) /* This inhibits ordinary (local filename) completion. */ rl_attempted_completion_over = 1; + /* Sort the words so the list is stable over multiple calls. */ + qsort (words, nr_words, sizeof (struct word), compare_words); + /* Complete the string. */ while (index < nr_words) { - word = words[index]; + struct word *word; + + word = &words[index]; index++; - if (strncasecmp (word, text, len) == 0) { - /* Is it a directory? */ - if (strncmp (word, "/dev/", 5) != 0) { - SAVE_ERROR_CB - if (guestfs_is_dir (g, word) > 0) - rl_completion_append_character = '/'; - RESTORE_ERROR_CB - } - return strdup (word); + /* Whether we should match case insensitively here or not is + * determined by the value of the completion-ignore-case readline + * variable. Default to case insensitive. (See: RHBZ#582993). + */ + char *cic_var = rl_variable_value ("completion-ignore-case"); + int cic = 1; + if (cic_var && STREQ (cic_var, "off")) + cic = 0; + + int matches = + cic ? STRCASEEQLEN (word->name, text, len) + : STREQLEN (word->name, text, len); + + if (matches) { + if (word->is_dir) + rl_completion_append_character = '/'; + + return strdup (word->name); } }