sfdisk: improve --wipe functionality

[thirdparty/util-linux.git] / disk-utils / fdisk-menu.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>

#include "c.h"
#include "fdisk.h"
#include "pt-sun.h"
#include "pt-mbr.h"

struct menu_entry {
	const char	key;			/* command key */
	const char	*title;			/* help string */
	unsigned int	normal : 1,		/* normal mode */
			expert : 1,		/* expert mode */
			hidden : 1;		/* be sensitive for this key,
						   but don't print it in help */

	enum fdisk_labeltype	label;		/* only for this label */
	int                     exclude;    /* all labels except these */
	enum fdisk_labeltype	parent;		/* for nested PT */
};

#define IS_MENU_SEP(e)	((e)->key == '-')
#define IS_MENU_HID(e)	((e)->hidden)

struct menu {
	enum fdisk_labeltype	label;		/* only for this label */
	int                     exclude;    /* all labels except these */

	unsigned int		nonested : 1;	/* don't make this menu active in nested PT */

	int (*callback)(struct fdisk_context **,
			const struct menu *,
			const struct menu_entry *);

	struct menu_entry	entries[];	/* NULL terminated array */
};

struct menu_context {
	size_t		menu_idx;		/* the current menu */
	size_t		entry_idx;		/* index with in the current menu */
};

#define MENU_CXT_EMPTY	{ 0, 0 }
#define DECLARE_MENU_CB(x) \
	static int x(struct fdisk_context **, \
		     const struct menu *, \
		     const struct menu_entry *)

DECLARE_MENU_CB(gpt_menu_cb);
DECLARE_MENU_CB(sun_menu_cb);
DECLARE_MENU_CB(sgi_menu_cb);
DECLARE_MENU_CB(geo_menu_cb);
DECLARE_MENU_CB(dos_menu_cb);
DECLARE_MENU_CB(bsd_menu_cb);
DECLARE_MENU_CB(createlabel_menu_cb);
DECLARE_MENU_CB(generic_menu_cb);

/*
 * Menu entry macros:
 *	MENU_X*    expert mode only
 *      MENU_B*    both -- expert + normal mode
 *
 *      *_E  exclude this label
 *      *_H  hidden
 *      *_L  only for this label
 */

/* separator */
#define MENU_SEP(t)		{ .title = t, .key = '-', .normal = 1 }
#define MENU_XSEP(t)		{ .title = t, .key = '-', .expert = 1 }
#define MENU_BSEP(t)		{ .title = t, .key = '-', .expert = 1, .normal = 1 }

/* entry */
#define MENU_ENT(k, t)		{ .title = t, .key = k, .normal = 1 }
#define MENU_ENT_E(k, t, l)	{ .title = t, .key = k, .normal = 1, .exclude = l }
#define MENU_ENT_L(k, t, l)	{ .title = t, .key = k, .normal = 1, .label = l }

#define MENU_XENT(k, t)		{ .title = t, .key = k, .expert = 1 }
#define MENU_XENT_H(k, t)	{ .title = t, .key = k, .expert = 1, .hidden = 1 }

#define MENU_BENT(k, t)		{ .title = t, .key = k, .expert = 1, .normal = 1 }
#define MENU_BENT_E(k, t, l)	{ .title = t, .key = k, .expert = 1, .normal = 1, .exclude = l }

#define MENU_ENT_NEST(k, t, l, p)	{ .title = t, .key = k, .normal = 1, .label = l, .parent = p }
#define MENU_XENT_NEST(k, t, l, p)	{ .title = t, .key = k, .expert = 1, .label = l, .parent = p }

