static int
check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs)
{
int r;
size_t len = strlen (fs->windows_systemroot) + 64;
char system[len];
snprintf (system, len, "%s/system32/config/system",
fs->windows_systemroot);
CLEANUP_FREE char *system_path = guestfs_case_sensitive_path (g, system);
if (!system_path)
return -1;
r = guestfs_is_file (g, system_path);
if (r == -1)
return -1;
/* If the system hive doesn't exist, just accept that we cannot
* find hostname etc.
*/
if (r == 0)
return 0;
int ret = -1;
int64_t root, node, value;
CLEANUP_FREE_HIVEX_VALUE_LIST struct guestfs_hivex_value_list *values = NULL;
CLEANUP_FREE_HIVEX_VALUE_LIST struct guestfs_hivex_value_list *values2 = NULL;
int32_t dword;
size_t i, count;
CLEANUP_FREE void *buf = NULL;
size_t buflen;
const char *hivepath[] =
{ NULL /* current control set */, "Services", "Tcpip", "Parameters" };
if (guestfs_hivex_open (g, system_path,
GUESTFS_HIVEX_OPEN_VERBOSE, g->verbose, -1) == -1)
goto out;
root = guestfs_hivex_root (g);
if (root == 0)
goto out;
/* Get the CurrentControlSet. */
node = guestfs_hivex_node_get_child (g, root, "Select");
if (node == -1)
goto out;
if (node == 0) {
error (g, "hivex: could not locate HKLM\\SYSTEM\\Select");
goto out;
}
value = guestfs_hivex_node_get_value (g, node, "Current");
if (value == -1)
goto out;
if (value == 0) {
error (g, "hivex: HKLM\\System\\Select Default entry not found");
goto out;
}
/* XXX Should check the type. */
buf = guestfs_hivex_value_value (g, value, &buflen);
if (buflen != 4) {
error (g, "hivex: HKLM\\System\\Select\\Current expected to be DWORD");
goto out;
}
dword = le32toh (*(int32_t *)buf);
fs->windows_current_control_set = safe_asprintf (g, "ControlSet%03d", dword);
/* Get the drive mappings.
* This page explains the contents of HKLM\System\MountedDevices:
* http://www.goodells.net/multiboot/partsigs.shtml
*/
node = guestfs_hivex_node_get_child (g, root, "MountedDevices");
if (node == -1)
goto out;
if (node == 0)
/* Not found: skip getting drive letter mappings (RHBZ#803664). */
goto skip_drive_letter_mappings;
values = guestfs_hivex_node_values (g, node);
/* Count how many DOS drive letter mappings there are. This doesn't
* ignore removable devices, so it overestimates, but that doesn't
* matter because it just means we'll allocate a few bytes extra.
*/
for (i = count = 0; i < values->len; ++i) {
CLEANUP_FREE char *key =
guestfs_hivex_value_key (g, values->val[i].hivex_value_h);
if (key == NULL)
goto out;
if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
c_isalpha (key[12]) && key[13] == ':')
count++;
}
fs->drive_mappings = safe_calloc (g, 2*count + 1, sizeof (char *));
for (i = count = 0; i < values->len; ++i) {
int64_t v = values->val[i].hivex_value_h;
CLEANUP_FREE char *key = guestfs_hivex_value_key (g, v);
if (key == NULL)
goto out;
if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
c_isalpha (key[12]) && key[13] == ':') {
/* Get the binary value. Is it a fixed disk? */
CLEANUP_FREE char *blob = NULL;
char *device;
size_t len;
int64_t type;
type = guestfs_hivex_value_type (g, v);
blob = guestfs_hivex_value_value (g, v, &len);
if (blob != NULL && type == 3 && len == 12) {
/* Try to map the blob to a known disk and partition. */
device = map_registry_disk_blob (g, blob);
if (device != NULL) {
fs->drive_mappings[count++] = safe_strndup (g, &key[12], 1);
fs->drive_mappings[count++] = device;
}
}
}
}
skip_drive_letter_mappings:;
/* Get the hostname. */
hivepath[0] = fs->windows_current_control_set;
for (node = root, i = 0;
node > 0 && i < sizeof hivepath / sizeof hivepath[0];
++i) {
node = guestfs_hivex_node_get_child (g, node, hivepath[i]);
}
if (node == -1)
goto out;
if (node == 0) {
perrorf (g, "hivex: cannot locate HKLM\\SYSTEM\\%s\\Services\\Tcpip\\Parameters",
fs->windows_current_control_set);
goto out;
}
values2 = guestfs_hivex_node_values (g, node);
if (values2 == NULL)
goto out;
for (i = 0; i < values2->len; ++i) {
int64_t v = values2->val[i].hivex_value_h;
CLEANUP_FREE char *key = guestfs_hivex_value_key (g, v);
if (key == NULL)
goto out;
if (STRCASEEQ (key, "Hostname")) {
fs->hostname = guestfs_hivex_value_utf8 (g, v);
if (!fs->hostname)
goto out;
}
/* many other interesting fields here ... */
}
ret = 0;
out:
guestfs_hivex_close (g);
return ret;
}
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;
}
