Adding upstream version 2.38.1.upstream/2.38.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2847 insertions, 0 deletions

diff --git a/disk-utils/cfdisk.c b/disk-utils/cfdisk.c
new file mode 100644
index 0000000..36eb3f8
--- /dev/null
+++ b/disk-utils/cfdisk.c
@@ -0,0 +1,2847 @@
+/*
+ * cfdisk.c - Display or manipulate a disk partition table.
+ *
+ *     Copyright (C) 2014-2015 Karel Zak <kzak@redhat.com>
+ *     Copyright (C) 1994 Kevin E. Martin (martin@cs.unc.edu)
+ *
+ *     The original cfdisk was inspired by the fdisk program
+ *           by A. V. Le Blanc (leblanc@mcc.ac.uk.
+ *
+ * cfdisk is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <assert.h>
+#include <libsmartcols.h>
+#include <sys/ioctl.h>
+#include <libfdisk.h>
+
+#ifdef HAVE_LIBMOUNT
+# include <libmount.h>	/* keep it optional for non-linux systems */
+#endif
+
+#ifdef HAVE_SLANG_H
+# include <slang.h>
+#elif defined(HAVE_SLANG_SLANG_H)
+# include <slang/slang.h>
+#endif
+
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 500 /* for inclusion of get_wch */
+#endif
+
+#ifdef HAVE_SLCURSES_H
+# include <slcurses.h>
+#elif defined(HAVE_SLANG_SLCURSES_H)
+# include <slang/slcurses.h>
+#elif defined(HAVE_NCURSESW_NCURSES_H) && defined(HAVE_WIDECHAR)
+# include <ncursesw/ncurses.h>
+#elif defined(HAVE_NCURSES_H)
+# include <ncurses.h>
+#elif defined(HAVE_NCURSES_NCURSES_H)
+# include <ncurses/ncurses.h>
+#endif
+
+#ifdef HAVE_WIDECHAR
+# include <wctype.h>
+# include <wchar.h>
+#endif
+
+#include "c.h"
+#include "closestream.h"
+#include "nls.h"
+#include "strutils.h"
+#include "xalloc.h"
+#include "mbsalign.h"
+#include "mbsedit.h"
+#include "colors.h"
+#include "debug.h"
+#include "list.h"
+#include "blkdev.h"
+
+static const char *default_disks[] = {
+#ifdef __GNU__
+		"/dev/hd0",
+		"/dev/sd0",
+#elif defined(__FreeBSD__)
+		"/dev/ad0",
+		"/dev/da0",
+#else
+		"/dev/sda",
+		"/dev/vda",
+		"/dev/hda",
+#endif
+};
+
+#define ARROW_CURSOR_STRING	">>  "
+#define ARROW_CURSOR_DUMMY	"    "
+#define ARROW_CURSOR_WIDTH	(sizeof(ARROW_CURSOR_STRING) - 1)
+
+/* vertical menu */
+#define MENU_V_SPADDING		1	/* space around menu item string */
+
+/* horizontal menu */
+#define MENU_H_SPADDING		0	/* space around menu item string */
+#define MENU_H_BETWEEN		2	/* space between menu items */
+#define MENU_H_PRESTR		"["
+#define MENU_H_POSTSTR		"]"
+
+#define MENU_TITLE_PADDING	3
+
+#define MENU_H_PRESTR_SZ	(sizeof(MENU_H_PRESTR) - 1)
+#define MENU_H_POSTSTR_SZ	(sizeof(MENU_H_POSTSTR) - 1)
+
+#define TABLE_START_LINE	4
+#define MENU_START_LINE		(ui_lines - 4)		/* The menu maybe use two lines */
+#define INFO_LINE		(ui_lines - 2)
+#define WARN_LINE		INFO_LINE
+#define HINT_LINE		(ui_lines - 1)
+
+#define CFDISK_ERR_ESC		5000
+
+#ifndef KEY_ESC
+# define KEY_ESC	'\033'
+#endif
+#ifndef KEY_DELETE
+# define KEY_DELETE	'\177'
+#endif
+#ifndef KEY_DC
+# define KEY_DC		0423
+#endif
+
+
+/* colors */
+enum {
+	CFDISK_CL_NONE = 0,
+	CFDISK_CL_WARNING,
+	CFDISK_CL_FREESPACE,
+	CFDISK_CL_INFO
+};
+static const int color_pairs[][2] = {
+	/* color            foreground, background */
+	[CFDISK_CL_WARNING]   = { COLOR_RED, -1 },
+	[CFDISK_CL_FREESPACE] = { COLOR_GREEN, -1 },
+	[CFDISK_CL_INFO]      = { COLOR_BLUE, -1 }
+};
+
+struct cfdisk;
+
+static struct cfdisk_menuitem *menu_get_menuitem(struct cfdisk *cf, size_t idx);
+static struct cfdisk_menuitem *menu_get_menuitem_by_key(struct cfdisk *cf, int key, size_t *idx);
+static struct cfdisk_menu *menu_push(struct cfdisk *cf, struct cfdisk_menuitem *item);
+static struct cfdisk_menu *menu_pop(struct cfdisk *cf);
+static void menu_refresh_size(struct cfdisk *cf);
+
+static int ui_end(void);
+static int ui_refresh(struct cfdisk *cf);
+
+static void ui_warnx(const char *fmt, ...)
+			__attribute__((__format__ (__printf__, 1, 2)));
+static void ui_warn(const char *fmt, ...)
+			__attribute__((__format__ (__printf__, 1, 2)));
+static void ui_info(const char *fmt, ...)
+			__attribute__((__format__ (__printf__, 1, 2)));
+
+static void ui_draw_menu(struct cfdisk *cf);
+static int ui_menu_move(struct cfdisk *cf, int key);
+static void ui_menu_resize(struct cfdisk *cf);
+
+static int ui_get_size(struct cfdisk *cf, const char *prompt, uint64_t *res,
+		       uint64_t low, uint64_t up, int *expsize);
+
+static int ui_enabled;
+static volatile sig_atomic_t sig_resize;
+static volatile sig_atomic_t sig_die;
+
+/* ncurses LINES and COLS may be actual variables or *macros*, but we need
+ * something portable and writable */
+static size_t ui_lines;
+static size_t ui_cols;
+
+/* menu item */
+struct cfdisk_menuitem {
+	int		key;		/* keyboard shortcut */
+	const char	*name;		/* item name */
+	const char	*desc;		/* item description (hint) */
+	void		*userdata;
+};
+
+/* menu */
+struct cfdisk_menu {
+	char			*title;	/* optional menu title */
+	struct cfdisk_menuitem	*items;	/* array with menu items */
+	char			*ignore;/* string with keys to ignore */
+	size_t			width;	/* maximal width of the menu item */
+	size_t			nitems;	/* number of the active menu items */
+	size_t			page_sz;/* when menu longer than screen */
+	size_t			idx;	/* the current menu item */
+	int			prefkey;/* preferred menu item  */
+	struct cfdisk_menu	*prev;
+
+	/* @ignore keys generator */
+	int (*ignore_cb)	(struct cfdisk *, char *, size_t);
+
+	unsigned int		vertical : 1;	/* enable vertical mode */
+};
+
+/* main menu */
+static struct cfdisk_menuitem main_menuitems[] = {
+	{ 'b', N_("Bootable"), N_("Toggle bootable flag of the current partition") },
+	{ 'd', N_("Delete"), N_("Delete the current partition") },
+	{ 'r', N_("Resize"), N_("Reduce or enlarge the current partition") },
+	{ 'n', N_("New"), N_("Create new partition from free space") },
+	{ 'q', N_("Quit"), N_("Quit program without writing changes") },
+	{ 't', N_("Type"), N_("Change the partition type") },
+	{ 'h', N_("Help"), N_("Print help screen") },
+	{ 's', N_("Sort"), N_("Fix partitions order") },
+	{ 'W', N_("Write"), N_("Write partition table to disk (this might destroy data)") },
+	{ 'u', N_("Dump"), N_("Dump partition table to sfdisk compatible script file") },
+	{ 0, NULL, NULL }
+};
+
+/* extra partinfo in name:value pairs */
+struct cfdisk_extra {
+	char *name;
+	char *data;
+
+	struct list_head exs;
+};
+
+/* line and extra partinfo list_head */
+struct cfdisk_line {
+	char			*data;		/* line data */
+	struct libscols_table	*extra;		/* extra info ('X') */
+	WINDOW			*w;		/* window with extra info */
+};
+
+/* top level control struct */
+struct cfdisk {
+	struct fdisk_context	*cxt;	/* libfdisk context */
+	struct fdisk_table	*table;	/* partition table */
+	struct fdisk_table	*original_layout; /* original on-disk PT */
+
+	struct cfdisk_menu	*menu;	/* the current menu */
+
+	int	*fields;	/* output columns IDs */
+	size_t	nfields;	/* number of columns IDs */
+
+	char	*linesbuf;	/* table as string */
+	size_t	linesbufsz;	/* size of the tb_buf */
+
+	struct	cfdisk_line	*lines;	/* list of lines */
+
+	size_t	nlines;		/* number of lines */
+	size_t	lines_idx;	/* current line <0..N>, exclude header */
+	size_t  page_sz;
+
+	unsigned int nwrites;	/* fdisk_write_disklabel() counter */
+
+	WINDOW	*act_win;	/* the window currently on the screen */
+
+#ifdef HAVE_LIBMOUNT
+	struct libmnt_table *mtab;
+	struct libmnt_table *fstab;
+	struct libmnt_cache *mntcache;
+#endif
+	unsigned int	wrong_order :1,		/* PT not in right order */
+			zero_start :1,		/* ignore existing partition table */
+			device_is_used : 1,	/* don't use re-read ioctl */
+			show_extra :1;		/* show extra partinfo */
+};
+
+
+/*
+ * let's use include/debug.h stuff for cfdisk too
+ */
+static UL_DEBUG_DEFINE_MASK(cfdisk);
+UL_DEBUG_DEFINE_MASKNAMES(cfdisk) = UL_DEBUG_EMPTY_MASKNAMES;
+
+#define CFDISK_DEBUG_INIT	(1 << 1)
+#define CFDISK_DEBUG_UI		(1 << 2)
+#define CFDISK_DEBUG_MENU	(1 << 3)
+#define CFDISK_DEBUG_MISC	(1 << 4)
+#define CFDISK_DEBUG_TABLE	(1 << 5)
+#define CFDISK_DEBUG_ALL	0xFFFF
+
+#define DBG(m, x)       __UL_DBG(cfdisk, CFDISK_DEBUG_, m, x)
+
+static void cfdisk_init_debug(void)
+{
+	__UL_INIT_DEBUG_FROM_ENV(cfdisk, CFDISK_DEBUG_, 0, CFDISK_DEBUG);
+}
+
+/* Initialize output columns -- we follow libfdisk fields (usually specific
+ * to the label type.
+ */
+static int cols_init(struct cfdisk *cf)
+{
+	assert(cf);
+
+	free(cf->fields);
+	cf->fields = NULL;
+	cf->nfields = 0;
+
+	return fdisk_label_get_fields_ids(NULL, cf->cxt, &cf->fields, &cf->nfields);
+}
+
+static void die_on_signal(void)
+{
+	DBG(MISC, ul_debug("die on signal."));
+	ui_end();
+	exit(EXIT_FAILURE);
+}
+
+static void resize(void)
+{
+	struct winsize ws;
+
+	if (ioctl(fileno(stdout), TIOCGWINSZ, &ws) != -1
+	    && ws.ws_row && ws.ws_col) {
+		ui_lines = ws.ws_row;
+		ui_cols  = ws.ws_col;
+#if HAVE_RESIZETERM
+		resizeterm(ws.ws_row, ws.ws_col);
+#endif
+		clearok(stdscr, TRUE);
+	}
+	touchwin(stdscr);
+
+	DBG(UI, ul_debug("ui: resize refresh ui_cols=%zu, ui_lines=%zu",
+				ui_cols, ui_lines));
+	sig_resize = 0;
+}
+
+/* Reads partition in tree-like order from scols
+ */
+static int partition_from_scols(struct fdisk_table *tb,
+				struct libscols_line *ln)
+{
+	struct fdisk_partition *pa = scols_line_get_userdata(ln);
+
+	fdisk_table_add_partition(tb, pa);
+	fdisk_unref_partition(pa);
+
+	if (scols_line_has_children(ln)) {
+		struct libscols_line *chln;
+		struct libscols_iter *itr = scols_new_iter(SCOLS_ITER_FORWARD);
+
+		if (!itr)
+			return -EINVAL;
+		while (scols_line_next_child(ln, itr, &chln) == 0)
+			partition_from_scols(tb, chln);
+		scols_free_iter(itr);
+	}
+	return 0;
+}
+
+static char *table_to_string(struct cfdisk *cf, struct fdisk_table *tb)
+{
+	struct fdisk_partition *pa;
+	struct fdisk_label *lb;
+	struct fdisk_iter *itr;
+	struct libscols_table *table = NULL;
+	struct libscols_iter *s_itr = NULL;
+	char *res = NULL;
+	size_t i;
+	int tree = 0;
+	struct libscols_line *ln, *ln_cont = NULL;
+
+	DBG(TABLE, ul_debug("convert to string"));
+
+	assert(cf);
+	assert(cf->cxt);
+	assert(cf->fields);
+	assert(tb);
+
+	lb = fdisk_get_label(cf->cxt, NULL);
+	assert(lb);
+
+	itr = fdisk_new_iter(FDISK_ITER_FORWARD);
+	if (!itr)
+		goto done;
+
+	/* get container (e.g. extended partition) */
+	while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
+		if (fdisk_partition_is_nested(pa)) {
+			DBG(TABLE, ul_debug("nested detected, using tree"));
+			tree = SCOLS_FL_TREE;
+			break;
+		}
+	}
+
+	table = scols_new_table();
+	if (!table)
+		goto done;
+	scols_table_enable_maxout(table, 1);
+	scols_table_enable_nowrap(table, 1);
+
+#if !defined(HAVE_LIBNCURSESW) || !defined(HAVE_WIDECHAR)
+	scols_table_enable_ascii(table, 1);
+#endif
+
+	/* headers */
+	for (i = 0; i < cf->nfields; i++) {
+		int fl = 0;
+		const struct fdisk_field *field =
+				fdisk_label_get_field(lb, cf->fields[i]);
+		if (!field)
+			continue;
+
+		if (fdisk_field_is_number(field))
+			fl |= SCOLS_FL_RIGHT;
+		if (fdisk_field_get_id(field) == FDISK_FIELD_TYPE)
+			fl |= SCOLS_FL_TRUNC;
+		if (tree && fdisk_field_get_id(field) == FDISK_FIELD_DEVICE)
+			fl |= SCOLS_FL_TREE;
+
+		if (!scols_table_new_column(table,
+				_(fdisk_field_get_name(field)),
+				fdisk_field_get_width(field), fl))
+			goto done;
+	}
+
+	/* data */
+	fdisk_reset_iter(itr, FDISK_ITER_FORWARD);
+
+	while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
+		struct libscols_line *parent = fdisk_partition_is_nested(pa) ? ln_cont : NULL;
+
+		ln = scols_table_new_line(table, parent);
+		if (!ln)
+			goto done;
+		for (i = 0; i < cf->nfields; i++) {
+			char *cdata = NULL;
+
+			if (fdisk_partition_to_string(pa, cf->cxt,
+					cf->fields[i], &cdata))
+				continue;
+			scols_line_refer_data(ln, i, cdata);
+		}
+		if (tree && fdisk_partition_is_container(pa))
+			ln_cont = ln;
+
+		scols_line_set_userdata(ln, (void *) pa);
+		fdisk_ref_partition(pa);
+	}
+
+	if (scols_table_is_empty(table))
+		goto done;
+
+	scols_table_reduce_termwidth(table, ARROW_CURSOR_WIDTH);
+	scols_print_table_to_string(table, &res);
+
+	/* scols_* code might reorder lines, let's reorder @tb according to the
+	 * final output (it's no problem because partitions are addressed by
+	 * parno stored within struct fdisk_partition)  */
+
+	/* remove all */
+	fdisk_reset_table(tb);
+
+	s_itr = scols_new_iter(SCOLS_ITER_FORWARD);
+	if (!s_itr)
+		goto done;
+
+	/* add all in the right order (don't forget the output is tree) */
+	while (scols_table_next_line(table, s_itr, &ln) == 0) {
+		if (scols_line_get_parent(ln))
+			continue;
+		if (partition_from_scols(tb, ln))
+			break;
+	}
+done:
+	scols_unref_table(table);
+	scols_free_iter(s_itr);
+	fdisk_free_iter(itr);
+
+	return res;
+}
+
+static void cfdisk_free_lines(struct cfdisk *cf)
+{
+	size_t i = 0;
+	while(i < cf->nlines) {
+		scols_unref_table(cf->lines[i].extra);
+
+		DBG(UI, ul_debug("delete window: %p",
+				cf->lines[i].w));
+
+		if (cf->lines[i].w)
+			delwin(cf->lines[i].w);
+		cf->lines[i].w = NULL;
+		++i;
+	}
+	cf->act_win = NULL;
+	free(cf->lines);
+	cf->lines = NULL;
+}
+/*
+ * Read data about partitions from libfdisk and prepare output lines.
+ */
+static int lines_refresh(struct cfdisk *cf)
+{
+	int rc;
+	char *p;
+	size_t i;
+
+	assert(cf);
+
+	DBG(TABLE, ul_debug("refreshing buffer"));
+
+	free(cf->linesbuf);
+	cfdisk_free_lines(cf);
+	cf->linesbuf = NULL;
+	cf->linesbufsz = 0;
+	cf->lines = NULL;
+	cf->nlines = 0;
+
+	fdisk_unref_table(cf->table);
+	cf->table = NULL;
+
+	/* read partitions and free spaces into cf->table */
+	rc = fdisk_get_partitions(cf->cxt, &cf->table);
+	if (!rc)
+		rc = fdisk_get_freespaces(cf->cxt, &cf->table);
+	if (rc)
+		return rc;
+
+	cf->linesbuf = table_to_string(cf, cf->table);
+	if (!cf->linesbuf)
+		return -ENOMEM;
+
+	cf->linesbufsz = strlen(cf->linesbuf);
+	cf->nlines = fdisk_table_get_nents(cf->table) + 1;	/* 1 for header line */
+	cf->page_sz = 0;
+	cf->wrong_order = fdisk_table_wrong_order(cf->table) ? 1 : 0;
+
+	if (MENU_START_LINE - TABLE_START_LINE < cf->nlines)
+		cf->page_sz = MENU_START_LINE - TABLE_START_LINE - 1;
+
+	cf->lines = xcalloc(cf->nlines, sizeof(struct cfdisk_line));
+
+	for (p = cf->linesbuf, i = 0; p && i < cf->nlines; i++) {
+		cf->lines[i].data = p;
+		p = strchr(p, '\n');
+		if (p) {
+			*p = '\0';
+			p++;
+		}
+		cf->lines[i].extra = scols_new_table();
+		scols_table_enable_noheadings(cf->lines[i].extra, 1);
+		scols_table_new_column(cf->lines[i].extra, NULL, 0, SCOLS_FL_RIGHT);
+		scols_table_new_column(cf->lines[i].extra, NULL, 0, SCOLS_FL_TRUNC);
+	}
+
+	return 0;
+}
+
+static struct fdisk_partition *get_current_partition(struct cfdisk *cf)
+{
+	assert(cf);
+	assert(cf->table);
+
+	return fdisk_table_get_partition(cf->table, cf->lines_idx);
+}
+
+static int is_freespace(struct cfdisk *cf, size_t i)
+{
+	struct fdisk_partition *pa;
+
+	assert(cf);
+	assert(cf->table);
+
+	pa = fdisk_table_get_partition(cf->table, i);
+	return fdisk_partition_is_freespace(pa);
+}
+
+/* converts libfdisk FDISK_ASKTYPE_MENU to cfdisk menu and returns user's
+ * response back to libfdisk
+ */
+static int ask_menu(struct fdisk_ask *ask, struct cfdisk *cf)
+{
+	struct cfdisk_menuitem *d, *cm;
+	int key;
+	size_t i = 0, nitems;
+	const char *name, *desc;
+
+	assert(ask);
+	assert(cf);
+
+	/* create cfdisk menu according to libfdisk ask-menu, note that the
+	 * last cm[] item has to be empty -- so nitems + 1 */
+	nitems = fdisk_ask_menu_get_nitems(ask);
+	cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
+
+	for (i = 0; i < nitems; i++) {
+		if (fdisk_ask_menu_get_item(ask, i, &key, &name, &desc))
+			break;
+		cm[i].key = key;
+		cm[i].desc = desc;
+		cm[i].name = name;
+	}
+
+	/* make the new menu active */
+	menu_push(cf, cm);
+	ui_draw_menu(cf);
+	refresh();
+
+	/* wait for keys */
+	while (!sig_die) {
+		key = getch();
+
+		if (sig_die)
+			break;
+		if (sig_resize)
+			ui_menu_resize(cf);
+		if (ui_menu_move(cf, key) == 0)
+			continue;
+
+		switch (key) {
+		case KEY_ENTER:
+		case '\n':
+		case '\r':
+			d = menu_get_menuitem(cf, cf->menu->idx);
+			if (d)
+				fdisk_ask_menu_set_result(ask, d->key);
+			menu_pop(cf);
+			free(cm);
+			return 0;
+		}
+	}
+
+	if (sig_die)
+		die_on_signal();
+
+	menu_pop(cf);
+	free(cm);
+	return -1;
+}
+
+/* libfdisk callback
+ */
+static int ask_callback(struct fdisk_context *cxt __attribute__((__unused__)),
+			struct fdisk_ask *ask,
+			void *data __attribute__((__unused__)))
+{
+	int rc = 0;
+
+	assert(ask);
+
+	switch(fdisk_ask_get_type(ask)) {
+	case FDISK_ASKTYPE_INFO:
+		ui_info("%s", fdisk_ask_print_get_mesg(ask));
+		break;
+	case FDISK_ASKTYPE_WARNX:
+		ui_warnx("%s", fdisk_ask_print_get_mesg(ask));
+		break;
+	case FDISK_ASKTYPE_WARN:
+		ui_warn("%s", fdisk_ask_print_get_mesg(ask));
+		break;
+	case FDISK_ASKTYPE_MENU:
+		ask_menu(ask, (struct cfdisk *) data);
+		break;
+	default:
+		ui_warnx(_("internal error: unsupported dialog type %d"),
+			fdisk_ask_get_type(ask));
+		return -EINVAL;
+	}
+	return rc;
+}
+
+static int ui_end(void)
+{
+	if (!ui_enabled)
+		return -EINVAL;
+
+#if defined(HAVE_SLCURSES_H) || defined(HAVE_SLANG_SLCURSES_H)
+	SLsmg_gotorc(ui_lines - 1, 0);
+	SLsmg_refresh();
+#else
+	mvcur(0, ui_cols - 1, ui_lines-1, 0);
+#endif
+	curs_set(1);
+	nl();
+	endwin();
+	printf("\n");
+	ui_enabled = 0;
+	return 0;
+}
+
+static void __attribute__((__format__ (__printf__, 3, 0)))
+	ui_vprint_center(size_t line, int attrs, const char *fmt, va_list ap)
+{
+	size_t width;
+	char *buf = NULL;
+
+	move(line, 0);
+	clrtoeol();
+
+	xvasprintf(&buf, fmt, ap);
+
+	width = mbs_safe_width(buf);
+	if (width > (size_t) ui_cols) {
+		char *p = strrchr(buf + ui_cols, ' ');
+		if (!p)
+			p = buf + ui_cols;
+		*p = '\0';
+		if (line + 1 >= ui_lines)
+			line--;
+		attron(attrs);
+		mvaddstr(line, 0, buf);
+		mvaddstr(line + 1, 0, p+1);
+		attroff(attrs);
+	} else {
+		attron(attrs);
+		mvaddstr(line, (ui_cols - width) / 2, buf);
+		attroff(attrs);
+	}
+	free(buf);
+}
+
+static void __attribute__((__format__ (__printf__, 2, 3)))
+	ui_center(size_t line, const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	ui_vprint_center(line, 0, fmt, ap);
+	va_end(ap);
+}
+
+static void __attribute__((__format__ (__printf__, 1, 2)))
+	ui_warnx(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	if (ui_enabled)
+		ui_vprint_center(WARN_LINE,
+			colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING) : 0,
+			fmt, ap);
+	else {
+		vfprintf(stderr, fmt, ap);
+		fputc('\n', stderr);
+	}
+	va_end(ap);
+}
+
+static void __attribute__((__format__ (__printf__, 1, 2)))
+	ui_warn(const char *fmt, ...)
+{
+	char *fmt_m;
+	va_list ap;
+
+	xasprintf(&fmt_m, "%s: %m", fmt);
+
+	va_start(ap, fmt);
+	if (ui_enabled)
+		ui_vprint_center(WARN_LINE,
+			colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING) : 0,
+			fmt_m, ap);
+	else {
+		vfprintf(stderr, fmt_m, ap);
+		fputc('\n', stderr);
+	}
+	va_end(ap);
+	free(fmt_m);
+}
+
+static void ui_clean_warn(void)
+{
+	move(WARN_LINE, 0);
+	clrtoeol();
+}
+
+static int __attribute__((__noreturn__))
+	   __attribute__((__format__ (__printf__, 2, 3)))
+	ui_err(int rc, const char *fmt, ...)
+{
+	va_list ap;
+	ui_end();
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", program_invocation_short_name);
+	vfprintf(stderr, fmt, ap);
+	fprintf(stderr, ": %s\n", strerror(errno));
+	va_end(ap);
+
+	exit(rc);
+}
+
+static int __attribute__((__noreturn__))
+	   __attribute__((__format__ (__printf__, 2, 3)))
+	ui_errx(int rc, const char *fmt, ...)
+		{
+	va_list ap;
+	ui_end();
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", program_invocation_short_name);
+	vfprintf(stderr, fmt, ap);
+	fputc('\n', stderr);
+	va_end(ap);
+
+	exit(rc);
+}
+
+static void __attribute__((__format__ (__printf__, 1, 2)))
+	ui_info(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	if (ui_enabled)
+		ui_vprint_center(INFO_LINE,
+				colors_wanted() ? COLOR_PAIR(CFDISK_CL_INFO) : 0,
+				fmt, ap);
+	else {
+		vfprintf(stdout, fmt, ap);
+		fputc('\n', stdout);
+	}
+	va_end(ap);
+}
+
+static void ui_clean_info(void)
+{
+	move(INFO_LINE, 0);
+	clrtoeol();
+}
+
+static void __attribute__((__format__ (__printf__, 1, 2)))
+	ui_hint(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	if (ui_enabled)
+		ui_vprint_center(HINT_LINE, A_BOLD, fmt, ap);
+	else {
+		vfprintf(stdout, fmt, ap);
+		fputc('\n', stdout);
+	}
+	va_end(ap);
+}
+
+static void ui_clean_hint(void)
+{
+	move(HINT_LINE, 0);
+	clrtoeol();
+}
+
+
+static void sig_handler_die(int dummy __attribute__((__unused__)))
+{
+	sig_die = 1;
+}
+
+static void sig_handler_resize(int dummy __attribute__((__unused__)))
+{
+	sig_resize = 1;
+}
+
+static void menu_refresh_size(struct cfdisk *cf)
+{
+	if (cf->menu && cf->menu->nitems)
+		cf->menu->page_sz = (cf->menu->nitems / (ui_lines - 4)) ? ui_lines - 4 : 0;
+}
+
+static void menu_update_ignore(struct cfdisk *cf)
+{
+	char ignore[128] = { 0 };
+	int i = 0;
+	struct cfdisk_menu *m;
+	struct cfdisk_menuitem *d, *org = NULL;
+	size_t idx;
+
+	assert(cf);
+	assert(cf->menu);
+	assert(cf->menu->ignore_cb);
+
+	m = cf->menu;
+	DBG(MENU, ul_debug("update menu ignored keys"));
+
+	i = m->ignore_cb(cf, ignore, sizeof(ignore));
+	ignore[i] = '\0';
+
+	/* return if no change */
+	if ((!m->ignore && !*ignore)
+	    || (m->ignore && *ignore && strcmp(m->ignore, ignore) == 0)) {
+		    return;
+	}
+
+	if (!m->prefkey)
+		org = menu_get_menuitem(cf, m->idx);
+
+	free(m->ignore);
+	m->ignore = xstrdup(ignore);
+	m->nitems = 0;
+
+	for (d = m->items; d->name; d++) {
+		if (m->ignore && strchr(m->ignore, d->key))
+			continue;
+		m->nitems++;
+	}
+
+	DBG(MENU, ul_debug("update menu preferred keys"));
+
+	/* refresh menu index to be at the same menuitem or go to the first */
+	if (org && menu_get_menuitem_by_key(cf, org->key, &idx))
+		m->idx = idx;
+	else if (m->prefkey && menu_get_menuitem_by_key(cf, m->prefkey, &idx))
+		m->idx = idx;
+	else
+		m->idx = 0;
+
+	menu_refresh_size(cf);
+}
+
+static struct cfdisk_menu *menu_push(
+			struct cfdisk *cf,
+			struct cfdisk_menuitem *items)
+{
+	struct cfdisk_menu *m = xcalloc(1, sizeof(*m));
+	struct cfdisk_menuitem *d;
+
+	assert(cf);
+
+	DBG(MENU, ul_debug("new menu"));
+
+	m->prev = cf->menu;
+	m->items = items;
+
+	for (d = m->items; d->name; d++) {
+		const char *name = _(d->name);
+		size_t len = mbs_safe_width(name);
+		if (len > m->width)
+			m->width = len;
+		m->nitems++;
+	}
+
+	cf->menu = m;
+
+	menu_refresh_size(cf);
+	return m;
+}
+
+static struct cfdisk_menu *menu_pop(struct cfdisk *cf)
+{
+	struct cfdisk_menu *m = NULL;
+
+	assert(cf);
+
+	DBG(MENU, ul_debug("pop menu"));
+
+	if (cf->menu) {
+		m = cf->menu->prev;
+		free(cf->menu->ignore);
+		free(cf->menu->title);
+		free(cf->menu);
+	}
+	cf->menu = m;
+	return cf->menu;
+}
+
+static void menu_set_title(struct cfdisk_menu *m, const char *title)
+{
+	char *str = NULL;
+
+	if (title) {
+		size_t len =  mbs_safe_width(title);
+		if (len + MENU_TITLE_PADDING > m->width)
+			m->width = len + MENU_TITLE_PADDING;
+		str = xstrdup(title);
+	}
+	m->title = str;
+}
+
+
+static int ui_init(struct cfdisk *cf __attribute__((__unused__)))
+{
+	struct sigaction sa;
+
+	DBG(UI, ul_debug("init"));
+
+	/* setup SIGCHLD handler */
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = 0;
+	sa.sa_handler = sig_handler_die;
+	sigaction(SIGINT, &sa, NULL);
+	sigaction(SIGTERM, &sa, NULL);
+
+	sa.sa_handler = sig_handler_resize;
+	sigaction(SIGWINCH, &sa, NULL);
+
+	ui_enabled = 1;
+	initscr();
+
+#ifdef HAVE_USE_DEFAULT_COLORS
+	if (colors_wanted() && has_colors()) {
+		size_t i;
+
+		start_color();
+		use_default_colors();
+		for (i = 1; i < ARRAY_SIZE(color_pairs); i++)		/* yeah, start from 1! */
+			init_pair(i, color_pairs[i][0], color_pairs[i][1]);
+	}
+#else
+	colors_off();
+#endif
+
+	cbreak();
+	noecho();
+	nonl();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+
+	return 0;
+}
+
+/* "[ string ]" */
+#define MENU_H_ITEMWIDTH(m)	(  MENU_H_PRESTR_SZ \
+				 + MENU_H_SPADDING \
+				 + (m)->width \
+				 + MENU_H_SPADDING \
+				 + MENU_H_POSTSTR_SZ)
+
+#define MENU_V_ITEMWIDTH(m)	(MENU_V_SPADDING + (m)->width + MENU_V_SPADDING)
+
+
+static size_t menuitem_get_line(struct cfdisk *cf, size_t idx)
+{
+	struct cfdisk_menu *m = cf->menu;
+
+	if (m->vertical) {
+		if (!m->page_sz)				/* small menu */
+			return (ui_lines - (cf->menu->nitems + 1)) / 2 + idx;
+		return (idx % m->page_sz) + 1;
+	}
+
+	{
+		size_t len = MENU_H_ITEMWIDTH(m) + MENU_H_BETWEEN; /** item width */
+		size_t items = ui_cols / len;			/* items per line */
+
+		if (items == 0)
+			return 0;
+		return MENU_START_LINE + ((idx / items));
+	}
+}
+
+static int menuitem_get_column(struct cfdisk *cf, size_t idx)
+{
+	if (cf->menu->vertical) {
+		size_t nc = MENU_V_ITEMWIDTH(cf->menu);
+		if ((size_t) ui_cols <= nc)
+			return 0;
+		return (ui_cols - nc) / 2;
+	}
+
+	{
+		size_t len = MENU_H_ITEMWIDTH(cf->menu) + MENU_H_BETWEEN; /* item width */
+		size_t items = ui_cols / len;				/* items per line */
+		size_t extra = items < cf->menu->nitems ?		/* extra space on line */
+				ui_cols % len :				/* - multi-line menu */
+				ui_cols - (cf->menu->nitems * len);	/* - one line menu */
+
+		if (items == 0)
+			return 0;					/* hmm... no space */
+
+		extra += MENU_H_BETWEEN;	/* add padding after last item to extra */
+
+		if (idx < items)
+			return (idx * len) + (extra / 2);
+		return ((idx % items) * len) + (extra / 2);
+	}
+}
+
+static int menuitem_on_page(struct cfdisk *cf, size_t idx)
+{
+	struct cfdisk_menu *m = cf->menu;
+
+	if (m->page_sz == 0 ||
+	    m->idx / m->page_sz == idx / m->page_sz)
+		return 1;
+	return 0;
+}
+
+static struct cfdisk_menuitem *menu_get_menuitem(struct cfdisk *cf, size_t idx)
+{
+	struct cfdisk_menuitem *d;
+	size_t i;
+
+	for (i = 0, d = cf->menu->items; d->name; d++) {
+		if (cf->menu->ignore && strchr(cf->menu->ignore, d->key))
+			continue;
+		if (i++ == idx)
+			return d;
+	}
+
+	return NULL;
+}
+
+static struct cfdisk_menuitem *menu_get_menuitem_by_key(struct cfdisk *cf,
+							int key, size_t *idx)
+{
+	struct cfdisk_menuitem *d;
+
+	for (*idx = 0, d = cf->menu->items; d->name; d++) {
+		if (cf->menu->ignore && strchr(cf->menu->ignore, d->key))
+			continue;
+		if (key == d->key)
+			return d;
+		(*idx)++;
+	}
+
+	return NULL;
+}
+
+static void ui_draw_menuitem(struct cfdisk *cf,
+			     struct cfdisk_menuitem *d,
+			     size_t idx)
+{
+	char *buf, *ptr;
+	const char *name;
+	size_t width;
+	const size_t buf_sz = 80 * MB_CUR_MAX;
+	int ln, cl, vert = cf->menu->vertical;
+
+	if (!menuitem_on_page(cf, idx))
+		return;		/* no visible item */
+	ln = menuitem_get_line(cf, idx);
+	cl = menuitem_get_column(cf, idx);
+
+	ptr = buf = xmalloc(buf_sz);
+	/* string width */
+	if (vert) {
+		width = cf->menu->width + MENU_V_SPADDING;
+		memset(ptr, ' ', MENU_V_SPADDING);
+		ptr += MENU_V_SPADDING;
+	} else
+		width = MENU_H_SPADDING + cf->menu->width + MENU_H_SPADDING;
+
+	name = _(d->name);
+	mbsalign(name, ptr, buf_sz, &width,
+			vert ? MBS_ALIGN_LEFT : MBS_ALIGN_CENTER,
+			0);
+
+	DBG(MENU, ul_debug("menuitem: cl=%d, ln=%d, item='%s'",
+			cl, ln, buf));
+
+	if (vert) {
+		mvaddch(ln, cl - 1, ACS_VLINE);
+		mvaddch(ln, cl + MENU_V_ITEMWIDTH(cf->menu), ACS_VLINE);
+	}
+
+	if (cf->menu->idx == idx)
+		standout();
+
+	if (vert)
+		mvprintw(ln, cl, "%s", buf);
+	else
+		mvprintw(ln, cl, "%s%s%s", MENU_H_PRESTR, buf, MENU_H_POSTSTR);
+	free(buf);
+
+	if (cf->menu->idx == idx) {
+		standend();
+		if (d->desc)
+			ui_hint("%s", _(d->desc));
+	}
+}
+
+static void ui_clean_menu(struct cfdisk *cf)
+{
+	size_t i;
+	size_t lastline;
+	struct cfdisk_menu *m = cf->menu;
+	size_t ln = menuitem_get_line(cf, 0);
+
+	if (m->vertical)
+		lastline = ln + (m->page_sz ? m->page_sz : m->nitems);
+	else
+		lastline = menuitem_get_line(cf, m->nitems);
+
+	for (i = ln; i <= lastline; i++) {
+		move(i, 0);
+		clrtoeol();
+		DBG(MENU, ul_debug("clean_menu: line %zu", i));
+	}
+	if (m->vertical) {
+		move(ln - 1, 0);
+		clrtoeol();
+	}
+	ui_clean_hint();
+}
+
+static void ui_draw_menu(struct cfdisk *cf)
+{
+	struct cfdisk_menuitem *d;
+	struct cfdisk_menu *m;
+	size_t i = 0;
+	size_t ln = menuitem_get_line(cf, 0);
+	size_t nlines;
+
+	assert(cf);
+	assert(cf->menu);
+
+	DBG(MENU, ul_debug("draw start"));
+
+	ui_clean_menu(cf);
+	m = cf->menu;
+
+	if (m->vertical)
+		nlines = m->page_sz ? m->page_sz : m->nitems;
+	else
+		nlines = menuitem_get_line(cf, m->nitems);
+
+	if (m->ignore_cb)
+		menu_update_ignore(cf);
+	i = 0;
+	while ((d = menu_get_menuitem(cf, i)))
+		ui_draw_menuitem(cf, d, i++);
+
+	if (m->vertical) {
+		size_t cl = menuitem_get_column(cf, 0);
+		size_t curpg = m->page_sz ? m->idx / m->page_sz : 0;
+
+		/* corners and horizontal lines */
+		mvaddch(ln - 1, cl - 1, ACS_ULCORNER);
+		mvaddch(ln + nlines, cl - 1, ACS_LLCORNER);
+
+		for (i = 0; i < MENU_V_ITEMWIDTH(m); i++) {
+			mvaddch(ln - 1, cl + i, ACS_HLINE);
+			mvaddch(ln + nlines, cl + i, ACS_HLINE);
+		}
+
+		mvaddch(ln - 1, cl + i, ACS_URCORNER);
+		mvaddch(ln + nlines, cl + i, ACS_LRCORNER);
+
+		/* draw also lines around empty lines on last page */
+		if (m->page_sz &&
+		    m->nitems / m->page_sz == m->idx / m->page_sz) {
+			for (i = m->nitems % m->page_sz + 1; i <= m->page_sz; i++) {
+				mvaddch(i, cl - 1, ACS_VLINE);
+				mvaddch(i, cl + MENU_V_ITEMWIDTH(m), ACS_VLINE);
+			}
+		}
+		if (m->title) {
+			attron(A_BOLD);
+			mvprintw(ln - 1, cl, " %s ", m->title);
+			attroff(A_BOLD);
+		}
+		if (curpg != 0)
+			mvaddch(ln - 1, cl + MENU_V_ITEMWIDTH(m) - 2, ACS_UARROW);
+		if (m->page_sz && curpg < m->nitems / m->page_sz)
+			mvaddch(ln + nlines, cl + MENU_V_ITEMWIDTH(m) - 2, ACS_DARROW);
+	}
+
+	DBG(MENU, ul_debug("draw end."));
+}
+
+inline static int extra_insert_pair(struct cfdisk_line *l, const char *name, const char *data)
+{
+	struct libscols_line *lsl;
+	int rc;
+
+	assert(l);
+	assert(l->extra);
+
+	if (!data || !*data)
+		return 0;
+
+	lsl = scols_table_new_line(l->extra, NULL);
+	if (!lsl)
+		return -ENOMEM;
+
+	rc = scols_line_set_data(lsl, 0, name);
+	if (!rc)
+		rc = scols_line_set_data(lsl, 1, data);
+
+	return rc;
+}
+
+#ifndef HAVE_LIBMOUNT
+static char *get_mountpoint(	struct cfdisk *cf __attribute__((unused)),
+				const char *tagname __attribute__((unused)),
+				const char *tagdata __attribute__((unused)))
+{
+	return NULL;
+}
+#else
+static char *get_mountpoint(struct cfdisk *cf, const char *tagname, const char *tagdata)
+{
+	struct libmnt_fs *fs = NULL;
+	char *target = NULL;
+	int mounted = 0;
+
+	assert(tagname);
+	assert(tagdata);
+
+	DBG(UI, ul_debug("asking for mountpoint [%s=%s]", tagname, tagdata));
+
+	if (!cf->mntcache)
+		cf->mntcache = mnt_new_cache();
+
+	/* 1st try between mounted filesystems */
+	if (!cf->mtab) {
+		cf->mtab = mnt_new_table();
+		if (cf->mtab) {
+			mnt_table_set_cache(cf->mtab, cf->mntcache);
+			mnt_table_parse_mtab(cf->mtab, NULL);
+		}
+	}
+
+	if (cf->mtab)
+		fs = mnt_table_find_tag(cf->mtab, tagname, tagdata, MNT_ITER_FORWARD);
+
+	/* 2nd try fstab */
+	if (!fs) {
+		if (!cf->fstab) {
+			cf->fstab = mnt_new_table();
+			if (cf->fstab) {
+				mnt_table_set_cache(cf->fstab, cf->mntcache);
+				if (mnt_table_parse_fstab(cf->fstab, NULL) != 0) {
+					mnt_unref_table(cf->fstab);
+					cf->fstab = NULL;
+				}
+			}
+		}
+		if (cf->fstab)
+			fs = mnt_table_find_tag(cf->fstab, tagname, tagdata, MNT_ITER_FORWARD);
+	} else
+		mounted = 1;
+
+	if (fs) {
+		if (mounted)
+			xasprintf(&target, _("%s (mounted)"), mnt_fs_get_target(fs));
+		else
+			target = xstrdup(mnt_fs_get_target(fs));
+	}
+
+	return target;
+}
+#endif /* HAVE_LIBMOUNT */
+
+static inline int iszero(const char *str)
+{
+	const char *p;
+
+	for (p = str; p && *p == '0'; p++);
+
+	return !p || *p == '\0';
+}
+
+static int has_uuid(struct fdisk_table *tb, const char *uuid)
+{
+	struct fdisk_partition *pa;
+	struct fdisk_iter *itr;
+	int rc = 0;
+
+	if (!tb || !uuid || fdisk_table_is_empty(tb))
+		return 0;
+
+	itr = fdisk_new_iter(FDISK_ITER_FORWARD);
+	while (rc == 0 && fdisk_table_next_partition(tb, itr, &pa) == 0) {
+		const char *x = fdisk_partition_get_uuid(pa);
+		if (x)
+			rc = strcmp(x, uuid) == 0;
+	}
+	fdisk_free_iter(itr);
+	return rc;
+}
+
+static void extra_prepare_data(struct cfdisk *cf)
+{
+	struct fdisk_partition *pa = get_current_partition(cf);
+	struct cfdisk_line *l = &cf->lines[cf->lines_idx];
+	char *data = NULL;
+	char *mountpoint = NULL;
+
+	DBG(UI, ul_debug("preparing extra data"));
+
+	/* string data should not equal an empty string */
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_NAME, &data) && data) {
+		extra_insert_pair(l, _("Partition name:"), data);
+		if (!mountpoint)
+			mountpoint = get_mountpoint(cf, "PARTLABEL", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_UUID, &data) && data) {
+		extra_insert_pair(l, _("Partition UUID:"), data);
+
+		/* Search for mountpoint by PARTUUID= means that we need to
+		 * check fstab and convert PARTUUID to the device name. This is
+		 * unnecessary and overkill for newly created partitions. Let's
+		 * check if the UUID already exist in the old layout, otherwise
+		 * ignore it.
+		 */
+		if (!mountpoint && has_uuid(cf->original_layout, data))
+			mountpoint = get_mountpoint(cf, "PARTUUID", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_TYPE, &data) && data) {
+		char *code = NULL, *type = NULL;
+
+		fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_TYPEID, &code);
+		xasprintf(&type, "%s (%s)", data, code);
+
+		extra_insert_pair(l, _("Partition type:"), type);
+		free(data);
+		free(code);
+		free(type);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_ATTR, &data) && data) {
+		extra_insert_pair(l, _("Attributes:"), data);
+		free(data);
+	}
+
+	/* for numeric data, only show non-zero rows */
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_BSIZE, &data) && data) {
+		if (!iszero(data))
+			extra_insert_pair(l, "BSIZE:", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_CPG, &data) && data) {
+		if (!iszero(data))
+			extra_insert_pair(l, "CPG:", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSIZE, &data) && data) {
+		if (!iszero(data))
+			extra_insert_pair(l, "FSIZE:", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSUUID, &data) && data) {
+		extra_insert_pair(l, _("Filesystem UUID:"), data);
+		if (!mountpoint)
+			mountpoint = get_mountpoint(cf, "UUID", data);
+		free(data);
+	}
+
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSLABEL, &data) && data) {
+		extra_insert_pair(l, _("Filesystem LABEL:"), data);
+		if (!mountpoint)
+			mountpoint = get_mountpoint(cf, "LABEL", data);
+		free(data);
+	}
+	if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSTYPE, &data) && data) {
+		extra_insert_pair(l, _("Filesystem:"), data);
+		free(data);
+	}
+
+	if (mountpoint) {
+		extra_insert_pair(l, _("Mountpoint:"), mountpoint);
+		free(mountpoint);
+	}
+}
+
+static int ui_draw_extra(struct cfdisk *cf)
+{
+	WINDOW *win_ex;
+	int wline = 1;
+	struct cfdisk_line *ln = &cf->lines[cf->lines_idx];
+	char *tbstr = NULL, *end;
+	int win_ex_start_line, win_height, tblen;
+	int ndatalines;
+
+	if (!cf->show_extra)
+		return 0;
+
+	DBG(UI, ul_debug("draw extra"));
+
+	assert(ln->extra);
+
+	if (cf->act_win) {
+		wclear(cf->act_win);
+		touchwin(stdscr);
+	}
+
+	if (scols_table_is_empty(ln->extra)) {
+		extra_prepare_data(cf);
+		if (scols_table_is_empty(ln->extra))
+			return 0;
+	}
+
+	ndatalines = fdisk_table_get_nents(cf->table) + 1;
+
+	/* nents + header + one free line */
+	win_ex_start_line = TABLE_START_LINE + ndatalines;
+	win_height = MENU_START_LINE - win_ex_start_line;
+	tblen = scols_table_get_nlines(ln->extra);
+
+	/* we can't get a single line of data under the partlist*/
+	if (win_height < 3)
+		return 1;
+
+	/* number of data lines + 2 for top/bottom lines */
+	win_height = win_height < tblen + 2 ? win_height : tblen + 2;
+
+	if ((size_t) win_ex_start_line + win_height + 1 < MENU_START_LINE)
+		win_ex_start_line = MENU_START_LINE - win_height;
+
+	win_ex = subwin(stdscr, win_height, ui_cols - 2, win_ex_start_line, 1);
+
+	scols_table_reduce_termwidth(ln->extra, 4);
+	scols_print_table_to_string(ln->extra, &tbstr);
+
+	end = tbstr;
+	while ((end = strchr(end, '\n')))
+		*end++ = '\0';
+
+	box(win_ex, 0, 0);
+
+	end = tbstr;
+	while (--win_height > 1) {
+		mvwaddstr(win_ex, wline++, 1 /* window column*/, tbstr);
+		tbstr += strlen(tbstr) + 1;
+	}
+	free(end);
+
+	if (ln->w)
+		delwin(ln->w);
+
+	DBG(UI, ul_debug("draw window: %p", win_ex));
+	touchwin(stdscr);
+	wrefresh(win_ex);
+
+	cf->act_win = ln->w = win_ex;
+	return 0;
+}
+
+static void ui_menu_goto(struct cfdisk *cf, int where)
+{
+	struct cfdisk_menuitem *d;
+	size_t old;
+
+	/* stop and begin/end for vertical menus */
+	if (cf->menu->vertical) {
+		if (where < 0)
+			where = 0;
+		else if (where > (int) cf->menu->nitems - 1)
+			where = cf->menu->nitems - 1;
+	} else {
+		/* continue from begin/end */
+		if (where < 0)
+			where = cf->menu->nitems - 1;
+		else if ((size_t) where > cf->menu->nitems - 1)
+			where = 0;
+	}
+	if ((size_t) where == cf->menu->idx)
+		return;
+
+	ui_clean_info();
+
+	old = cf->menu->idx;
+	cf->menu->idx = where;
+
+	if (!menuitem_on_page(cf, old)) {
+		ui_draw_menu(cf);
+		return;
+	}
+
+	d = menu_get_menuitem(cf, old);
+	ui_draw_menuitem(cf, d, old);
+
+	d = menu_get_menuitem(cf, where);
+	ui_draw_menuitem(cf, d, where);
+
+}
+
+static int ui_menu_move(struct cfdisk *cf, int key)
+{
+	struct cfdisk_menu *m;
+
+	assert(cf);
+	assert(cf->menu);
+
+	if (key == (int) ERR)
+		return 0;	/* ignore errors */
+
+	m = cf->menu;
+
+	DBG(MENU, ul_debug("menu move key >%c<.", key));
+
+	if (m->vertical)
+	{
+		switch (key) {
+		case KEY_DOWN:
+		case '\016':	/* ^N */
+		case 'j':	/* Vi-like alternative */
+			ui_menu_goto(cf, m->idx + 1);
+			return 0;
+		case KEY_UP:
+		case '\020':	/* ^P */
+		case 'k':	/* Vi-like alternative */
+			ui_menu_goto(cf, (int) m->idx - 1);
+			return 0;
+		case KEY_PPAGE:
+			if (m->page_sz) {
+				ui_menu_goto(cf, (int) m->idx - m->page_sz);
+				return 0;
+			}
+			/* fallthrough */
+		case KEY_HOME:
+			ui_menu_goto(cf, 0);
+			return 0;
+		case KEY_NPAGE:
+			if (m->page_sz) {
+				ui_menu_goto(cf, m->idx + m->page_sz);
+				return 0;
+			}
+			/* fallthrough */
+		case KEY_END:
+			ui_menu_goto(cf, m->nitems);
+			return 0;
+		}
+	} else {
+		switch (key) {
+		case KEY_RIGHT:
+		case '\t':
+			ui_menu_goto(cf, m->idx + 1);
+			return 0;
+		case KEY_LEFT:
+#ifdef KEY_BTAB
+		case KEY_BTAB:
+#endif
+			ui_menu_goto(cf, (int) m->idx - 1);
+			return 0;
+		}
+	}
+
+	if (key == '\014') {		/* ^L refresh */
+		ui_menu_resize(cf);
+		return 0;
+	}
+
+	DBG(MENU, ul_debug(" no menu move key"));
+	return 1;
+}
+
+/* but don't call me from ui_run(), this is for pop-up menus only */
+static void ui_menu_resize(struct cfdisk *cf)
+{
+	DBG(MENU, ul_debug("menu resize/refresh"));
+	resize();
+	ui_clean_menu(cf);
+	menu_refresh_size(cf);
+	ui_draw_menu(cf);
+	refresh();
+}
+
+static int partition_on_page(struct cfdisk *cf, size_t i)
+{
+	if (cf->page_sz == 0 ||
+	    cf->lines_idx / cf->page_sz == i / cf->page_sz)
+		return 1;
+	return 0;
+}
+
+static void ui_draw_partition(struct cfdisk *cf, size_t i)
+{
+	int ln = TABLE_START_LINE + 1 + i;	/* skip table header */
+	int cl = ARROW_CURSOR_WIDTH;		/* we need extra space for cursor */
+	int cur = cf->lines_idx == i;
+	size_t curpg = 0;
+
+	if (cf->page_sz) {
+		if (!partition_on_page(cf, i))
+			return;
+		ln = TABLE_START_LINE + (i % cf->page_sz) + 1;
+		curpg = cf->lines_idx / cf->page_sz;
+	}
+
+	DBG(UI, ul_debug(
+			"draw partition %zu [page_sz=%zu, "
+			"line=%d, idx=%zu]",
+			i, cf->page_sz, ln, cf->lines_idx));
+
+	if (cur) {
+		attron(A_REVERSE);
+		mvaddstr(ln, 0, ARROW_CURSOR_STRING);
+		mvaddstr(ln, cl, cf->lines[i + 1].data);
+		attroff(A_REVERSE);
+	} else {
+		int at = 0;
+
+		if (colors_wanted() && is_freespace(cf, i)) {
+			attron(COLOR_PAIR(CFDISK_CL_FREESPACE));
+			at = 1;
+		}
+		mvaddstr(ln, 0, ARROW_CURSOR_DUMMY);
+		mvaddstr(ln, cl, cf->lines[i + 1].data);
+		if (at)
+			attroff(COLOR_PAIR(CFDISK_CL_FREESPACE));
+	}
+
+	if ((size_t) ln == MENU_START_LINE - 1 &&
+	    cf->page_sz && curpg < cf->nlines / cf->page_sz) {
+		if (cur)
+			attron(A_REVERSE);
+		mvaddch(ln, ui_cols - 1, ACS_DARROW);
+		mvaddch(ln, 0, ACS_DARROW);
+		if (cur)
+			attroff(A_REVERSE);
+	}
+
+}
+
+static int ui_draw_table(struct cfdisk *cf)
+{
+	int cl = ARROW_CURSOR_WIDTH;
+	size_t i, nparts = fdisk_table_get_nents(cf->table);
+	size_t curpg = cf->page_sz ? cf->lines_idx / cf->page_sz : 0;
+
+	DBG(UI, ul_debug("draw table"));
+
+	for (i = TABLE_START_LINE; i <= TABLE_START_LINE + cf->page_sz; i++) {
+		move(i, 0);
+		clrtoeol();
+	}
+
+	if (nparts == 0 || (size_t) cf->lines_idx > nparts - 1)
+		cf->lines_idx = nparts ? nparts - 1 : 0;
+
+	/* print header */
+	attron(A_BOLD);
+	mvaddstr(TABLE_START_LINE, cl, cf->lines[0].data);
+	attroff(A_BOLD);
+
+	/* print partitions */
+	for (i = 0; i < nparts; i++)
+		ui_draw_partition(cf, i);
+
+	if (curpg != 0) {
+		mvaddch(TABLE_START_LINE, ui_cols - 1, ACS_UARROW);
+		mvaddch(TABLE_START_LINE, 0, ACS_UARROW);
+	}
+	if (cf->page_sz && curpg < cf->nlines / cf->page_sz) {
+		mvaddch(MENU_START_LINE - 1, ui_cols - 1, ACS_DARROW);
+		mvaddch(MENU_START_LINE - 1, 0, ACS_DARROW);
+	}
+	return 0;
+}
+
+static int ui_table_goto(struct cfdisk *cf, int where)
+{
+	size_t old;
+	size_t nparts = fdisk_table_get_nents(cf->table);
+
+	DBG(UI, ul_debug("goto table %d", where));
+
+	if (where < 0)
+		where = 0;
+	else if ((size_t) where > nparts - 1)
+		where = nparts - 1;
+
+	if ((size_t) where == cf->lines_idx)
+		return 0;
+
+	old = cf->lines_idx;
+	cf->lines_idx = where;
+
+	if (!partition_on_page(cf, old) ||!partition_on_page(cf, where))
+		ui_draw_table(cf);
+	else {
+		ui_draw_partition(cf, old);	/* cleanup old */
+		ui_draw_partition(cf, where);	/* draw new */
+	}
+	ui_clean_info();
+	ui_draw_menu(cf);
+	ui_draw_extra(cf);
+	refresh();
+
+	return 0;
+}
+
+static int ui_refresh(struct cfdisk *cf)
+{
+	struct fdisk_label *lb;
+	char *id = NULL;
+        uint64_t bytes = fdisk_get_nsectors(cf->cxt) * fdisk_get_sector_size(cf->cxt);
+	char *strsz;
+
+	if (!ui_enabled)
+		return -EINVAL;
+
+	strsz = size_to_human_string(SIZE_DECIMAL_2DIGITS
+				| SIZE_SUFFIX_SPACE
+				| SIZE_SUFFIX_3LETTER, bytes);
+
+	lb = fdisk_get_label(cf->cxt, NULL);
+	assert(lb);
+
+	clear();
+
+	/* header */
+	attron(A_BOLD);
+	ui_center(0, _("Disk: %s"), fdisk_get_devname(cf->cxt));
+	attroff(A_BOLD);
+	ui_center(1, _("Size: %s, %"PRIu64" bytes, %ju sectors"),
+			strsz, bytes, (uintmax_t) fdisk_get_nsectors(cf->cxt));
+	if (fdisk_get_disklabel_id(cf->cxt, &id) == 0 && id)
+		ui_center(2, _("Label: %s, identifier: %s"),
+				fdisk_label_get_name(lb), id);
+	else
+		ui_center(2, _("Label: %s"), fdisk_label_get_name(lb));
+	free(strsz);
+	free(id);
+
+	ui_draw_table(cf);
+	ui_draw_menu(cf);
+	refresh();
+	return 0;
+}
+
+static ssize_t ui_get_string(const char *prompt,
+			     const char *hint, char *buf, size_t len)
+{
+	int ln = MENU_START_LINE, cl = 1;
+	ssize_t rc = -1;
+	struct mbs_editor *edit;
+
+	DBG(UI, ul_debug("ui get string"));
+
+	assert(buf);
+	assert(len);
+
+	move(ln, 0);
+	clrtoeol();
+
+	move(ln + 1, 0);
+	clrtoeol();
+
+	if (prompt) {
+		mvaddstr(ln, cl, prompt);
+		cl += mbs_safe_width(prompt);
+	}
+
+	edit = mbs_new_edit(buf, len, ui_cols - cl);
+	if (!edit)
+		goto done;
+
+	mbs_edit_goto(edit, MBS_EDIT_END);
+
+	if (hint)
+		ui_hint("%s", hint);
+	else
+		ui_clean_hint();
+
+	curs_set(1);
+
+	while (!sig_die) {
+		wint_t c;	/* we have fallback in widechar.h */
+
+		move(ln, cl);
+		clrtoeol();
+		mvaddstr(ln, cl, edit->buf);
+		move(ln, cl + edit->cursor_cells);
+		refresh();
+
+#if !defined(HAVE_SLCURSES_H) && !defined(HAVE_SLANG_SLCURSES_H) && \
+    defined(HAVE_LIBNCURSESW) && defined(HAVE_WIDECHAR)
+		if (get_wch(&c) == ERR) {
+#else
+		if ((c = getch()) == (wint_t) ERR) {
+#endif
+			if (sig_die)
+				break;
+			if (sig_resize) {
+				resize();
+				continue;
+			}
+			if (!isatty(STDIN_FILENO))
+				exit(2);
+			else
+				goto done;
+		}
+
+		DBG(UI, ul_debug("ui get string: key=%lc", c));
+
+		if (c == '\r' || c == '\n' || c == KEY_ENTER)
+			break;
+
+		rc = 1;
+
+		switch (c) {
+		case KEY_ESC:
+			rc = -CFDISK_ERR_ESC;
+			goto done;
+		case KEY_LEFT:
+			rc = mbs_edit_goto(edit, MBS_EDIT_LEFT);
+			break;
+		case KEY_RIGHT:
+			rc = mbs_edit_goto(edit, MBS_EDIT_RIGHT);
+			break;
+		case KEY_END:
+			rc = mbs_edit_goto(edit, MBS_EDIT_END);
+			break;
+		case KEY_HOME:
+			rc = mbs_edit_goto(edit, MBS_EDIT_HOME);
+			break;
+		case KEY_UP:
+		case KEY_DOWN:
+			break;
+		case KEY_DC:
+			rc = mbs_edit_delete(edit);
+			break;
+		case '\b':
+		case KEY_DELETE:
+		case KEY_BACKSPACE:
+			rc = mbs_edit_backspace(edit);
+			break;
+		default:
+			rc = mbs_edit_insert(edit, c);
+			break;
+		}
+		if (rc == 1)
+			beep();
+	}
+
+	if (sig_die)
+		die_on_signal();
+
+	rc = strlen(edit->buf);		/* success */
+done:
+	move(ln, 0);
+	clrtoeol();
+	curs_set(0);
+	refresh();
+	mbs_free_edit(edit);
+
+	return rc;
+}
+
+static int ui_get_size(struct cfdisk *cf,	/* context */
+		       const char *prompt,	/* UI dialog string */
+		       uint64_t *res,		/* result in bytes */
+		       uint64_t low,		/* minimal size */
+		       uint64_t up,		/* maximal size */
+		       int *expsize)		/* explicitly specified size */
+{
+	char buf[128];
+	uint64_t user = 0;
+	ssize_t rc;
+	char *dflt = size_to_human_string(0, *res);
+
+	DBG(UI, ul_debug("get_size (default=%"PRIu64")", *res));
+
+	ui_clean_info();
+
+	snprintf(buf, sizeof(buf), "%s", dflt);
+
+	do {
+		int pwr = 0, insec = 0;
+
+		rc = ui_get_string(prompt,
+				_("May be followed by M for MiB, G for GiB, "
+				  "T for TiB, or S for sectors."),
+				buf, sizeof(buf));
+		ui_clean_warn();
+
+		if (rc == 0) {
+			ui_warnx(_("Please, specify size."));
+			continue;			/* nothing specified */
+		} if (rc == -CFDISK_ERR_ESC)
+			break;				/* cancel dialog */
+
+		if (strcmp(buf, dflt) == 0)
+			user = *res, rc = 0;		/* no change, use default */
+		else {
+			size_t len = strlen(buf);
+			if (buf[len - 1] == 'S' || buf[len - 1] == 's') {
+				insec = 1;
+				buf[len - 1] = '\0';
+			}
+			rc = parse_size(buf, (uintmax_t *)&user, &pwr);	/* parse */
+		}
+
+		if (rc == 0) {
+			DBG(UI, ul_debug("get_size user=%"PRIu64", power=%d, in-sectors=%s",
+						user, pwr, insec ? "yes" : "no"));
+			if (insec)
+				user *= fdisk_get_sector_size(cf->cxt);
+			if (user < low) {
+				ui_warnx(_("Minimum size is %"PRIu64" bytes."), low);
+				rc = -ERANGE;
+			}
+			if (user > up && pwr && user < up + (1ULL << pwr * 10))
+				/* ignore when the user specified size overflow
+				 * with in range specified by suffix (e.g. MiB) */
+				user = up;
+
+			if (user > up) {
+				ui_warnx(_("Maximum size is %"PRIu64" bytes."), up);
+				rc = -ERANGE;
+			}
+			if (rc == 0 && insec && expsize)
+				*expsize = 1;
+
+		} else
+			ui_warnx(_("Failed to parse size."));
+	} while (rc != 0);
+
+	if (rc == 0)
+		*res = user;
+	free(dflt);
+
+	DBG(UI, ul_debug("get_size (result=%"PRIu64", rc=%zd)", *res, rc));
+	return rc;
+}
+
+static struct fdisk_parttype *ui_get_parttype(struct cfdisk *cf,
+					struct fdisk_parttype *cur)
+{
+	struct cfdisk_menuitem *d, *cm;
+	size_t i = 0, nitems, idx = 0;
+	struct fdisk_parttype *t = NULL;
+	struct fdisk_label *lb;
+	int codetypes = 0;
+
+	DBG(UI, ul_debug("asking for parttype."));
+
+	lb = fdisk_get_label(cf->cxt, NULL);
+
+	/* create cfdisk menu according to label types, note that the
+	 * last cm[] item has to be empty -- so nitems + 1 */
+	nitems = fdisk_label_get_nparttypes(lb);
+	if (!nitems)
+		return NULL;
+
+	cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
+	if (!cm)
+		return NULL;
+
+	codetypes = fdisk_label_has_code_parttypes(lb);
+
+	for (i = 0; i < nitems; i++) {
+		const struct fdisk_parttype *x = fdisk_label_get_parttype(lb, i);
+		char *name;
+
+		cm[i].userdata = (void *) x;
+		if (codetypes)
+			xasprintf(&name, "%2x %s",
+				fdisk_parttype_get_code(x),
+				_(fdisk_parttype_get_name(x)));
+		else {
+			name = (char *) _(fdisk_parttype_get_name(x));
+			cm[i].desc = fdisk_parttype_get_string(x);
+		}
+		cm[i].name = name;
+		if (x == cur)
+			idx = i;
+	}
+
+	/* make the new menu active */
+	menu_push(cf, cm);
+	cf->menu->vertical = 1;
+	cf->menu->idx = idx;
+	menu_set_title(cf->menu, _("Select partition type"));
+	ui_draw_menu(cf);
+	refresh();
+
+	while (!sig_die) {
+		int key = getch();
+
+		if (sig_die)
+			break;
+		if (sig_resize)
+			ui_menu_resize(cf);
+		if (ui_menu_move(cf, key) == 0)
+			continue;
+
+		switch (key) {
+		case KEY_ENTER:
+		case '\n':
+		case '\r':
+			d = menu_get_menuitem(cf, cf->menu->idx);
+			if (d)
+				t = (struct fdisk_parttype *) d->userdata;
+			goto done;
+		case KEY_ESC:
+		case 'q':
+		case 'Q':
+			goto done;
+		}
+	}
+
+	if (sig_die)
+		die_on_signal();
+done:
+	menu_pop(cf);
+	if (codetypes) {
+		for (i = 0; i < nitems; i++)
+			free((char *) cm[i].name);
+	}
+	free(cm);
+	DBG(UI, ul_debug("get parrtype done [type=%s] ", t ?
+				fdisk_parttype_get_name(t) : ""));
+	return t;
+}
+
+static int ui_script_read(struct cfdisk *cf)
+{
+	struct fdisk_script *sc = NULL;
+	char buf[PATH_MAX] = { 0 };
+	int rc;
+
+	erase();
+	rc = ui_get_string(	_("Enter script file name: "),
+				_("The script file will be applied to in-memory partition table."),
+				buf, sizeof(buf));
+	if (rc <= 0)
+		return rc;
+
+	rc = -1;
+	errno = 0;
+	sc = fdisk_new_script_from_file(cf->cxt, buf);
+	if (!sc && errno)
+		ui_warn(_("Cannot open %s"), buf);
+	else if (!sc)
+		ui_warnx(_("Failed to parse script file %s"), buf);
+	else if (fdisk_apply_script(cf->cxt, sc) != 0)
+		ui_warnx(_("Failed to apply script %s"), buf);
+	else
+		rc = 0;
+
+	ui_clean_hint();
+	fdisk_unref_script(sc);
+	return rc;
+}
+
+static int ui_script_write(struct cfdisk *cf)
+{
+	struct fdisk_script *sc = NULL;
+	char buf[PATH_MAX] = { 0 };
+	FILE *f = NULL;
+	int rc;
+
+	rc = ui_get_string(	_("Enter script file name: "),
+				_("The current in-memory partition table will be dumped to the file."),
+				buf, sizeof(buf));
+	if (rc <= 0)
+		return rc;
+
+	rc = 0;
+	sc = fdisk_new_script(cf->cxt);
+	if (!sc) {
+		ui_warn(_("Failed to allocate script handler"));
+		goto done;
+	}
+
+	rc = fdisk_script_read_context(sc, NULL);
+	if (rc) {
+		ui_warnx(_("Failed to read disk layout into script."));
+		goto done;
+	}
+
+	DBG(UI, ul_debug("writing dump into: '%s'", buf));
+	f = fopen(buf, "w");
+	if (!f) {
+		ui_warn(_("Cannot open %s"), buf);
+		rc = -errno;
+		goto done;
+	}
+
+	rc = fdisk_script_write_file(sc, f);
+	if (!rc)
+		ui_info(_("Disk layout successfully dumped."));
+done:
+	if (rc)
+		ui_warn(_("Failed to write script %s"), buf);
+	if (f)
+		fclose(f);
+	fdisk_unref_script(sc);
+	return rc;
+}
+
+/* prints menu with libfdisk labels and waits for users response */
+static int ui_create_label(struct cfdisk *cf)
+{
+	struct cfdisk_menuitem *d, *cm;
+	int rc = 1, refresh_menu = 1;
+	size_t i = 0, nitems;
+	struct fdisk_label *lb = NULL;
+
+	assert(cf);
+
+	DBG(UI, ul_debug("asking for new disklabe."));
+
+	/* create cfdisk menu according to libfdisk labels, note that the
+	 * last cm[] item has to be empty -- so nitems + 1 */
+	nitems = fdisk_get_nlabels(cf->cxt);
+	cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
+
+	while (fdisk_next_label(cf->cxt, &lb) == 0) {
+		if (fdisk_label_is_disabled(lb) ||
+		    fdisk_label_get_type(lb) == FDISK_DISKLABEL_BSD)
+			continue;
+		cm[i++].name = fdisk_label_get_name(lb);
+	}
+
+	erase();
+
+	/* make the new menu active */
+	menu_push(cf, cm);
+	cf->menu->vertical = 1;
+	menu_set_title(cf->menu, _("Select label type"));
+
+	if (!cf->zero_start)
+		ui_info(_("Device does not contain a recognized partition table."));
+
+
+	while (!sig_die) {
+		int key;
+
+		if (refresh_menu) {
+			ui_draw_menu(cf);
+			ui_hint(_("Select a type to create a new label, press 'L' to load script file, 'Q' quits."));
+			refresh();
+			refresh_menu = 0;
+		}
+
+		key = getch();
+
+		if (sig_die)
+			break;
+		if (sig_resize)
+			ui_menu_resize(cf);
+		if (ui_menu_move(cf, key) == 0)
+			continue;
+		switch (key) {
+		case KEY_ENTER:
+		case '\n':
+		case '\r':
+			d = menu_get_menuitem(cf, cf->menu->idx);
+			if (d)
+				rc = fdisk_create_disklabel(cf->cxt, d->name);
+			goto done;
+		case KEY_ESC:
+		case 'q':
+		case 'Q':
+			goto done;
+		case 'l':
+		case 'L':
+			rc = ui_script_read(cf);
+			if (rc == 0)
+				goto done;
+			refresh_menu = 1;
+			break;
+		}
+	}
+
+	if (sig_die)
+		die_on_signal();
+done:
+	menu_pop(cf);
+	free(cm);
+	DBG(UI, ul_debug("create label done [rc=%d] ", rc));
+	return rc;
+}
+
+
+static int ui_help(void)
+{
+	size_t i;
+	static const char *help[] = {
+		N_("This is cfdisk, a curses-based disk partitioning program."),
+		N_("It lets you create, delete, and modify partitions on a block device."),
+		"  ",
+		N_("Command      Meaning"),
+		N_("-------      -------"),
+		N_("  b          Toggle bootable flag of the current partition"),
+		N_("  d          Delete the current partition"),
+		N_("  h          Print this screen"),
+		N_("  n          Create new partition from free space"),
+		N_("  q          Quit program without writing partition table"),
+		N_("  r          Reduce or enlarge the current partition"),
+		N_("  s          Fix partitions order (only when in disarray)"),
+		N_("  t          Change the partition type"),
+		N_("  u          Dump disk layout to sfdisk compatible script file"),
+		N_("  W          Write partition table to disk (you must enter uppercase W);"),
+		N_("               since this might destroy data on the disk, you must either"),
+		N_("               confirm or deny the write by entering 'yes' or 'no'"),
+		N_("  x          Display/hide extra information about a partition"),
+		N_("Up Arrow     Move cursor to the previous partition"),
+		N_("Down Arrow   Move cursor to the next partition"),
+		N_("Left Arrow   Move cursor to the previous menu item"),
+		N_("Right Arrow  Move cursor to the next menu item"),
+		"  ",
+		N_("Note: All of the commands can be entered with either upper or lower"),
+		N_("case letters (except for Write)."),
+		"  ",
+		N_("Use lsblk(8) or partx(8) to see more details about the device."),
+		"  ",
+		"  ",
+		"Copyright (C) 2014-2017 Karel Zak <kzak@redhat.com>"
+	};
+
+	erase();
+	for (i = 0; i < ARRAY_SIZE(help); i++)
+		mvaddstr(i, 1, _(help[i]));
+
+	ui_info(_("Press a key to continue."));
+
+	getch();
+
+	if (sig_die)
+		die_on_signal();
+	return 0;
+}
+
+/* TODO: use @sz, now 128bytes */
+static int main_menu_ignore_keys(struct cfdisk *cf, char *ignore,
+		size_t sz __attribute__((__unused__)))
+{
+	struct fdisk_partition *pa = get_current_partition(cf);
+	size_t i = 0;
+
+	if (!pa)
+		return 0;
+	if (fdisk_partition_is_freespace(pa)) {
+		ignore[i++] = 'd';	/* delete */
+		ignore[i++] = 't';	/* set type */
+		ignore[i++] = 'b';      /* set bootable */
+		ignore[i++] = 'r';	/* resize */
+		cf->menu->prefkey = 'n';
+	} else {
+		cf->menu->prefkey = 'q';
+		ignore[i++] = 'n';
+		if (!fdisk_is_label(cf->cxt, DOS) &&
+		    !fdisk_is_label(cf->cxt, SGI))
+			ignore[i++] = 'b';
+	}
+
+	if (!cf->wrong_order)
+		ignore[i++] = 's';
+
+	if (fdisk_is_readonly(cf->cxt))
+		ignore[i++] = 'W';
+
+	return i;
+}
+
+
+/* returns: error: < 0, success: 0, quit: 1 */
+static int main_menu_action(struct cfdisk *cf, int key)
+{
+	size_t n;
+	int ref = 0, rc, org_order = cf->wrong_order;
+	const char *info = NULL, *warn = NULL;
+	struct fdisk_partition *pa;
+
+	assert(cf);
+	assert(cf->cxt);
+	assert(cf->menu);
+
+	if (key == 0) {
+		struct cfdisk_menuitem *d = menu_get_menuitem(cf, cf->menu->idx);
+		if (!d)
+			return 0;
+		key = d->key;
+
+	} else if (key != 'w' && key != 'W')
+		key = tolower(key);	/* case insensitive except 'W'rite */
+
+	DBG(MENU, ul_debug("main menu action: key=%c", key));
+
+	if (cf->menu->ignore && strchr(cf->menu->ignore, key)) {
+		DBG(MENU, ul_debug("  ignore '%c'", key));
+		return 0;
+	}
+
+	pa = get_current_partition(cf);
+	if (!pa)
+		return -EINVAL;
+	n = fdisk_partition_get_partno(pa);
+
+	DBG(MENU, ul_debug("menu action on %p", pa));
+	ui_clean_hint();
+	ui_clean_info();
+
+	switch (key) {
+	case 'b': /* Bootable flag */
+	{
+		int fl = fdisk_is_label(cf->cxt, DOS) ? DOS_FLAG_ACTIVE :
+			 fdisk_is_label(cf->cxt, SGI) ? SGI_FLAG_BOOT : 0;
+
+		if (fl && fdisk_toggle_partition_flag(cf->cxt, n, fl))
+			warn = _("Could not toggle the flag.");
+		else if (fl)
+			ref = 1;
+		break;
+	}
+#ifdef KEY_DC
+	case KEY_DC:
+#endif
+	case 'd': /* Delete */
+		if (fdisk_delete_partition(cf->cxt, n) != 0)
+			warn = _("Could not delete partition %zu.");
+		else
+			info = _("Partition %zu has been deleted.");
+		ref = 1;
+		break;
+	case 'h': /* Help */
+	case '?':
+		ui_help();
+		ref = 1;
+		break;
+	case 'n': /* New */
+	{
+		uint64_t start, size, dflt_size, secs, max_size;
+		struct fdisk_partition *npa;	/* the new partition */
+		int expsize = 0;		/* size specified explicitly in sectors */
+
+		if (!fdisk_partition_is_freespace(pa) || !fdisk_partition_has_start(pa))
+			return -EINVAL;
+
+		/* free space range */
+		start = fdisk_partition_get_start(pa);
+		size = max_size = dflt_size = fdisk_partition_get_size(pa) * fdisk_get_sector_size(cf->cxt);
+
+		if (ui_get_size(cf, _("Partition size: "), &size,
+				fdisk_get_sector_size(cf->cxt),
+				max_size, &expsize) == -CFDISK_ERR_ESC)
+			break;
+
+		secs = size / fdisk_get_sector_size(cf->cxt);
+
+		npa = fdisk_new_partition();
+		if (!npa)
+			return -ENOMEM;
+
+		if (dflt_size == size)	/* default is to fillin all free space */
+			fdisk_partition_end_follow_default(npa, 1);
+		else
+			fdisk_partition_set_size(npa, secs);
+
+		if (expsize)
+			fdisk_partition_size_explicit(pa, 1);
+
+		fdisk_partition_set_start(npa, start);
+		fdisk_partition_partno_follow_default(npa, 1);
+		/* add to disk label -- libfdisk will ask for missing details */
+		rc = fdisk_add_partition(cf->cxt, npa, NULL);
+		fdisk_unref_partition(npa);
+		if (rc == 0)
+			ref = 1;
+		break;
+	}
+	case 'q': /* Quit */
+		return 1;
+	case 't': /* Type */
+	{
+		struct fdisk_parttype *t;
+
+		if (fdisk_partition_is_freespace(pa))
+			return -EINVAL;
+		t = (struct fdisk_parttype *) fdisk_partition_get_type(pa);
+		t = ui_get_parttype(cf, t);
+		ref = 1;
+
+		if (t && fdisk_set_partition_type(cf->cxt, n, t) == 0)
+			info = _("Changed type of partition %zu.");
+		else
+			info = _("The type of partition %zu is unchanged.");
+		break;
+	}
+	case 'r': /* resize */
+	{
+		struct fdisk_partition *npa, *next;
+		uint64_t size, max_size, secs;
+
+		if (fdisk_partition_is_freespace(pa) || !fdisk_partition_has_start(pa))
+			return -EINVAL;
+
+		size = fdisk_partition_get_size(pa);
+
+		/* is the next freespace? */
+		next = fdisk_table_get_partition(cf->table, cf->lines_idx + 1);
+		if (next && fdisk_partition_is_freespace(next))
+			size += fdisk_partition_get_size(next);
+
+		size *= fdisk_get_sector_size(cf->cxt);
+		max_size = size;
+
+		if (ui_get_size(cf, _("New size: "), &size,
+				fdisk_get_sector_size(cf->cxt),
+				max_size, NULL) == -CFDISK_ERR_ESC)
+			break;
+		secs = size / fdisk_get_sector_size(cf->cxt);
+		npa = fdisk_new_partition();
+		if (!npa)
+			return -ENOMEM;
+
+		fdisk_partition_set_size(npa, secs);
+
+		rc = fdisk_set_partition(cf->cxt, n, npa);
+		fdisk_unref_partition(npa);
+		if (rc == 0) {
+			ref = 1;
+			info = _("Partition %zu resized.");
+		}
+		break;
+	}
+	case 's': /* Sort */
+		if (cf->wrong_order) {
+			fdisk_reorder_partitions(cf->cxt);
+			ref = 1;
+		}
+		break;
+	case 'u': /* dUmp */
+		ui_script_write(cf);
+		break;
+	case 'W': /* Write */
+	{
+		char buf[64] = { 0 };
+
+		if (fdisk_is_readonly(cf->cxt)) {
+			warn = _("Device is open in read-only mode.");
+			break;
+		}
+
+		rc = ui_get_string(
+			  _("Are you sure you want to write the partition "
+			    "table to disk? "),
+			  _("Type \"yes\" or \"no\", or press ESC to leave this dialog."),
+			  buf, sizeof(buf));
+
+		ref = 1;
+		if (rc <= 0 || (strcasecmp(buf, "yes") != 0 &&
+				strcasecmp(buf, _("yes")) != 0)) {
+			info = _("Did not write partition table to disk.");
+			break;
+		}
+		rc = fdisk_write_disklabel(cf->cxt);
+		if (rc)
+			warn = _("Failed to write disklabel.");
+		else {
+			if (cf->device_is_used)
+				fdisk_reread_changes(cf->cxt, cf->original_layout);
+			else
+				fdisk_reread_partition_table(cf->cxt);
+			info = _("The partition table has been altered.");
+		}
+		cf->nwrites++;
+		break;
+	}
+	default:
+		break;
+	}
+
+	if (ref) {
+		lines_refresh(cf);
+		ui_refresh(cf);
+		ui_draw_extra(cf);
+	} else
+		ui_draw_menu(cf);
+
+	ui_clean_hint();
+
+	if (warn)
+		ui_warnx(warn, n + 1);
+	else if (info)
+		ui_info(info, n + 1);
+	else if (key == 'n' && cf->wrong_order && org_order == 0)
+		 ui_info(_("Note that partition table entries are not in disk order now."));
+
+	return 0;
+}
+
+static void ui_resize_refresh(struct cfdisk *cf)
+{
+	DBG(UI, ul_debug("ui resize/refresh"));
+	resize();
+	menu_refresh_size(cf);
+	lines_refresh(cf);
+	ui_refresh(cf);
+	ui_draw_extra(cf);
+}
+
+static void toggle_show_extra(struct cfdisk *cf)
+{
+	if (cf->show_extra && cf->act_win) {
+		wclear(cf->act_win);
+		touchwin(stdscr);
+	}
+	cf->show_extra = cf->show_extra ? 0 : 1;
+
+	if (cf->show_extra)
+		ui_draw_extra(cf);
+	DBG(MENU, ul_debug("extra: %s", cf->show_extra ? "ENABLED" : "DISABLED" ));
+}
+
+static int ui_run(struct cfdisk *cf)
+{
+	int rc = 0;
+
+	ui_lines = LINES;
+	ui_cols = COLS;
+	DBG(UI, ul_debug("start cols=%zu, lines=%zu", ui_cols, ui_lines));
+
+	if (fdisk_get_collision(cf->cxt)) {
+		ui_warnx(_("Device already contains a %s signature; it will be removed by a write command."),
+				fdisk_get_collision(cf->cxt));
+		fdisk_enable_wipe(cf->cxt, 1);
+		ui_hint(_("Press a key to continue."));
+		getch();
+	}
+
+	if (!fdisk_has_label(cf->cxt) || cf->zero_start) {
+		rc = ui_create_label(cf);
+		if (rc < 0) {
+			errno = -rc;
+			ui_err(EXIT_FAILURE,
+					_("failed to create a new disklabel"));
+		}
+		if (rc)
+			return rc;
+	}
+
+	cols_init(cf);
+	rc = lines_refresh(cf);
+	if (rc)
+		ui_errx(EXIT_FAILURE, _("failed to read partitions"));
+
+	menu_push(cf, main_menuitems);
+	cf->menu->ignore_cb = main_menu_ignore_keys;
+
+	rc = ui_refresh(cf);
+	if (rc)
+		return rc;
+
+	cf->show_extra = 1;
+	ui_draw_extra(cf);
+
+	if (fdisk_is_readonly(cf->cxt))
+		ui_warnx(_("Device is open in read-only mode. Changes will remain in memory only."));
+	else if (cf->device_is_used)
+		ui_warnx(_("Device is currently in use, repartitioning is probably a bad idea."));
+	else if (cf->wrong_order)
+		ui_info(_("Note that partition table entries are not in disk order now."));
+
+	while (!sig_die) {
+		int key = getch();
+
+		rc = 0;
+
+		if (sig_die)
+			break;
+		if (sig_resize)
+			/* Note that ncurses getch() returns ERR when interrupted
+			 * by signal, but SLang does not interrupt at all. */
+			ui_resize_refresh(cf);
+		if (key == ERR)
+			continue;
+		if (key == '\014') {		/* ^L refresh */
+			ui_resize_refresh(cf);
+			continue;
+		}
+		if (ui_menu_move(cf, key) == 0)
+			continue;
+
+		DBG(UI, ul_debug("main action key >%1$c< [\\0%1$o].", key));
+
+		switch (key) {
+		case KEY_DOWN:
+		case '\016':	/* ^N */
+		case 'j':	/* Vi-like alternative */
+			ui_table_goto(cf, cf->lines_idx + 1);
+			break;
+		case KEY_UP:
+		case '\020':	/* ^P */
+		case 'k':	/* Vi-like alternative */
+			ui_table_goto(cf, (int) cf->lines_idx - 1);
+			break;
+		case KEY_PPAGE:
+			if (cf->page_sz) {
+				ui_table_goto(cf, (int) cf->lines_idx - cf->page_sz);
+				break;
+			}
+			/* fallthrough */
+		case KEY_HOME:
+			ui_table_goto(cf, 0);
+			break;
+		case KEY_NPAGE:
+			if (cf->page_sz) {
+				ui_table_goto(cf, cf->lines_idx + cf->page_sz);
+				break;
+			}
+			/* fallthrough */
+		case KEY_END:
+			ui_table_goto(cf, (int) cf->nlines - 1);
+			break;
+		case KEY_ENTER:
+		case '\n':
+		case '\r':
+			rc = main_menu_action(cf, 0);
+			break;
+		case 'X':
+		case 'x': /* Extra */
+			toggle_show_extra(cf);
+			break;
+		default:
+			rc = main_menu_action(cf, key);
+			if (rc < 0)
+				beep();
+			break;
+		}
+
+		if (rc == 1)
+			break; /* quit */
+	}
+
+	menu_pop(cf);
+
+	DBG(UI, ul_debug("end"));
+	return 0;
+}
+
+static void __attribute__((__noreturn__)) usage(void)
+{
+	FILE *out = stdout;
+	fputs(USAGE_HEADER, out);
+	fprintf(out,
+	      _(" %1$s [options] <disk>\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("Display or manipulate a disk partition table.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fprintf(out,
+	      _(" -L, --color[=<when>]     colorize output (%s, %s or %s)\n"), "auto", "always", "never");
+	fprintf(out,
+	        "                            %s\n", USAGE_COLORS_DEFAULT);
+	fputs(_(" -z, --zero               start with zeroed partition table\n"), out);
+	fprintf(out,
+	      _("     --lock[=<mode>]      use exclusive device lock (%s, %s or %s)\n"), "yes", "no", "nonblock");
+	fputs(_(" -r, --read-only          forced open cfdisk in read-only mode\n"), out);
+
+	fputs(USAGE_SEPARATOR, out);
+	printf(USAGE_HELP_OPTIONS(26));
+
+	printf(USAGE_MAN_TAIL("cfdisk(8)"));
+	exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+	const char *diskpath = NULL, *lockmode = NULL;
+	int rc, c, colormode = UL_COLORMODE_UNDEF;
+	int read_only = 0;
+	struct cfdisk _cf = { .lines_idx = 0 },
+		      *cf = &_cf;
+	enum {
+		OPT_LOCK	= CHAR_MAX + 1
+	};
+	static const struct option longopts[] = {
+		{ "color",   optional_argument, NULL, 'L' },
+		{ "lock",    optional_argument, NULL, OPT_LOCK },
+		{ "help",    no_argument,       NULL, 'h' },
+		{ "version", no_argument,       NULL, 'V' },
+		{ "zero",    no_argument,	NULL, 'z' },
+		{ "read-only", no_argument,     NULL, 'r' },
+		{ NULL, 0, NULL, 0 },
+	};
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	close_stdout_atexit();
+
+	while((c = getopt_long(argc, argv, "L::hVzr", longopts, NULL)) != -1) {
+		switch(c) {
+		case 'h':
+			usage();
+			break;
+		case 'L':
+			colormode = UL_COLORMODE_AUTO;
+			if (optarg)
+				colormode = colormode_or_err(optarg,
+						_("unsupported color mode"));
+			break;
+                case 'r':
+                        read_only = 1;
+                        break;
+		case 'V':
+			print_version(EXIT_SUCCESS);
+		case 'z':
+			cf->zero_start = 1;
+			break;
+		case OPT_LOCK:
+			lockmode = "1";
+			if (optarg) {
+				if (*optarg == '=')
+					optarg++;
+				lockmode = optarg;
+			}
+			break;
+		default:
+			errtryhelp(EXIT_FAILURE);
+		}
+	}
+
+	colors_init(colormode, "cfdisk");
+
+	fdisk_init_debug(0);
+	scols_init_debug(0);
+	cfdisk_init_debug();
+	cf->cxt = fdisk_new_context();
+	if (!cf->cxt)
+		err(EXIT_FAILURE, _("failed to allocate libfdisk context"));
+
+	fdisk_set_ask(cf->cxt, ask_callback, (void *) cf);
+
+	if (optind == argc) {
+		size_t i;
+
+		for (i = 0; i < ARRAY_SIZE(default_disks); i++) {
+			if (access(default_disks[i], F_OK) == 0) {
+				diskpath = default_disks[i];
+				break;
+			}
+		}
+		if (!diskpath)
+			diskpath = default_disks[0];	/* default, used for "cannot open" */
+	} else
+		diskpath = argv[optind];
+
+	rc = fdisk_assign_device(cf->cxt, diskpath, read_only);
+	if (rc == -EACCES && read_only == 0)
+		rc = fdisk_assign_device(cf->cxt, diskpath, 1);
+	if (rc != 0)
+		err(EXIT_FAILURE, _("cannot open %s"), diskpath);
+
+	if (!fdisk_is_readonly(cf->cxt)) {
+		if (blkdev_lock(fdisk_get_devfd(cf->cxt), diskpath, lockmode) != 0)
+			return EXIT_FAILURE;
+
+		cf->device_is_used = fdisk_device_is_used(cf->cxt);
+		fdisk_get_partitions(cf->cxt, &cf->original_layout);
+	}
+
+	/* Don't use err(), warn() from this point */
+	ui_init(cf);
+	ui_run(cf);
+	ui_end();
+
+	cfdisk_free_lines(cf);
+	free(cf->linesbuf);
+	free(cf->fields);
+
+	fdisk_unref_table(cf->table);
+#ifdef HAVE_LIBMOUNT
+	mnt_unref_table(cf->fstab);
+	mnt_unref_table(cf->mtab);
+	mnt_unref_cache(cf->mntcache);
+#endif
+	rc = fdisk_deassign_device(cf->cxt, cf->nwrites == 0);
+	fdisk_unref_context(cf->cxt);
+	DBG(MISC, ul_debug("bye! [rc=%d]", rc));
+	return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+}