/* Generic menu */
struct menu menu_generic = {
	.callback	= generic_menu_cb,
	.entries	= {
		MENU_BSEP(N_("Generic")),
		MENU_ENT  ('d', N_("delete a partition")),
		MENU_ENT  ('F', N_("list free unpartitioned space")),
		MENU_ENT  ('l', N_("list known partition types")),
		MENU_ENT  ('n', N_("add a new partition")),
		MENU_BENT ('p', N_("print the partition table")),
		MENU_ENT  ('t', N_("change a partition type")),
		MENU_BENT_E('v', N_("verify the partition table"), FDISK_DISKLABEL_BSD),
		MENU_ENT  ('i', N_("print information about a partition")),

		MENU_XENT('d', N_("print the raw data of the first sector from the device")),
		MENU_XENT('D', N_("print the raw data of the disklabel from the device")),
		MENU_XENT('f', N_("fix partitions order")),

		MENU_SEP(N_("Misc")),
		MENU_BENT ('m', N_("print this menu")),
		MENU_ENT_E('u', N_("change display/entry units"), FDISK_DISKLABEL_GPT),
		MENU_ENT_E('x', N_("extra functionality (experts only)"), FDISK_DISKLABEL_BSD),

		MENU_SEP(N_("Script")),
		MENU_ENT  ('I', N_("load disk layout from sfdisk script file")),
		MENU_ENT  ('O', N_("dump disk layout to sfdisk script file")),

		MENU_BSEP(N_("Save & Exit")),
		MENU_ENT_E('w', N_("write table to disk and exit"), FDISK_DISKLABEL_BSD),
		MENU_ENT_L('w', N_("write table to disk"), FDISK_DISKLABEL_BSD),
		MENU_BENT ('q', N_("quit without saving changes")),
		MENU_XENT ('r', N_("return to main menu")),

		MENU_ENT_NEST('r', N_("return from BSD to DOS"), FDISK_DISKLABEL_BSD, FDISK_DISKLABEL_DOS),

		{ 0, NULL }
	}
};

struct menu menu_createlabel = {
	.callback = createlabel_menu_cb,
	.exclude = FDISK_DISKLABEL_BSD,
	.nonested = 1,
	.entries = {
		MENU_SEP(N_("Create a new label")),
		MENU_ENT('g', N_("create a new empty GPT partition table")),
		MENU_ENT('G', N_("create a new empty SGI (IRIX) partition table")),
		MENU_ENT('o', N_("create a new empty DOS partition table")),
		MENU_ENT('s', N_("create a new empty Sun partition table")),

		/* backward compatibility -- be sensitive to 'g', but don't
		 * print it in the expert menu */
		MENU_XENT_H('g', N_("create an IRIX (SGI) partition table")),
		{ 0, NULL }
	}
};

struct menu menu_geo = {
	.callback = geo_menu_cb,
	.exclude = FDISK_DISKLABEL_GPT | FDISK_DISKLABEL_BSD,
	.entries = {
		MENU_XSEP(N_("Geometry")),
		MENU_XENT('c', N_("change number of cylinders")),
		MENU_XENT('h', N_("change number of heads")),
		MENU_XENT('s', N_("change number of sectors/track")),
		{ 0, NULL }
	}
};

struct menu menu_gpt = {
	.callback = gpt_menu_cb,
	.label = FDISK_DISKLABEL_GPT,
	.entries = {
		MENU_XSEP(N_("GPT")),
		MENU_XENT('i', N_("change disk GUID")),
		MENU_XENT('n', N_("change partition name")),
		MENU_XENT('u', N_("change partition UUID")),
		MENU_XENT('l', N_("change table length")),
		MENU_XENT('M', N_("enter protective/hybrid MBR")),

		MENU_XSEP(""),
		MENU_XENT('A', N_("toggle the legacy BIOS bootable flag")),
		MENU_XENT('B', N_("toggle the no block IO protocol flag")),
		MENU_XENT('R', N_("toggle the required partition flag")),
		MENU_XENT('S', N_("toggle the GUID specific bits")),

		{ 0, NULL }
	}
};

