void
free_drives (struct drv *drv)
{
if (!drv) return;
free_drives (drv->next);
free (drv->device);
switch (drv->type) {
case drv_a:
free (drv->a.filename);
/* a.format is an optarg, so don't free it */
break;
case drv_uri:
free (drv->uri.path);
free (drv->uri.protocol);
guestfs___free_string_list (drv->uri.server);
free (drv->uri.username);
break;
case drv_d:
/* d.filename is optarg, don't free it */
break;
#if COMPILING_GUESTFISH
case drv_N:
free (drv->N.filename);
drv->N.data_free (drv->N.data);
break;
#endif
default: ; /* keep GCC happy */
}
free (drv);
}
void
guestfs___free_inspect_info (guestfs_h *g)
{
size_t i, j;
for (i = 0; i < g->nr_fses; ++i) {
free (g->fses[i].mountable);
free (g->fses[i].product_name);
free (g->fses[i].product_variant);
free (g->fses[i].arch);
free (g->fses[i].hostname);
free (g->fses[i].windows_systemroot);
free (g->fses[i].windows_current_control_set);
for (j = 0; j < g->fses[i].nr_fstab; ++j) {
free (g->fses[i].fstab[j].mountable);
free (g->fses[i].fstab[j].mountpoint);
}
free (g->fses[i].fstab);
if (g->fses[i].drive_mappings)
guestfs___free_string_list (g->fses[i].drive_mappings);
}
free (g->fses);
g->nr_fses = 0;
g->fses = NULL;
}
/* Test guestfs___split_string. */
static void
test_split (void)
{
char **ret;
ret = guestfs___split_string (':', "");
assert (ret);
assert (guestfs___count_strings (ret) == 0);
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', "a");
assert (ret);
assert (guestfs___count_strings (ret) == 1);
assert (STREQ (ret[0], "a"));
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', ":");
assert (ret);
assert (guestfs___count_strings (ret) == 2);
assert (STREQ (ret[0], ""));
assert (STREQ (ret[1], ""));
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', "::");
assert (ret);
assert (guestfs___count_strings (ret) == 3);
assert (STREQ (ret[0], ""));
assert (STREQ (ret[1], ""));
assert (STREQ (ret[2], ""));
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', ":a");
assert (ret);
assert (guestfs___count_strings (ret) == 2);
assert (STREQ (ret[0], ""));
assert (STREQ (ret[1], "a"));
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', "a:");
assert (ret);
assert (guestfs___count_strings (ret) == 2);
assert (STREQ (ret[0], "a"));
assert (STREQ (ret[1], ""));
guestfs___free_string_list (ret);
ret = guestfs___split_string (':', "a:b:c");
assert (ret);
assert (guestfs___count_strings (ret) == 3);
assert (STREQ (ret[0], "a"));
assert (STREQ (ret[1], "b"));
assert (STREQ (ret[2], "c"));
guestfs___free_string_list (ret);
}
value
virt_resize_parse_uri (value argv /* arg value, not an array! */)
{
CAMLparam1 (argv);
CAMLlocal4 (rv, sv, ssv, ov);
struct uri uri;
int r;
size_t len;
r = parse_uri (String_val (argv), &uri);
if (r == -1)
caml_invalid_argument ("URI.parse_uri");
/* Convert the struct into an OCaml tuple. */
rv = caml_alloc_tuple (4);
/* path : string */
sv = caml_copy_string (uri.path);
free (uri.path);
Store_field (rv, 0, sv);
/* protocol : string */
sv = caml_copy_string (uri.protocol);
free (uri.protocol);
Store_field (rv, 1, sv);
/* server : string array option */
if (uri.server) {
ssv = caml_copy_string_array ((const char **) uri.server);
guestfs___free_string_list (uri.server);
ov = caml_alloc (1, 0);
Store_field (ov, 0, ssv);
}
else
ov = Val_int (0);
Store_field (rv, 2, ov);
/* username : string option */
if (uri.username) {
sv = caml_copy_string (uri.username);
free (uri.username);
ov = caml_alloc (1, 0);
Store_field (ov, 0, sv);
}
else
ov = Val_int (0);
Store_field (rv, 3, ov);
CAMLreturn (rv);
}
/* Get the first matching line (using egrep [-i]) of a small file,
* without any trailing newline character.
*
* Returns: 1 = returned a line (in *ret)
* 0 = no match
* -1 = error
*/
int
guestfs___first_egrep_of_file (guestfs_h *g, const char *filename,
const char *eregex, int iflag, char **ret)
{
char **lines;
int64_t size;
size_t i;
struct guestfs_grep_opts_argv optargs;
/* Don't trust guestfs_grep not to break with very large files.
* Check the file size is something reasonable first.
*/
size = guestfs_filesize (g, filename);
if (size == -1)
/* guestfs_filesize failed and has already set error in handle */
return -1;
if (size > MAX_SMALL_FILE_SIZE) {
error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
filename, size);
return -1;
}
optargs.bitmask = GUESTFS_GREP_OPTS_EXTENDED_BITMASK;
optargs.extended = 1;
if (iflag) {
optargs.bitmask |= GUESTFS_GREP_OPTS_INSENSITIVE_BITMASK;
optargs.insensitive = 1;
}
lines = guestfs_grep_opts_argv (g, eregex, filename, &optargs);
if (lines == NULL)
return -1;
if (lines[0] == NULL) {
guestfs___free_string_list (lines);
return 0;
}
*ret = lines[0]; /* caller frees */
/* free up any other matches and the array itself */
for (i = 1; lines[i] != NULL; ++i)
free (lines[i]);
free (lines);
return 1;
}
/* Get the first line of a small file, without any trailing newline
* character.
*
* NOTE: If the file is completely empty or begins with a '\n'
* character, this returns an empty string (not NULL). The caller
* will usually need to check for this case.
*/
char *
guestfs___first_line_of_file (guestfs_h *g, const char *filename)
{
char **lines = NULL; /* sic: not CLEANUP_FREE_STRING_LIST */
int64_t size;
char *ret;
/* Don't trust guestfs_head_n not to break with very large files.
* Check the file size is something reasonable first.
*/
size = guestfs_filesize (g, filename);
if (size == -1)
/* guestfs_filesize failed and has already set error in handle */
return NULL;
if (size > MAX_SMALL_FILE_SIZE) {
error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
filename, size);
return NULL;
}
lines = guestfs_head_n (g, 1, filename);
if (lines == NULL)
return NULL;
if (lines[0] == NULL) {
guestfs___free_string_list (lines);
/* Empty file: Return an empty string as explained above. */
return safe_strdup (g, "");
}
/* lines[1] should be NULL because of '1' argument above ... */
ret = lines[0]; /* caller frees */
free (lines);
return ret;
}
/* This function implements the -i option. */
void
inspect_mount (void)
{
if (live) {
fprintf (stderr, _("%s: don't use --live and -i options together\n"),
program_name);
exit (EXIT_FAILURE);
}
inspect_do_decrypt ();
char **roots = guestfs_inspect_os (g);
if (roots == NULL)
exit (EXIT_FAILURE);
if (roots[0] == NULL) {
fprintf (stderr,
_("%s: no operating system was found on this disk\n"
"\n"
"If using guestfish '-i' option, remove this option and instead\n"
"use the commands 'run' followed by 'list-filesystems'.\n"
"You can then mount filesystems you want by hand using the\n"
"'mount' or 'mount-ro' command.\n"
"\n"
"If using guestmount '-i', remove this option and choose the\n"
"filesystem(s) you want to see by manually adding '-m' option(s).\n"
"Use 'virt-filesystems' to see what filesystems are available.\n"
"\n"
"If using other virt tools, this disk image won't work\n"
"with these tools. Use the guestfish equivalent commands\n"
"(see the virt tool manual page).\n"),
program_name);
guestfs___free_string_list (roots);
exit (EXIT_FAILURE);
}
if (roots[1] != NULL) {
fprintf (stderr,
_("%s: multi-boot operating systems are not supported\n"
"\n"
"If using guestfish '-i' option, remove this option and instead\n"
"use the commands 'run' followed by 'list-filesystems'.\n"
"You can then mount filesystems you want by hand using the\n"
"'mount' or 'mount-ro' command.\n"
"\n"
"If using guestmount '-i', remove this option and choose the\n"
"filesystem(s) you want to see by manually adding '-m' option(s).\n"
"Use 'virt-filesystems' to see what filesystems are available.\n"
"\n"
"If using other virt tools, multi-boot operating systems won't work\n"
"with these tools. Use the guestfish equivalent commands\n"
"(see the virt tool manual page).\n"),
program_name);
guestfs___free_string_list (roots);
exit (EXIT_FAILURE);
}
root = roots[0];
free (roots);
inspect_mount_root (root);
}
