/* Test guestfs___join_strings. */
static void
test_join (void)
{
char *ret;
const char *test1[] = { NULL };
const char *test2[] = { "", NULL };
const char *test3[] = { "a", NULL };
const char *test4[] = { "a", "", NULL };
const char *test5[] = { "a", "b", NULL };
ret = guestfs___join_strings (":!", (char **) test1);
assert (STREQ (ret, ""));
free (ret);
ret = guestfs___join_strings (":!", (char **) test2);
assert (STREQ (ret, ""));
free (ret);
ret = guestfs___join_strings (":!", (char **) test3);
assert (STREQ (ret, "a"));
free (ret);
ret = guestfs___join_strings (":!", (char **) test4);
assert (STREQ (ret, "a:!"));
free (ret);
ret = guestfs___join_strings (":!", (char **) test5);
assert (STREQ (ret, "a:!b"));
free (ret);
}
static void
write_row (const char *name, const char *type,
const char *vfs_type, const char *vfs_label, int mbr_id,
int64_t size, char **parents, const char *uuid)
{
const char *strings[NR_COLUMNS];
CLEANUP_FREE char *parents_str = NULL;
size_t len = 0;
char hum[LONGEST_HUMAN_READABLE];
char num[256];
char mbr_id_str[3];
if ((columns & COLUMN_NAME))
strings[len++] = name;
if ((columns & COLUMN_TYPE))
strings[len++] = type;
if ((columns & COLUMN_VFS_TYPE))
strings[len++] = vfs_type;
if ((columns & COLUMN_VFS_LABEL))
strings[len++] = vfs_label;
if ((columns & COLUMN_MBR)) {
if (mbr_id >= 0) {
snprintf (mbr_id_str, sizeof mbr_id_str, "%02x", mbr_id);
strings[len++] = mbr_id_str;
} else
strings[len++] = NULL;
}
if ((columns & COLUMN_SIZE)) {
if (size >= 0) {
if (human) {
strings[len++] =
human_readable ((uintmax_t) size, hum,
human_round_to_nearest|human_autoscale|
human_base_1024|human_SI,
1, 1);
}
else {
snprintf (num, sizeof num, "%" PRIi64, size);
strings[len++] = num;
}
}
else
strings[len++] = NULL;
}
if ((columns & COLUMN_PARENTS)) {
/* Internally comma-separated field. */
parents_str = guestfs___join_strings (",", parents);
strings[len++] = parents_str;
}
if ((columns & COLUMN_UUID))
strings[len++] = uuid;
assert (len <= NR_COLUMNS);
write_row_strings ((char **) strings, len);
}
static int
disk_create_qcow2 (guestfs_h *g, const char *orig_filename, int64_t size,
const char *backingfile,
const struct guestfs_disk_create_argv *optargs)
{
CLEANUP_FREE char *filename = NULL;
const char *backingformat = NULL;
const char *preallocation = NULL;
const char *compat = NULL;
int clustersize = -1;
CLEANUP_FREE_STRINGSBUF DECLARE_STRINGSBUF (optionsv);
CLEANUP_CMD_CLOSE struct command *cmd = guestfs___new_command (g);
int r;
/* If the filename is something like "file:foo" then qemu-img will
* try to interpret that as "foo" in the file:/// protocol. To
* avoid that, if the path is relative prefix it with "./" since
* qemu-img won't try to interpret such a path.
*/
if (orig_filename[0] != '/')
filename = safe_asprintf (g, "./%s", orig_filename);
else
filename = safe_strdup (g, orig_filename);
if (optargs->bitmask & GUESTFS_DISK_CREATE_BACKINGFORMAT_BITMASK) {
backingformat = optargs->backingformat;
if (STRNEQ (backingformat, "raw") && STRNEQ (backingformat, "qcow2")) {
error (g, _("invalid value for backingformat parameter '%s'"),
backingformat);
return -1;
}
}
if (optargs->bitmask & GUESTFS_DISK_CREATE_PREALLOCATION_BITMASK) {
preallocation = optargs->preallocation;
if (STRNEQ (preallocation, "off") && STRNEQ (preallocation, "metadata")) {
error (g, _("invalid value for preallocation parameter '%s'"),
preallocation);
return -1;
}
}
if (optargs->bitmask & GUESTFS_DISK_CREATE_COMPAT_BITMASK) {
compat = optargs->compat;
if (STRNEQ (compat, "0.10") && STRNEQ (compat, "1.1")) {
error (g, _("invalid value for compat parameter '%s'"), compat);
return -1;
}
}
if (optargs->bitmask & GUESTFS_DISK_CREATE_CLUSTERSIZE_BITMASK) {
clustersize = optargs->clustersize;
if (clustersize < 512 || clustersize > 2097152 ||
!is_power_of_2 ((unsigned) clustersize)) {
error (g, _("invalid value for clustersize parameter '%d'"),
clustersize);
return -1;
}
}
/* Assemble the qemu-img command line. */
guestfs___cmd_add_arg (cmd, "qemu-img");
guestfs___cmd_add_arg (cmd, "create");
guestfs___cmd_add_arg (cmd, "-f");
guestfs___cmd_add_arg (cmd, "qcow2");
/* -o parameter. */
if (backingfile) {
CLEANUP_FREE char *p = qemu_escape_param (g, backingfile);
guestfs___add_sprintf (g, &optionsv, "backing_file=%s", p);
}
if (backingformat)
guestfs___add_sprintf (g, &optionsv, "backing_fmt=%s", backingformat);
if (preallocation)
guestfs___add_sprintf (g, &optionsv, "preallocation=%s", preallocation);
if (compat)
guestfs___add_sprintf (g, &optionsv, "compat=%s", compat);
if (clustersize >= 0)
guestfs___add_sprintf (g, &optionsv, "cluster_size=%d", clustersize);
guestfs___end_stringsbuf (g, &optionsv);
if (optionsv.size > 1) {
CLEANUP_FREE char *options = guestfs___join_strings (",", optionsv.argv);
guestfs___cmd_add_arg (cmd, "-o");
guestfs___cmd_add_arg (cmd, options);
}
/* Complete the command line. */
guestfs___cmd_add_arg (cmd, filename);
if (size >= 0)
guestfs___cmd_add_arg_format (cmd, "%" PRIi64, size);
r = guestfs___cmd_run (cmd);
if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
guestfs___external_command_failed (g, r, "qemu-img", orig_filename);
return -1;
}
return 0;
}