struct menu menu_sun = {
	.callback = sun_menu_cb,
	.label = FDISK_DISKLABEL_SUN,
	.entries = {
		MENU_BSEP(N_("Sun")),
		MENU_ENT('a', N_("toggle the read-only flag")),
		MENU_ENT('c', N_("toggle the mountable flag")),

		MENU_XENT('a', N_("change number of alternate cylinders")),
		MENU_XENT('e', N_("change number of extra sectors per cylinder")),
		MENU_XENT('i', N_("change interleave factor")),
		MENU_XENT('o', N_("change rotation speed (rpm)")),
		MENU_XENT('y', N_("change number of physical cylinders")),
		{ 0, NULL }
	}
};

struct menu menu_sgi = {
	.callback = sgi_menu_cb,
	.label = FDISK_DISKLABEL_SGI,
	.entries = {
		MENU_SEP(N_("SGI")),
		MENU_ENT('a', N_("select bootable partition")),
		MENU_ENT('b', N_("edit bootfile entry")),
		MENU_ENT('c', N_("select sgi swap partition")),
		MENU_ENT('i', N_("create SGI info")),
		{ 0, NULL }
	}
};

struct menu menu_dos = {
	.callback = dos_menu_cb,
	.label = FDISK_DISKLABEL_DOS,
	.entries = {
		MENU_BSEP(N_("DOS (MBR)")),
		MENU_ENT('a', N_("toggle a bootable flag")),
		MENU_ENT('b', N_("edit nested BSD disklabel")),
		MENU_ENT('c', N_("toggle the dos compatibility flag")),

		MENU_XENT('b', N_("move beginning of data in a partition")),
		MENU_XENT('i', N_("change the disk identifier")),

		MENU_XENT_NEST('M', N_("return from protective/hybrid MBR to GPT"),
					FDISK_DISKLABEL_DOS, FDISK_DISKLABEL_GPT),
		{ 0, NULL }
	}
};

struct menu menu_bsd = {
	.callback = bsd_menu_cb,
	.label = FDISK_DISKLABEL_BSD,
	.entries = {
		MENU_SEP(N_("BSD")),
		MENU_ENT('e', N_("edit drive data")),
		MENU_ENT('i', N_("install bootstrap")),
		MENU_ENT('s', N_("show complete disklabel")),
		MENU_ENT('x', N_("link BSD partition to non-BSD partition")),
		{ 0, NULL }
	}
};

static const struct menu *menus[] = {
	&menu_gpt,
	&menu_sun,
	&menu_sgi,
	&menu_dos,
	&menu_bsd,
	&menu_geo,
	&menu_generic,
	&menu_createlabel,
};

static const struct menu_entry *next_menu_entry(
			struct fdisk_context *cxt,
			struct menu_context *mc)
{
	struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
	struct fdisk_context *parent = fdisk_get_parent(cxt);
	unsigned int type = 0, pr_type = 0;

	assert(cxt);

	if (lb)
		type = fdisk_label_get_type(lb);
	if (parent)
		pr_type = fdisk_label_get_type(fdisk_get_label(parent, NULL));

	while (mc->menu_idx < ARRAY_SIZE(menus)) {
		const struct menu *m = menus[mc->menu_idx];
		const struct menu_entry *e = &(m->entries[mc->entry_idx]);

		/*
		 * whole-menu filter
		 */

		/* no more entries */
		if (e->title == NULL ||
		/* menu wanted for specified labels only */
		    (m->label && lb && !(m->label & type)) ||
		/* unwanted for nested PT */
		    (m->nonested && parent) ||
		/* menu excluded for specified labels */
		    (m->exclude && lb && (m->exclude & type))) {
			mc->menu_idx++;
			mc->entry_idx = 0;
			continue;
		}

		/*
		 * per entry filter
		 */

		/* excluded for the current label */
		if ((e->exclude && lb && e->exclude & type) ||
		/* entry wanted for specified labels only */
		    (e->label && lb && !(e->label & type)) ||
		/* exclude non-expert entries in expect mode */
		    (e->expert == 0 && fdisk_is_details(cxt)) ||
		/* nested only */
		    (e->parent && (!parent || pr_type != e->parent)) ||
		/* exclude non-normal entries in normal mode */
		    (e->normal == 0 && !fdisk_is_details(cxt))) {
			mc->entry_idx++;
			continue;
		}
		mc->entry_idx++;
		return e;

	}
	return NULL;
}

