char *
complete_dest_paths_generator (const char *text, int state)
{
#ifdef HAVE_LIBREADLINE
static size_t len, index;
static struct word *words = NULL;
static size_t nr_words = 0;
guestfs_error_handler_cb old_error_cb;
void *old_error_cb_data;
/* Temporarily replace the error handler so that messages don't
* get printed to stderr while we are issuing commands.
*/
#define SAVE_ERROR_CB \
old_error_cb = guestfs_get_error_handler (g, &old_error_cb_data); \
guestfs_set_error_handler (g, NULL, NULL);
/* Restore error handler. */
#define RESTORE_ERROR_CB \
guestfs_set_error_handler (g, old_error_cb, old_error_cb_data);
if (!state) {
char **strs;
len = strlen (text);
index = 0;
if (words) free_words (words, nr_words);
words = NULL;
nr_words = 0;
SAVE_ERROR_CB
/* Silently do nothing if an allocation fails */
#define APPEND_STRS_AND_FREE \
do { \
if (strs) { \
size_t i; \
size_t n = count_strings (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 || STREQLEN (text, "/dev/", 5)) {
/* Get a list of everything that can possibly begin with /dev/ */
strs = guestfs_list_devices (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_partitions (g);
APPEND_STRS_AND_FREE;
strs = guestfs_lvs (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_dm_devices (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_md_devices (g);
APPEND_STRS_AND_FREE;
}
if (len < 1 || text[0] == '/') {
/* If we've got a partial path already, we need to list everything
* 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) {
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);
}
}
}
/* else ... In theory we could complete other things here such as VG
* names. At the moment we don't do that.
*/
RESTORE_ERROR_CB
}
static int
mount_local_readdir (const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
time_t now;
size_t i;
char **names;
CLEANUP_FREE_DIRENT_LIST struct guestfs_dirent_list *ents = NULL;
DECL_G ();
DEBUG_CALL ("%s, %p, %ld", path, buf, (long) offset);
time (&now);
dir_cache_remove_all_expired (g, now);
ents = guestfs_readdir (g, path);
if (ents == NULL)
RETURN_ERRNO;
for (i = 0; i < ents->len; ++i) {
struct stat stat;
memset (&stat, 0, sizeof stat);
stat.st_ino = ents->val[i].ino;
switch (ents->val[i].ftyp) {
case 'b': stat.st_mode = S_IFBLK; break;
case 'c': stat.st_mode = S_IFCHR; break;
case 'd': stat.st_mode = S_IFDIR; break;
case 'f': stat.st_mode = S_IFIFO; break;
case 'l': stat.st_mode = S_IFLNK; break;
case 'r': stat.st_mode = S_IFREG; break;
case 's': stat.st_mode = S_IFSOCK; break;
case 'u':
case '?':
default: stat.st_mode = 0;
}
/* Copied from the example, which also ignores 'offset'. I'm
* not quite sure how this is ever supposed to work on large
* directories. XXX
*/
if (filler (buf, ents->val[i].name, &stat, 0))
break;
}
/* Now prepopulate the directory caches. This step is just an
* optimization, don't worry if it fails.
*/
names = malloc ((ents->len + 1) * sizeof (char *));
if (names) {
CLEANUP_FREE_STATNS_LIST struct guestfs_statns_list *ss = NULL;
CLEANUP_FREE_XATTR_LIST struct guestfs_xattr_list *xattrs = NULL;
char **links;
for (i = 0; i < ents->len; ++i)
names[i] = ents->val[i].name;
names[i] = NULL;
ss = guestfs_lstatnslist (g, path, names);
if (ss) {
for (i = 0; i < ss->len; ++i) {
if (ss->val[i].st_ino >= 0) {
struct stat statbuf;
memset (&statbuf, 0, sizeof statbuf);
statbuf.st_dev = ss->val[i].st_dev;
statbuf.st_ino = ss->val[i].st_ino;
statbuf.st_mode = ss->val[i].st_mode;
statbuf.st_nlink = ss->val[i].st_nlink;
statbuf.st_uid = ss->val[i].st_uid;
statbuf.st_gid = ss->val[i].st_gid;
statbuf.st_rdev = ss->val[i].st_rdev;
statbuf.st_size = ss->val[i].st_size;
statbuf.st_blksize = ss->val[i].st_blksize;
statbuf.st_blocks = ss->val[i].st_blocks;
statbuf.st_atime = ss->val[i].st_atime_sec;
#ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
statbuf.st_atim.tv_nsec = ss->val[i].st_atime_nsec;
#endif
statbuf.st_mtime = ss->val[i].st_mtime_sec;
#ifdef HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
statbuf.st_mtim.tv_nsec = ss->val[i].st_mtime_nsec;
#endif
statbuf.st_ctime = ss->val[i].st_ctime_sec;
#ifdef HAVE_STRUCT_STAT_ST_CTIM_TV_NSEC
statbuf.st_ctim.tv_nsec = ss->val[i].st_ctime_nsec;
#endif
lsc_insert (g, path, names[i], now, &statbuf);
}
}
}
xattrs = guestfs_lxattrlist (g, path, names);
if (xattrs) {
size_t ni, num;
struct guestfs_xattr *first;
struct guestfs_xattr_list *copy;
for (i = 0, ni = 0; i < xattrs->len; ++i, ++ni) {
/* assert (strlen (xattrs->val[i].attrname) == 0); */
if (xattrs->val[i].attrval_len > 0) {
++i;
first = &xattrs->val[i];
num = 0;
for (; i < xattrs->len && strlen (xattrs->val[i].attrname) > 0; ++i)
num++;
copy = copy_xattr_list (g, first, num);
if (copy)
xac_insert (g, path, names[ni], now, copy);
i--;
}
}
}
links = guestfs_readlinklist (g, path, names);
if (links) {
for (i = 0; names[i] != NULL; ++i) {
if (links[i][0])
/* Note that rlc_insert owns the string links[i] after this, */
rlc_insert (g, path, names[i], now, links[i]);
else
/* which is why we have to free links[i] here. */
free (links[i]);
}
free (links); /* free the array, not the strings */
}
free (names);
}
return 0;
}
char *
complete_dest_paths_generator (const char *text, int state)
{
#ifdef HAVE_LIBREADLINE
static size_t len, index;
static struct word *words = NULL;
static size_t nr_words = 0;
if (!state) {
char **strs;
len = strlen (text);
index = 0;
if (words) free_words (words, nr_words);
words = NULL;
nr_words = 0;
guestfs_push_error_handler (g, NULL, NULL);
/* Silently do nothing if an allocation fails */
#define APPEND_STRS_AND_FREE \
do { \
if (strs) { \
size_t i; \
size_t n = count_strings (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 || STREQLEN (text, "/dev/", 5)) {
/* Get a list of everything that can possibly begin with /dev/ */
strs = guestfs_list_devices (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_partitions (g);
APPEND_STRS_AND_FREE;
strs = guestfs_lvs (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_dm_devices (g);
APPEND_STRS_AND_FREE;
strs = guestfs_list_md_devices (g);
APPEND_STRS_AND_FREE;
}
if (len < 1 || text[0] == '/') {
/* If we've got a partial path already, we need to list everything
* 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) {
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);
}
}
}
/* else ... In theory we could complete other things here such as VG
* names. At the moment we don't do that.
*/
guestfs_pop_error_handler (g);
}
/* This inhibits ordinary (local filename) completion. */
rl_attempted_completion_over = 1;
/* Sort the words so the list is stable over multiple calls. */
if (words)
qsort (words, nr_words, sizeof (struct word), compare_words);
/* Complete the string. */
while (index < nr_words) {
struct word *word;
word = &words[index];
index++;
/* 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);
}
}
#endif /* HAVE_LIBREADLINE */
return NULL;
}