/* returns @menu and menu entry for then @key */
static const struct menu_entry *get_fdisk_menu_entry(
		struct fdisk_context *cxt,
		int key,
		const struct menu **menu)
{
	struct menu_context mc = MENU_CXT_EMPTY;
	const struct menu_entry *e;

	while ((e = next_menu_entry(cxt, &mc))) {
		if (IS_MENU_SEP(e) || e->key != key)
			continue;

		if (menu)
			*menu = menus[mc.menu_idx];
		return e;
	}

	return NULL;
}

static int menu_detect_collisions(struct fdisk_context *cxt)
{
	struct menu_context mc = MENU_CXT_EMPTY;
	const struct menu_entry *e, *r;

	while ((e = next_menu_entry(cxt, &mc))) {
		if (IS_MENU_SEP(e))
			continue;

		r = get_fdisk_menu_entry(cxt, e->key, NULL);
		if (!r) {
			DBG(MENU, ul_debug("warning: not found "
					"entry for %c", e->key));
			return -1;
		}
		if (r != e) {
			DBG(MENU, ul_debug("warning: duplicate key '%c'",
						e->key));
			DBG(MENU, ul_debug("       : %s", e->title));
			DBG(MENU, ul_debug("       : %s", r->title));
			abort();
		}
	}

	return 0;
}

static int print_fdisk_menu(struct fdisk_context *cxt)
{
	struct menu_context mc = MENU_CXT_EMPTY;
	const struct menu_entry *e;

	ON_DBG(MENU, menu_detect_collisions(cxt));

	if (fdisk_is_details(cxt))
		printf(_("\nHelp (expert commands):\n"));
	else
		printf(_("\nHelp:\n"));

	while ((e = next_menu_entry(cxt, &mc))) {
		if (IS_MENU_HID(e))
			continue;	/* hidden entry */
		if (IS_MENU_SEP(e) && (!e->title || !*e->title))
			printf("\n");
		else if (IS_MENU_SEP(e)) {
			color_scheme_enable("help-title", UL_COLOR_BOLD);
			printf("\n  %s\n", _(e->title));
			color_disable();
		} else
			printf("   %c   %s\n", e->key, _(e->title));
	}
	fputc('\n', stdout);

	if (fdisk_get_parent(cxt)) {
		struct fdisk_label *l = fdisk_get_label(cxt, NULL),
				   *p = fdisk_get_label(fdisk_get_parent(cxt), NULL);

		fdisk_info(cxt, _("You're editing nested '%s' partition table, "
				  "primary partition table is '%s'."),
				fdisk_label_get_name(l),
				fdisk_label_get_name(p));
	}

	return 0;
}

/* Asks for command, verify the key and perform the command or
 * returns the command key if no callback for the command is
 * implemented.
 *
 * Note that this function might exchange the context pointer to
 * switch to another (nested) context.
 *
 * Returns: <0 on error
 *           0 on success (the command performed)
 *          >0 if no callback (then returns the key)
 */
int process_fdisk_menu(struct fdisk_context **cxt0)
{
	struct fdisk_context *cxt = *cxt0;
	const struct menu_entry *ent;
	const struct menu *menu;
	int key, rc;
	const char *prompt;
	char buf[BUFSIZ];

	if (fdisk_is_details(cxt))
		prompt = _("Expert command (m for help): ");
	else
		prompt = _("Command (m for help): ");

	fputc('\n',stdout);
	rc = get_user_reply(cxt, prompt, buf, sizeof(buf));
	if (rc)
		return rc;

	key = buf[0];
	ent = get_fdisk_menu_entry(cxt, key, &menu);
	if (!ent) {
		fdisk_warnx(cxt, _("%c: unknown command"), key);
		return -EINVAL;
	}

	DBG(MENU, ul_debug("selected: key=%c, entry='%s'",
				key, ent->title));

	/* menu has implemented callback, use it */
	if (menu->callback)
		rc = menu->callback(cxt0, menu, ent);
	else {
		DBG(MENU, ul_debug("no callback for key '%c'", key));
		rc = -EINVAL;
	}

	DBG(MENU, ul_debug("process menu done [rc=%d]", rc));
	return rc;
}

static int script_read(struct fdisk_context *cxt)
{
	struct fdisk_script *sc = NULL;
	char *filename = NULL;
	int rc;

	rc = fdisk_ask_string(cxt, _("Enter script file name"), &filename);
	if (rc)
		return rc;

	errno = 0;
	sc = fdisk_new_script_from_file(cxt, filename);
	if (!sc && errno)
		fdisk_warn(cxt, _("Cannot open %s"), filename);
	else if (!sc)
		fdisk_warnx(cxt, _("Failed to parse script file %s"), filename);
	else if (fdisk_apply_script(cxt, sc) != 0)
		fdisk_warnx(cxt, _("Failed to apply script %s"), filename);
	else
		fdisk_info(cxt, _("Script successfully applied."));

	fdisk_unref_script(sc);
	free(filename);
	return rc;
}

static int script_write(struct fdisk_context *cxt)
{
	struct fdisk_script *sc = NULL;
	char *filename = NULL;
	FILE *f = NULL;
	int rc;

	rc = fdisk_ask_string(cxt, _("Enter script file name"), &filename);
	if (rc)
		return rc;

	sc = fdisk_new_script(cxt);
	if (!sc) {
		fdisk_warn(cxt, _("Failed to allocate script handler"));
		goto done;
	}

	rc = fdisk_script_read_context(sc, NULL);
	if (rc) {
		fdisk_warnx(cxt, _("Failed to transform disk layout into script"));
		goto done;
	}

	f = fopen(filename, "w");
	if (!f) {
		fdisk_warn(cxt, _("Cannot open %s"), filename);
		goto done;
	}

	rc = fdisk_script_write_file(sc, f);
	if (rc)
		fdisk_warn(cxt, _("Failed to write script %s"), filename);
	else
		fdisk_info(cxt, _("Script successfully saved."));
done:
	if (f)
		fclose(f);
	fdisk_unref_script(sc);
	free(filename);
	return rc;
}

static int ask_for_wipe(struct fdisk_context *cxt, size_t partno)
{
	struct fdisk_partition *tmp = NULL;
	char *fstype = NULL;
	int rc, yes = 0;

	rc = fdisk_get_partition(cxt, partno, &tmp);
	if (rc)
		goto done;

	rc = fdisk_partition_to_string(tmp, cxt, FDISK_FIELD_FSTYPE, &fstype);
	if (rc || fstype == NULL)
		goto done;

	fdisk_warnx(cxt, _("Partition #%zu contains a %s signature."), partno + 1, fstype);

	if (pwipemode == WIPEMODE_AUTO && isatty(STDIN_FILENO))
		fdisk_ask_yesno(cxt, _("Do you want to remove the signature?"), &yes);
	else if (pwipemode == WIPEMODE_ALWAYS)
		yes = 1;

	if (yes) {
		fdisk_info(cxt, _("The signature will be removed by a write command."));
		rc = fdisk_wipe_partition(cxt, partno, TRUE);
	}
done:
	fdisk_unref_partition(tmp);
	free(fstype);
	return rc;
}

/*
 * Basic fdisk actions
 */
static int generic_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = 0;
	size_t n;

	/* actions shared between expert and normal mode */
	switch (ent->key) {
	case 'p':
		list_disk_geometry(cxt);
		list_disklabel(cxt);
		break;
	case 'w':
		if (fdisk_is_readonly(cxt)) {
			fdisk_warnx(cxt, _("Device is open in read-only mode."));
			break;
		}
		rc = fdisk_write_disklabel(cxt);
		if (rc)
			err(EXIT_FAILURE, _("failed to write disklabel"));
		if (fdisk_get_parent(cxt))
			break; /* nested PT, don't leave */
		fdisk_info(cxt, _("The partition table has been altered."));
		rc = fdisk_reread_partition_table(cxt);
		if (!rc)
			rc = fdisk_deassign_device(cxt, 0);
		/* fallthrough */
	case 'q':
		fdisk_unref_context(cxt);
		fputc('\n', stdout);
		exit(rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
	case 'm':
		rc = print_fdisk_menu(cxt);
		break;
	case 'v':
		rc = fdisk_verify_disklabel(cxt);
		break;
	case 'i':
		rc = print_partition_info(cxt);
		break;
	case 'F':
		list_freespace(cxt);
		break;
	}

	/* expert mode */
	if (ent->expert) {
		switch (ent->key) {
		case 'd':
			dump_firstsector(cxt);
			break;
		case 'D':
			dump_disklabel(cxt);
			break;
		case 'f':
			rc = fdisk_reorder_partitions(cxt);
			if (rc)
				fdisk_warnx(cxt, _("Failed to fix partitions order."));
			else
				fdisk_info(cxt, _("Partitions order fixed."));
			break;
		case 'r':
			rc = fdisk_enable_details(cxt, 0);
			break;
		}
		return rc;
	}

	/* normal mode */
	switch (ent->key) {
	case 'd':
		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (!rc)
			rc = fdisk_delete_partition(cxt, n);
		if (rc)
			fdisk_warnx(cxt, _("Could not delete partition %zu"), n + 1);
		else
			fdisk_info(cxt, _("Partition %zu has been deleted."), n + 1);
		break;
	case 'I':
		script_read(cxt);
		break;
	case 'O':
		script_write(cxt);
		break;
	case 'l':
		list_partition_types(cxt);
		break;
	case 'n':
	{
		size_t partno;
		rc = fdisk_add_partition(cxt, NULL, &partno);
		if (!rc)
			rc = ask_for_wipe(cxt, partno);
		break;
	}
	case 't':
		change_partition_type(cxt);
		break;
	case 'u':
		fdisk_set_unit(cxt,
			fdisk_use_cylinders(cxt) ? "sectors" :
							   "cylinders");
		if (fdisk_use_cylinders(cxt))
			fdisk_info(cxt, _("Changing display/entry units to cylinders (DEPRECATED!)."));
		else
			fdisk_info(cxt, _("Changing display/entry units to sectors."));
		break;
	case 'x':
		fdisk_enable_details(cxt, 1);
		break;
	case 'r':
		/* return from nested BSD to DOS */
		if (fdisk_get_parent(cxt)) {
			*cxt0 = fdisk_get_parent(cxt);

			fdisk_info(cxt, _("Leaving nested disklabel."));
			fdisk_unref_context(cxt);
		}
		break;
	}

	return rc;
}


/*
 * This is fdisk frontend for GPT specific libfdisk functions that
 * are not exported by generic libfdisk API.
 */
static int gpt_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	struct fdisk_context *mbr;
	struct fdisk_partition *pa = NULL;
	size_t n;
	int rc = 0;
	uintmax_t length = 0;

	assert(cxt);
	assert(ent);
	assert(fdisk_is_label(cxt, GPT));

	DBG(MENU, ul_debug("enter GPT menu"));

	if (ent->expert) {
		switch (ent->key) {
		case 'i':
			return fdisk_set_disklabel_id(cxt);
		case 'l':
	                rc =  fdisk_ask_number(cxt, 1, fdisk_get_npartitions(cxt),
	                                ~(uint32_t)0, _("New maximum entries"), &length);
			if (rc)
				return rc;
			return fdisk_gpt_set_npartitions(cxt, (uint32_t) length);
		case 'M':
			mbr = fdisk_new_nested_context(cxt, "dos");
			if (!mbr)
				return -ENOMEM;
			*cxt0 = cxt = mbr;
			fdisk_enable_details(cxt, 1);	/* keep us in expert mode */
			fdisk_info(cxt, _("Entering protective/hybrid MBR disklabel."));
			return 0;
		}

		/* actions where is necessary partnum */
		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (rc)
			return rc;

		switch(ent->key) {
		case 'u':
			pa = fdisk_new_partition();	/* new template */
			if (!pa)
				rc = -ENOMEM;
			else {
				char *str = NULL;
				rc = fdisk_ask_string(cxt, _("New UUID (in 8-4-4-4-12 format)"), &str);
				if (!rc)
					rc = fdisk_partition_set_uuid(pa, str);
				if (!rc)
					rc = fdisk_set_partition(cxt, n, pa);
				free(str);
				fdisk_unref_partition(pa);
			}
			break;
		case 'n':
			pa = fdisk_new_partition();	/* new template */
			if (!pa)
				rc = -ENOMEM;
			else {
				char *str = NULL;
				rc = fdisk_ask_string(cxt, _("New name"), &str);
				if (!rc)
					rc = fdisk_partition_set_name(pa, str);
				if (!rc)
					rc = fdisk_set_partition(cxt, n, pa);
				free(str);
				fdisk_unref_partition(pa);
			}
			break;
		case 'A':
			rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_LEGACYBOOT);
			break;
		case 'B':
			rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_NOBLOCK);
			break;
		case 'R':
			rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_REQUIRED);
			break;
		case 'S':
			rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_GUIDSPECIFIC);
			break;
		}
	}

	return rc;
}


/*
 * This is fdisk frontend for MBR specific libfdisk functions that
 * are not exported by generic libfdisk API.
 */
static int dos_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = 0;

	DBG(MENU, ul_debug("enter DOS menu"));

	if (!ent->expert) {
		switch (ent->key) {
		case 'a':
		{
			size_t n;
			rc = fdisk_ask_partnum(cxt, &n, FALSE);
			if (!rc)
				rc = fdisk_toggle_partition_flag(cxt, n, DOS_FLAG_ACTIVE);
			break;
		}
		case 'b':
		{
			struct fdisk_context *bsd
					= fdisk_new_nested_context(cxt, "bsd");
			if (!bsd)
				return -ENOMEM;
			if (!fdisk_has_label(bsd))
				rc = fdisk_create_disklabel(bsd, "bsd");
			if (rc)
				fdisk_unref_context(bsd);
			else {
				*cxt0 = cxt = bsd;
				fdisk_info(cxt,	_("Entering nested BSD disklabel."));
			}
			break;
		}
		case 'c':
			toggle_dos_compatibility_flag(cxt);
			break;
		}
		return rc;
	}

	/* expert mode */
	switch (ent->key) {
	case 'b':
	{
		size_t n;
		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (!rc)
			rc = fdisk_dos_move_begin(cxt, n);
		break;
	}
	case 'i':
		rc = fdisk_set_disklabel_id(cxt);
		break;
	case 'M':
		/* return from nested MBR to GPT */
		if (fdisk_get_parent(cxt)) {
			*cxt0 = fdisk_get_parent(cxt);

			fdisk_info(cxt, _("Leaving nested disklabel."));
			fdisk_unref_context(cxt);
		}
		break;
	}
	return rc;
}

static int sun_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = 0;

	DBG(MENU, ul_debug("enter SUN menu"));

	assert(cxt);
	assert(ent);
	assert(fdisk_is_label(cxt, SUN));

	DBG(MENU, ul_debug("enter SUN menu"));

	/* normal mode */
	if (!ent->expert) {
		size_t n;

		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (rc)
			return rc;
		switch (ent->key) {
		case 'a':
			rc = fdisk_toggle_partition_flag(cxt, n, SUN_FLAG_RONLY);
			break;
		case 'c':
			rc = fdisk_toggle_partition_flag(cxt, n, SUN_FLAG_UNMNT);
			break;
		}
		return rc;
	}

	/* expert mode */
	switch (ent->key) {
	case 'a':
		rc = fdisk_sun_set_alt_cyl(cxt);
		break;
	case 'e':
		rc = fdisk_sun_set_xcyl(cxt);
		break;
	case 'i':
		rc = fdisk_sun_set_ilfact(cxt);
		break;
	case 'o':
		rc = fdisk_sun_set_rspeed(cxt);
		break;
	case 'y':
		rc = fdisk_sun_set_pcylcount(cxt);
		break;
	}
	return rc;
}

static int sgi_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = -EINVAL;
	size_t n = 0;

	DBG(MENU, ul_debug("enter SGI menu"));

	assert(cxt);
	assert(ent);
	assert(fdisk_is_label(cxt, SGI));

	if (ent->expert)
		return rc;

	switch (ent->key) {
	case 'a':
		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (!rc)
			rc = fdisk_toggle_partition_flag(cxt, n, SGI_FLAG_BOOT);
		break;
	case 'b':
		fdisk_sgi_set_bootfile(cxt);
		break;
	case 'c':
		rc = fdisk_ask_partnum(cxt, &n, FALSE);
		if (!rc)
			rc = fdisk_toggle_partition_flag(cxt, n, SGI_FLAG_SWAP);
		break;
	case 'i':
		rc = fdisk_sgi_create_info(cxt);
		break;
	}

	return rc;
}

/*
 * This is fdisk frontend for BSD specific libfdisk functions that
 * are not exported by generic libfdisk API.
 */
static int bsd_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = 0, org;

	assert(cxt);
	assert(ent);
	assert(fdisk_is_label(cxt, BSD));

	DBG(MENU, ul_debug("enter BSD menu"));

	switch(ent->key) {
	case 'e':
		rc = fdisk_bsd_edit_disklabel(cxt);
		break;
	case 'i':
		rc = fdisk_bsd_write_bootstrap(cxt);
		break;
	case 's':
		org = fdisk_is_details(cxt);

		fdisk_enable_details(cxt, 1);
		list_disklabel(cxt);
		fdisk_enable_details(cxt, org);
		break;
	case 'x':
		rc = fdisk_bsd_link_partition(cxt);
		break;
	}
	return rc;
}

/* C/H/S commands */
static int geo_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = -EINVAL;
	uintmax_t c = 0, h = 0, s = 0;

	DBG(MENU, ul_debug("enter GEO menu"));

	assert(cxt);
	assert(ent);

	switch (ent->key) {
	case 'c':
		rc =  fdisk_ask_number(cxt, 1, fdisk_get_geom_cylinders(cxt),
				1048576, _("Number of cylinders"), &c);
		break;
	case 'h':
		rc =  fdisk_ask_number(cxt, 1, fdisk_get_geom_heads(cxt),
				256, _("Number of heads"), &h);
		break;
	case 's':
		rc =  fdisk_ask_number(cxt, 1, fdisk_get_geom_sectors(cxt),
				63, _("Number of sectors"), &s);
		break;
	}

	if (!rc)
		fdisk_override_geometry(cxt, c, h, s);
	return rc;
}

static int createlabel_menu_cb(struct fdisk_context **cxt0,
		       const struct menu *menu __attribute__((__unused__)),
		       const struct menu_entry *ent)
{
	struct fdisk_context *cxt = *cxt0;
	int rc = -EINVAL;

	DBG(MENU, ul_debug("enter Create label menu"));

	assert(cxt);
	assert(ent);

	if (ent->expert) {
		switch (ent->key) {
		case 'g':
			/* Deprecated, use 'G' in main menu, just for backward
			 * compatibility only. */
			rc = fdisk_create_disklabel(cxt, "sgi");
			break;
		}
		return rc;
	}

	switch (ent->key) {
		case 'g':
			fdisk_create_disklabel(cxt, "gpt");
			break;
		case 'G':
			fdisk_create_disklabel(cxt, "sgi");
			break;
		case 'o':
			fdisk_create_disklabel(cxt, "dos");
			break;
		case 's':
			fdisk_create_disklabel(cxt, "sun");
			break;
	}
	return rc;
}