/*
 * Copyright (C) 1995  Andries E. Brouwer (aeb@cwi.nl)
 * Copyright (C) 2014 Karel Zak <kzak@redhat.com>
 *
 * This program 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 1
 * or (at your option) any later version.
 *
 * A.V. Le Blanc (LeBlanc@mcc.ac.uk) wrote Linux fdisk 1992-1994,
 * patched by various people (faith@cs.unc.edu, martin@cs.unc.edu,
 * leisner@sdsp.mc.xerox.com, esr@snark.thyrsus.com, aeb@cwi.nl)
 * 1993-1995, with version numbers (as far as I have seen) 0.93 - 2.0e.
 * This program had (head,sector,cylinder) as basic unit, and was
 * (therefore) broken in several ways for the use on larger disks -
 * for example, my last patch (from 2.0d to 2.0e) was required
 * to allow a partition to cross cylinder 8064, and to write an
 * extended partition past the 4GB mark.
 *
 * Karel Zak wrote new sfdisk based on libfdisk from util-linux
 * in 2014.
 */

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <sys/stat.h>
#include <assert.h>
#include <fcntl.h>
#include <libsmartcols.h>
#ifdef HAVE_LIBREADLINE
# define _FUNCTION_DEF
# include <readline/readline.h>
#endif
#include <libgen.h>

#include "c.h"
#include "xalloc.h"
#include "nls.h"
#include "debug.h"
#include "strutils.h"
#include "closestream.h"
#include "colors.h"
#include "blkdev.h"
#include "all-io.h"
#include "rpmatch.h"
#include "optutils.h"

#include "libfdisk.h"
#include "fdisk-list.h"

/*
 * sfdisk debug stuff (see fdisk.h and include/debug.h)
 */
static UL_DEBUG_DEFINE_MASK(sfdisk);
UL_DEBUG_DEFINE_MASKNAMES(sfdisk) = UL_DEBUG_EMPTY_MASKNAMES;

#define SFDISKPROG_DEBUG_INIT	(1 << 1)
#define SFDISKPROG_DEBUG_PARSE	(1 << 2)
#define SFDISKPROG_DEBUG_MISC	(1 << 3)
#define SFDISKPROG_DEBUG_ASK	(1 << 4)
#define SFDISKPROG_DEBUG_ALL	0xFFFF

#define DBG(m, x)       __UL_DBG(sfdisk, SFDISKPROG_DEBUG_, m, x)
#define ON_DBG(m, x)    __UL_DBG_CALL(sfdisk, SFDISKPROG_DEBUG_, m, x)

enum {
	ACT_FDISK = 1,
	ACT_ACTIVATE,
	ACT_CHANGE_ID,
	ACT_DUMP,
	ACT_LIST,
	ACT_LIST_FREE,
	ACT_LIST_TYPES,
	ACT_REORDER,
	ACT_SHOW_SIZE,
	ACT_SHOW_GEOM,
	ACT_VERIFY,
	ACT_PARTTYPE,
	ACT_PARTUUID,
	ACT_PARTLABEL,
	ACT_PARTATTRS,
	ACT_DELETE
};

struct sfdisk {
	int		act;		/* ACT_* */
	int		partno;		/* -N <partno>, default -1 */
	int		wipemode;	/* remove foreign signatures from disk */
	int		pwipemode;	/* remove foreign signatures from partitions */
	const char	*label;		/* --label <label> */
	const char	*label_nested;	/* --label-nested <label> */
	const char	*backup_file;	/* -O <path> */
	const char	*move_typescript; /* --movedata <typescript> */
	char		*prompt;

	struct fdisk_context	*cxt;		/* libfdisk context */
	struct fdisk_partition  *orig_pa;	/* -N <partno> before the change */

	unsigned int verify : 1,	/* call fdisk_verify_disklabel() */
		     quiet  : 1,	/* suppress extra messages */
		     interactive : 1,	/* running on tty */
		     noreread : 1,	/* don't check device is in use */
		     force  : 1,	/* do also stupid things */
		     backup : 1,	/* backup sectors before write PT */
		     container : 1,	/* PT contains container (MBR extended) partitions */
		     append : 1,	/* don't create new PT, append partitions only */
		     json : 1,		/* JSON dump */
		     movedata: 1,	/* move data after resize */
		     notell : 1,	/* don't tell kernel aout new PT */
		     noact  : 1;	/* do not write to device */
};

#define SFDISK_PROMPT	">>> "

static void sfdiskprog_init_debug(void)
{
	__UL_INIT_DEBUG_FROM_ENV(sfdisk, SFDISKPROG_DEBUG_, 0, SFDISK_DEBUG);
}


static int get_user_reply(const char *prompt, char *buf, size_t bufsz)
{
	char *p;
	size_t sz;

#ifdef HAVE_LIBREADLINE
	if (isatty(STDIN_FILENO)) {
		p = readline(prompt);
		if (!p)
			return 1;
		memcpy(buf, p, bufsz);
		free(p);
	} else
#endif
	{
		fputs(prompt, stdout);
		fflush(stdout);

		if (!fgets(buf, bufsz, stdin))
			return 1;
	}

	for (p = buf; *p && !isgraph(*p); p++);	/* get first non-blank */

	if (p > buf)
		memmove(buf, p, p - buf);	/* remove blank space */
	sz = strlen(buf);
	if (sz && *(buf + sz - 1) == '\n')
		*(buf + sz - 1) = '\0';

	DBG(ASK, ul_debug("user's reply: >>>%s<<<", buf));
	return 0;
}

static int ask_callback(struct fdisk_context *cxt __attribute__((__unused__)),
			struct fdisk_ask *ask,
			void *data)
{
	struct sfdisk *sf = (struct sfdisk *) data;
	int rc = 0;

	assert(ask);

	switch(fdisk_ask_get_type(ask)) {
	case FDISK_ASKTYPE_INFO:
		if (sf->quiet)
			break;
		fputs(fdisk_ask_print_get_mesg(ask), stdout);
		fputc('\n', stdout);
		break;
	case FDISK_ASKTYPE_WARNX:
		fflush(stdout);
		color_scheme_fenable("warn", UL_COLOR_RED, stderr);
		fputs(fdisk_ask_print_get_mesg(ask), stderr);
		color_fdisable(stderr);
		fputc('\n', stderr);
		break;
	case FDISK_ASKTYPE_WARN:
		fflush(stdout);
		color_scheme_fenable("warn", UL_COLOR_RED, stderr);
		fputs(fdisk_ask_print_get_mesg(ask), stderr);
		errno = fdisk_ask_print_get_errno(ask);
		fprintf(stderr, ": %m\n");
		color_fdisable(stderr);
		break;
	case FDISK_ASKTYPE_YESNO:
	{
		char buf[BUFSIZ];
		fputc('\n', stdout);
		do {
			int x;
			fputs(fdisk_ask_get_query(ask), stdout);
			rc = get_user_reply(_(" [Y]es/[N]o: "), buf, sizeof(buf));
			if (rc)
				break;
			x = rpmatch(buf);
			if (x == RPMATCH_YES || x == RPMATCH_NO) {
				fdisk_ask_yesno_set_result(ask, x);
				break;
			}
		} while(1);
		DBG(ASK, ul_debug("yes-no ask: reply '%s' [rc=%d]", buf, rc));
		break;
	}
	default:
		break;
	}
	return rc;
}

static void sfdisk_init(struct sfdisk *sf)
{
	fdisk_init_debug(0);
	scols_init_debug(0);
	sfdiskprog_init_debug();

	sf->cxt = fdisk_new_context();
	if (!sf->cxt)
		err(EXIT_FAILURE, _("failed to allocate libfdisk context"));
	fdisk_set_ask(sf->cxt, ask_callback, (void *) sf);
	fdisk_enable_bootbits_protection(sf->cxt, 1);

	if (sf->label_nested) {
		struct fdisk_context *x = fdisk_new_nested_context(sf->cxt,
							sf->label_nested);
		if (!x)
			err(EXIT_FAILURE, _("failed to allocate nested libfdisk context"));
		/* the original context is available by fdisk_get_parent() */
		sf->cxt = x;
	}
}

static int sfdisk_deinit(struct sfdisk *sf)
{
	struct fdisk_context *parent;

	assert(sf);
	assert(sf->cxt);

	parent = fdisk_get_parent(sf->cxt);
	if (parent) {
		fdisk_unref_context(sf->cxt);
		sf->cxt = parent;
	}

	fdisk_unref_context(sf->cxt);
	free(sf->prompt);

	memset(sf, 0, sizeof(*sf));
	return 0;
}

static struct fdisk_partition *get_partition(struct fdisk_context *cxt, size_t partno)
{
	struct fdisk_table *tb = NULL;
	struct fdisk_partition *pa;

	if (fdisk_get_partitions(cxt, &tb) != 0)
		return NULL;

	pa = fdisk_table_get_partition_by_partno(tb, partno);
	if (pa)
		fdisk_ref_partition(pa);
	fdisk_unref_table(tb);
	return pa;
}

static void backup_sectors(struct sfdisk *sf,
			   const char *tpl,
			   const char *name,
			   const char *devname,
			   uint64_t offset, size_t size)
{
	char *fname;
	int fd, devfd;

	devfd = fdisk_get_devfd(sf->cxt);
	assert(devfd >= 0);

	xasprintf(&fname, "%s0x%08"PRIx64".bak", tpl, offset);

	fd = open(fname, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
	if (fd < 0)
		goto fail;

	if (lseek(devfd, (off_t) offset, SEEK_SET) == (off_t) -1) {
		fdisk_warn(sf->cxt, _("cannot seek %s"), devname);
		goto fail;
	} else {
		unsigned char *buf = xmalloc(size);

		if (read_all(devfd, (char *) buf, size) != (ssize_t) size) {
			fdisk_warn(sf->cxt, _("cannot read %s"), devname);
			free(buf);
			goto fail;
		}
		if (write_all(fd, buf, size) != 0) {
			fdisk_warn(sf->cxt, _("cannot write %s"), fname);
			free(buf);
			goto fail;
		}
		free(buf);
	}

	fdisk_info(sf->cxt, _("%12s (offset %5ju, size %5ju): %s"),
			name, (uintmax_t) offset, (uintmax_t) size, fname);
	close(fd);
	free(fname);
	return;
fail:
	errx(EXIT_FAILURE, _("%s: failed to create a backup"), devname);
}

static char *mk_backup_filename_tpl(const char *filename, const char *devname, const char *suffix)
{
	char *tpl = NULL;
	char *name, *buf = xstrdup(devname);

	name = basename(buf);

	if (!filename) {
		const char *home = getenv ("HOME");
		if (!home)
			errx(EXIT_FAILURE, _("failed to create a backup file, $HOME undefined"));
		xasprintf(&tpl, "%s/sfdisk-%s%s", home, name, suffix);
	} else
		xasprintf(&tpl, "%s-%s%s", filename, name, suffix);

	free(buf);
	return tpl;
}


static void backup_partition_table(struct sfdisk *sf, const char *devname)
{
	const char *name;
	char *tpl;
	uint64_t offset = 0;
	size_t size = 0;
	int i = 0;

	assert(sf);

	if (!fdisk_has_label(sf->cxt))
		return;

	tpl = mk_backup_filename_tpl(sf->backup_file, devname, "-");

	color_scheme_enable("header", UL_COLOR_BOLD);
	fdisk_info(sf->cxt, _("Backup files:"));
	color_disable();

	while (fdisk_locate_disklabel(sf->cxt, i++, &name, &offset, &size) == 0 && size)
		backup_sectors(sf, tpl, name, devname, offset, size);

	if (!sf->quiet)
		fputc('\n', stdout);
	free(tpl);
}

static int move_partition_data(struct sfdisk *sf, size_t partno, struct fdisk_partition *orig_pa)
{
	struct fdisk_partition *pa = get_partition(sf->cxt, partno);
	char *devname = NULL, *typescript = NULL, *buf = NULL;
	FILE *f = NULL;
	int ok = 0, fd, backward = 0;
	fdisk_sector_t nsectors, from, to, step, i;
	size_t ss, step_bytes, cc;
	uintmax_t src, dst;
	int errsv;

	assert(sf->movedata);

	if (!pa)
		warnx(_("failed to read new partition from device; ignoring --move-data"));
	else if (!fdisk_partition_has_size(pa))
		warnx(_("failed to get size of the new partition; ignoring --move-data"));
	else if (!fdisk_partition_has_start(pa))
		warnx(_("failed to get start of the new partition; ignoring --move-data"));
	else if (!fdisk_partition_has_size(orig_pa))
		warnx(_("failed to get size of the old partition; ignoring --move-data"));
	else if (!fdisk_partition_has_start(orig_pa))
		warnx(_("failed to get start of the old partition; ignoring --move-data"));
	else if (fdisk_partition_get_start(pa) == fdisk_partition_get_start(orig_pa))
		warnx(_("start of the partition has not been moved; ignoring --move-data"));
	else if (fdisk_partition_get_size(orig_pa) < fdisk_partition_get_size(pa))
		warnx(_("new partition is smaller than original; ignoring --move-data"));
	else
		ok = 1;
	if (!ok)
		return -EINVAL;

	DBG(MISC, ul_debug("moving data"));

	fd = fdisk_get_devfd(sf->cxt);

	ss = fdisk_get_sector_size(sf->cxt);
	nsectors = fdisk_partition_get_size(orig_pa);
	from = fdisk_partition_get_start(orig_pa);
	to = fdisk_partition_get_start(pa);

	if ((to >= from && from + nsectors >= to) ||
	    (from >= to && to + nsectors >= from)) {
		/* source and target overlay, check if we need to copy
		 * backwardly from end of the source */
		DBG(MISC, ul_debug("overlay between source and target"));
		backward = from < to;
		DBG(MISC, ul_debug(" copy order: %s", backward ? "backward" : "forward"));

		step = from > to ? from - to : to - from;
		if (step > nsectors)
			step = nsectors;
	} else
		step = nsectors;

	/* make step usable for malloc() */
	if (step * ss > (getpagesize() * 256U))
		step = (getpagesize() * 256) / ss;

	/* align the step (note that nsectors does not have to be power of 2) */
	while (nsectors % step)
		step--;

	step_bytes = step * ss;
	DBG(MISC, ul_debug(" step: %ju (%zu bytes)", (uintmax_t)step, step_bytes));

#if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
	if (!backward)
		posix_fadvise(fd, from * ss, nsectors * ss, POSIX_FADV_SEQUENTIAL);
#endif
	devname = fdisk_partname(fdisk_get_devname(sf->cxt), partno+1);
	typescript = mk_backup_filename_tpl(sf->move_typescript, devname, ".move");

	if (!sf->quiet) {
		fdisk_info(sf->cxt,"");
		color_scheme_enable("header", UL_COLOR_BOLD);
		fdisk_info(sf->cxt, _("Data move:"));
		color_disable();
		fdisk_info(sf->cxt, _(" typescript file: %s"), typescript);
		printf(_(" old start: %ju, new start: %ju (move %ju sectors)\n"),
			(uintmax_t) from, (uintmax_t) to, (uintmax_t) nsectors);
		fflush(stdout);
	}

	if (sf->interactive) {
		int yes = 0;
		fdisk_ask_yesno(sf->cxt, _("Do you want to move partition data?"), &yes);
		if (!yes) {
			fdisk_info(sf->cxt, _("Leaving."));
			return 0;
		}
	}

	f = fopen(typescript, "w");
	if (!f)
		goto fail;

	/* don't translate */
	fprintf(f, "# sfdisk: " PACKAGE_STRING "\n");
	fprintf(f, "# Disk: %s\n", devname);
	fprintf(f, "# Partition: %zu\n", partno + 1);
	fprintf(f, "# Operation: move data\n");
	fprintf(f, "# Original start offset (sectors/bytes): %ju/%ju\n",
	        (uintmax_t)from, (uintmax_t)from * ss);
	fprintf(f, "# New start offset (sectors/bytes): %ju/%ju\n",
	        (uintmax_t)to, (uintmax_t)to * ss);
	fprintf(f, "# Area size (sectors/bytes): %ju/%ju\n",
	        (uintmax_t)nsectors, (uintmax_t)nsectors * ss);
	fprintf(f, "# Sector size: %zu\n", ss);
	fprintf(f, "# Step size (in bytes): %zu\n", step_bytes);
	fprintf(f, "# Steps: %ju\n", (uintmax_t)(nsectors / step));
	fprintf(f, "#\n");
	fprintf(f, "# <step>: <from> <to> (step offsets in bytes)\n");

	src = (backward ? from + nsectors : from) * ss;
	dst = (backward ? to + nsectors : to) * ss;
	buf = xmalloc(step_bytes);

	DBG(MISC, ul_debug(" initial: src=%ju dst=%ju", src, dst));

	for (cc = 1, i = 0; i < nsectors; i += step, cc++) {
		ssize_t rc;

		if (backward)
			src -= step_bytes, dst -= step_bytes;

		DBG(MISC, ul_debug("#%05zu: src=%ju dst=%ju", cc, src, dst));

		/* read source */
		if (lseek(fd, src, SEEK_SET) == (off_t) -1)
			goto fail;
		rc = read(fd, buf, step_bytes);
		if (rc < 0 || rc != (ssize_t) step_bytes)
			goto fail;

		/* write target */
		if (lseek(fd, dst, SEEK_SET) == (off_t) -1)
			goto fail;
		rc = write(fd, buf, step_bytes);
		if (rc < 0 || rc != (ssize_t) step_bytes)
			goto fail;
		fsync(fd);

		/* write log */
		fprintf(f, "%05zu: %12ju %12ju\n", cc, src, dst);

#if defined(POSIX_FADV_DONTNEED) && defined(HAVE_POSIX_FADVISE)
		posix_fadvise(fd, src, step_bytes, POSIX_FADV_DONTNEED);
#endif
		if (!backward)
			src += step_bytes, dst += step_bytes;
	}

	fclose(f);
	free(buf);
	free(devname);
	free(typescript);

	return 0;
fail:
	errsv = -errno;
	warn(_("%s: failed to move data"), devname);
	if (f)
		fclose(f);
	free(buf);
	free(devname);
	free(typescript);

	return errsv;
}

static int write_changes(struct sfdisk *sf)
{
	int rc = 0;

	if (sf->noact)
		fdisk_info(sf->cxt, _("The partition table is unchanged (--no-act)."));
	else {
		rc = fdisk_write_disklabel(sf->cxt);
		if (rc == 0 && sf->movedata && sf->orig_pa)
			rc = move_partition_data(sf, sf->partno, sf->orig_pa);
		if (!rc) {
			fdisk_info(sf->cxt, _("\nThe partition table has been altered."));
			if (!sf->notell) {
				/* Let's wait a little bit. It's possible that our
				 * system is still busy with a previous re-read
				 * ioctl (on sfdisk start) or with another task
				 * related to the write to the device.
				 */
				xusleep(250000);
				fdisk_reread_partition_table(sf->cxt);
			}
		}
	}
	if (!rc)
		rc = fdisk_deassign_device(sf->cxt,
				sf->noact || sf->notell);	/* no-sync */
	return rc;
}

/*
 * sfdisk --list [<device ..]
 */
static int command_list_partitions(struct sfdisk *sf, int argc, char **argv)
{
	int fail = 0;
	fdisk_enable_listonly(sf->cxt, 1);

	if (argc) {
		int i, ct = 0;

		for (i = 0; i < argc; i++) {
			if (ct)
				fputs("\n\n", stdout);
			if (print_device_pt(sf->cxt, argv[i], 1, sf->verify) != 0)
				fail++;
			ct++;
		}
	} else
		print_all_devices_pt(sf->cxt, sf->verify);

	return fail;
}

/*
 * sfdisk --list-free [<device ..]
 */
static int command_list_freespace(struct sfdisk *sf, int argc, char **argv)
{
	int fail = 0;
	fdisk_enable_listonly(sf->cxt, 1);

	if (argc) {
		int i, ct = 0;

		for (i = 0; i < argc; i++) {
			if (ct)
				fputs("\n\n", stdout);
			if (print_device_freespace(sf->cxt, argv[i], 1) != 0)
				fail++;
			ct++;
		}
	} else
		print_all_devices_freespace(sf->cxt);

	return fail;
}

/*
 * sfdisk --list-types
 */
static int command_list_types(struct sfdisk *sf)
{
	const struct fdisk_parttype *t;
	struct fdisk_label *lb;
	const char *name;
	size_t i = 0;
	int codes;

	assert(sf);
	assert(sf->cxt);

	name = sf->label ? sf->label : "dos";
	lb = fdisk_get_label(sf->cxt, name);
	if (!lb)
		errx(EXIT_FAILURE, _("unsupported label '%s'"), name);

	codes = fdisk_label_has_code_parttypes(lb);
	fputs(_("Id  Name\n\n"), stdout);

	while ((t = fdisk_label_get_parttype(lb, i++))) {
		if (codes)
			printf("%2x  %s\n", fdisk_parttype_get_code(t),
					   fdisk_parttype_get_name(t));
		else
			printf("%s  %s\n", fdisk_parttype_get_string(t),
					  fdisk_parttype_get_name(t));
	}

	return 0;
}

static int verify_device(struct sfdisk *sf, const char *devname)
{
	int rc = 1;

	fdisk_enable_listonly(sf->cxt, 1);

	if (fdisk_assign_device(sf->cxt, devname, 1)) {
		warn(_("cannot open %s"), devname);
		return 1;
	}

	color_scheme_enable("header", UL_COLOR_BOLD);
	fdisk_info(sf->cxt, "%s:", devname);
	color_disable();

	if (!fdisk_has_label(sf->cxt))
		fdisk_info(sf->cxt, _("unrecognized partition table type"));
	else
		rc = fdisk_verify_disklabel(sf->cxt);

	fdisk_deassign_device(sf->cxt, 1);
	return rc;
}

/*
 * sfdisk --verify [<device ..]
 */
static int command_verify(struct sfdisk *sf, int argc, char **argv)
{
	int nfails = 0, ct = 0;

	if (argc) {
		int i;
		for (i = 0; i < argc; i++) {
			if (i)
				fdisk_info(sf->cxt, " ");
			if (verify_device(sf, argv[i]) < 0)
				nfails++;
		}
	} else {
		FILE *f = NULL;
		char *dev;

		while ((dev = next_proc_partition(&f))) {
			if (ct)
				fdisk_info(sf->cxt, " ");
			if (verify_device(sf, dev) < 0)
				nfails++;
			free(dev);
			ct++;
		}
	}

	return nfails;
}

static int get_size(const char *dev, int silent, uintmax_t *sz)
{
	int fd, rc = 0;

	fd = open(dev, O_RDONLY);
	if (fd < 0) {
		if (!silent)
			warn(_("cannot open %s"), dev);
		return -errno;
	}

	if (blkdev_get_sectors(fd, (unsigned long long *) sz) == -1) {
		if (!silent)
			warn(_("Cannot get size of %s"), dev);
		rc = -errno;
	}

	close(fd);
	return rc;
}

/*
 * sfdisk --show-size [<device ..]
 *
 * (silly, but just for backward compatibility)
 */
static int command_show_size(struct sfdisk *sf __attribute__((__unused__)),
			     int argc, char **argv)
{
	uintmax_t sz;

	if (argc) {
		int i;
		for (i = 0; i < argc; i++) {
			if (get_size(argv[i], 0, &sz) == 0)
				printf("%ju\n", sz / 2);
		}
	} else {
		FILE *f = NULL;
		uintmax_t total = 0;
		char *dev;

		while ((dev = next_proc_partition(&f))) {
			if (get_size(dev, 1, &sz) == 0) {
				printf("%s: %9ju\n", dev, sz / 2);
				total += sz / 2;
			}
			free(dev);
		}
		if (total)
			printf(_("total: %ju blocks\n"), total);
	}

	return 0;
}

static int print_geom(struct sfdisk *sf, const char *devname)
{
	fdisk_enable_listonly(sf->cxt, 1);

	if (fdisk_assign_device(sf->cxt, devname, 1)) {
		warn(_("cannot open %s"), devname);
		return 1;
	}

	fdisk_info(sf->cxt, "%s: %ju cylinders, %ju heads, %ju sectors/track",
			devname,
			(uintmax_t) fdisk_get_geom_cylinders(sf->cxt),
			(uintmax_t) fdisk_get_geom_heads(sf->cxt),
			(uintmax_t) fdisk_get_geom_sectors(sf->cxt));

	fdisk_deassign_device(sf->cxt, 1);
	return 0;
}

/*
 * sfdisk --show-geometry [<device ..]
 */
static int command_show_geometry(struct sfdisk *sf, int argc, char **argv)
{
	int nfails = 0;

	if (argc) {
		int i;
		for (i = 0; i < argc; i++) {
			if (print_geom(sf, argv[i]) < 0)
				nfails++;
		}
	} else {
		FILE *f = NULL;
		char *dev;

		while ((dev = next_proc_partition(&f))) {
			if (print_geom(sf, dev) < 0)
				nfails++;
			free(dev);
		}
	}

	return nfails;
}

/*
 * sfdisk --activate <device> [<partno> ...]
 */
static int command_activate(struct sfdisk *sf, int argc, char **argv)
{
	int rc, nparts, i, listonly;
	struct fdisk_partition *pa = NULL;
	const char *devname = NULL;

	if (argc < 1)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	/*  --activate <device> */
	listonly = argc == 1;

	rc = fdisk_assign_device(sf->cxt, devname, listonly);
	if (rc)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	if (fdisk_is_label(sf->cxt, GPT)) {
		/* Switch from GPT to PMBR */
		sf->cxt = fdisk_new_nested_context(sf->cxt, "dos");
		if (!sf->cxt)
			err(EXIT_FAILURE, _("cannot switch to PMBR"));
	} else if (!fdisk_is_label(sf->cxt, DOS))
		errx(EXIT_FAILURE, _("toggle boot flags is supported for MBR or PMBR only"));

	if (!listonly && sf->backup)
		backup_partition_table(sf, devname);

	nparts = fdisk_get_npartitions(sf->cxt);
	for (i = 0; i < nparts; i++) {
		char *data = NULL;

		/* note that fdisk_get_partition() reuses the @pa pointer, you
		 * don't have to (re)allocate it */
		if (fdisk_get_partition(sf->cxt, i, &pa) != 0)
			continue;

		/* sfdisk --activate  list bootable partitions */
		if (listonly) {
			if (!fdisk_partition_is_bootable(pa))
				continue;
			if (fdisk_partition_to_string(pa, sf->cxt,
						FDISK_FIELD_DEVICE, &data) == 0) {
				printf("%s\n", data);
				free(data);
			}

		/* deactivate all active partitions */
		} else if (fdisk_partition_is_bootable(pa))
			fdisk_toggle_partition_flag(sf->cxt, i, DOS_FLAG_ACTIVE);
	}

	/* sfdisk --activate <partno> [..] */
	for (i = 1; i < argc; i++) {
		int n;

		if (i == 1 && strcmp(argv[1], "-") == 0)
			break;
		n = strtou32_or_err(argv[i], _("failed to parse partition number"));

		rc = fdisk_toggle_partition_flag(sf->cxt, n - 1, DOS_FLAG_ACTIVE);
		if (rc)
			errx(EXIT_FAILURE,
				_("%s: partition %d: failed to toggle bootable flag"),
				devname, i + 1);
	}

	fdisk_unref_partition(pa);

	if (listonly)
		rc = fdisk_deassign_device(sf->cxt, 1);
	else
		rc = write_changes(sf);
	return rc;
}

/*
 * sfdisk --delete <device> [<partno> ...]
 */
static int command_delete(struct sfdisk *sf, int argc, char **argv)
{
	size_t i;
	const char *devname = NULL;

	if (argc < 1)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	if (fdisk_assign_device(sf->cxt, devname, 0) != 0)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	if (sf->backup)
		backup_partition_table(sf, devname);

	/* delete all */
	if (argc == 1) {
		size_t nparts = fdisk_get_npartitions(sf->cxt);
		for (i = 0; i < nparts; i++) {
			if (fdisk_is_partition_used(sf->cxt, i) &&
			    fdisk_delete_partition(sf->cxt, i) != 0)
				errx(EXIT_FAILURE, _("%s: partition %zu: failed to delete"), devname, i + 1);
		}
	/* delete specified */
	} else {
		for (i = 1; i < (size_t) argc; i++) {
			size_t n = strtou32_or_err(argv[i], _("failed to parse partition number"));

			if (fdisk_delete_partition(sf->cxt, n - 1) != 0)
				errx(EXIT_FAILURE, _("%s: partition %zu: failed to delete"), devname, n);
		}
	}

	return write_changes(sf);
}

/*
 * sfdisk --reorder <device>
 */
static int command_reorder(struct sfdisk *sf, int argc, char **argv)
{
	const char *devname = NULL;
	int rc;

	if (argc)
		devname = argv[0];
	if (!devname)
		errx(EXIT_FAILURE, _("no disk device specified"));

	rc = fdisk_assign_device(sf->cxt, devname, 0);	/* read-write */
	if (rc)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	if (sf->backup)
		backup_partition_table(sf, devname);

	if (fdisk_reorder_partitions(sf->cxt) == 1)	/* unchanged */
		rc = fdisk_deassign_device(sf->cxt, 1);
	else
		rc = write_changes(sf);

	return rc;
}


/*
 * sfdisk --dump <device>
 */
static int command_dump(struct sfdisk *sf, int argc, char **argv)
{
	const char *devname = NULL;
	struct fdisk_script *dp;
	int rc;

	if (argc)
		devname = argv[0];
	if (!devname)
		errx(EXIT_FAILURE, _("no disk device specified"));

	rc = fdisk_assign_device(sf->cxt, devname, 1);	/* read-only */
	if (rc)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	if (!fdisk_has_label(sf->cxt))
		errx(EXIT_FAILURE, _("%s: does not contain a recognized partition table"), devname);

	dp = fdisk_new_script(sf->cxt);
	if (!dp)
		err(EXIT_FAILURE, _("failed to allocate dump struct"));

	rc = fdisk_script_read_context(dp, NULL);
	if (rc)
		errx(EXIT_FAILURE, _("%s: failed to dump partition table"), devname);

	if (sf->json)
		fdisk_script_enable_json(dp, 1);
	fdisk_script_write_file(dp, stdout);

	fdisk_unref_script(dp);
	fdisk_deassign_device(sf->cxt, 1);		/* no-sync() */
	return 0;
}

static void assign_device_partition(struct sfdisk *sf,
				const char *devname,
				size_t partno,
				int rdonly)
{
	int rc;
	size_t n;
	struct fdisk_label *lb = NULL;

	assert(sf);
	assert(devname);

	/* read-only when a new <type> undefined */
	rc = fdisk_assign_device(sf->cxt, devname, rdonly);
	if (rc)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	lb = fdisk_get_label(sf->cxt, NULL);
	if (!lb)
		errx(EXIT_FAILURE, _("%s: no partition table found"), devname);

	n = fdisk_get_npartitions(sf->cxt);
	if (partno > n)
		errx(EXIT_FAILURE, _("%s: partition %zu: partition table contains "
				     "only %zu partitions"), devname, partno, n);
	if (!fdisk_is_partition_used(sf->cxt, partno - 1))
		errx(EXIT_FAILURE, _("%s: partition %zu: partition is unused"),
				devname, partno);
}

/*
 * sfdisk --part-type <device> <partno> [<type>]
 */
static int command_parttype(struct sfdisk *sf, int argc, char **argv)
{
	size_t partno;
	struct fdisk_parttype *type = NULL;
	struct fdisk_label *lb;
	const char *devname = NULL, *typestr = NULL;

	if (!argc)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	if (argc < 2)
		errx(EXIT_FAILURE, _("no partition number specified"));
	partno = strtou32_or_err(argv[1], _("failed to parse partition number"));

	if (argc == 3)
		typestr = argv[2];
	else if (argc > 3)
		errx(EXIT_FAILURE, _("unexpected arguments"));

	/* read-only when a new <type> undefined */
	assign_device_partition(sf, devname, partno, !typestr);

	lb = fdisk_get_label(sf->cxt, NULL);

	/* print partition type */
	if (!typestr) {
		const struct fdisk_parttype *t = NULL;
		struct fdisk_partition *pa = NULL;

		if (fdisk_get_partition(sf->cxt, partno - 1, &pa) == 0)
			t = fdisk_partition_get_type(pa);
		if (!t)
			errx(EXIT_FAILURE, _("%s: partition %zu: failed to get partition type"),
						devname, partno);

		if (fdisk_label_has_code_parttypes(lb))
			printf("%2x\n", fdisk_parttype_get_code(t));
		else
			printf("%s\n", fdisk_parttype_get_string(t));

		fdisk_unref_partition(pa);
		fdisk_deassign_device(sf->cxt, 1);
		return 0;
	}

	if (sf->backup)
		backup_partition_table(sf, devname);

	/* parse <type> and apply to PT */
	type = fdisk_label_parse_parttype(lb, typestr);
	if (!type)
		errx(EXIT_FAILURE, _("failed to parse %s partition type '%s'"),
				fdisk_label_get_name(lb), typestr);

	else if (fdisk_set_partition_type(sf->cxt, partno - 1, type) != 0)
		errx(EXIT_FAILURE, _("%s: partition %zu: failed to set partition type"),
						devname, partno);
	fdisk_unref_parttype(type);
	return write_changes(sf);
}

/*
 * sfdisk --part-uuid <device> <partno> [<uuid>]
 */
static int command_partuuid(struct sfdisk *sf, int argc, char **argv)
{
	size_t partno;
	struct fdisk_partition *pa = NULL;
	const char *devname = NULL, *uuid = NULL;

	if (!argc)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	if (argc < 2)
		errx(EXIT_FAILURE, _("no partition number specified"));
	partno = strtou32_or_err(argv[1], _("failed to parse partition number"));

	if (argc == 3)
		uuid = argv[2];
	else if (argc > 3)
		errx(EXIT_FAILURE, _("unexpected arguments"));

	/* read-only if uuid not given */
	assign_device_partition(sf, devname, partno, !uuid);

	/* print partition uuid */
	if (!uuid) {
		const char *str = NULL;

		if (fdisk_get_partition(sf->cxt, partno - 1, &pa) == 0)
			str = fdisk_partition_get_uuid(pa);
		if (!str)
			errx(EXIT_FAILURE, _("%s: partition %zu: failed to get partition UUID"),
						devname, partno);
		printf("%s\n", str);
		fdisk_unref_partition(pa);
		fdisk_deassign_device(sf->cxt, 1);
		return 0;
	}

	if (sf->backup)
		backup_partition_table(sf, devname);

	pa = fdisk_new_partition();
	if (!pa)
		err(EXIT_FAILURE, _("failed to allocate partition object"));

	if (fdisk_partition_set_uuid(pa, uuid) != 0 ||
	    fdisk_set_partition(sf->cxt, partno - 1, pa) != 0)
		errx(EXIT_FAILURE, _("%s: partition %zu: failed to set partition UUID"),
						devname, partno);
	fdisk_unref_partition(pa);
	return write_changes(sf);
}

/*
 * sfdisk --part-label <device> <partno> [<label>]
 */
static int command_partlabel(struct sfdisk *sf, int argc, char **argv)
{
	size_t partno;
	struct fdisk_partition *pa = NULL;
	const char *devname = NULL, *name = NULL;

	if (!argc)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	if (argc < 2)
		errx(EXIT_FAILURE, _("no partition number specified"));
	partno = strtou32_or_err(argv[1], _("failed to parse partition number"));

	if (argc == 3)
		name = argv[2];
	else if (argc > 3)
		errx(EXIT_FAILURE, _("unexpected arguments"));

	/* read-only if name not given */
	assign_device_partition(sf, devname, partno, !name);

	/* print partition name */
	if (!name) {
		const char *str = NULL;

		if (fdisk_get_partition(sf->cxt, partno - 1, &pa) == 0)
			str = fdisk_partition_get_name(pa);
		if (!str)
			errx(EXIT_FAILURE, _("%s: partition %zu: failed to get partition name"),
						devname, partno);
		printf("%s\n", str);
		fdisk_unref_partition(pa);
		fdisk_deassign_device(sf->cxt, 1);
		return 0;
	}

	if (sf->backup)
		backup_partition_table(sf, devname);

	pa = fdisk_new_partition();
	if (!pa)
		err(EXIT_FAILURE, _("failed to allocate partition object"));

	if (fdisk_partition_set_name(pa, name) != 0 ||
	    fdisk_set_partition(sf->cxt, partno - 1, pa) != 0)
		errx(EXIT_FAILURE, _("%s: partition %zu: failed to set partition name"),
				devname, partno);

	fdisk_unref_partition(pa);
	return write_changes(sf);
}

/*
 * sfdisk --part-attrs <device> <partno> [<attrs>]
 */
static int command_partattrs(struct sfdisk *sf, int argc, char **argv)
{
	size_t partno;
	struct fdisk_partition *pa = NULL;
	const char *devname = NULL, *attrs = NULL;

	if (!argc)
		errx(EXIT_FAILURE, _("no disk device specified"));
	devname = argv[0];

	if (argc < 2)
		errx(EXIT_FAILURE, _("no partition number specified"));
	partno = strtou32_or_err(argv[1], _("failed to parse partition number"));

	if (argc == 3)
		attrs = argv[2];
	else if (argc > 3)
		errx(EXIT_FAILURE, _("unexpected arguments"));

	/* read-only if name not given */
	assign_device_partition(sf, devname, partno, !attrs);

	/* print partition name */
	if (!attrs) {
		const char *str = NULL;

		if (fdisk_get_partition(sf->cxt, partno - 1, &pa) == 0)
			str = fdisk_partition_get_attrs(pa);
		if (str)
			printf("%s\n", str);
		fdisk_unref_partition(pa);
		fdisk_deassign_device(sf->cxt, 1);
		return 0;
	}

	if (sf->backup)
		backup_partition_table(sf, devname);

	pa = fdisk_new_partition();
	if (!pa)
		err(EXIT_FAILURE, _("failed to allocate partition object"));

	if (fdisk_partition_set_attrs(pa, attrs) != 0 ||
	    fdisk_set_partition(sf->cxt, partno - 1, pa) != 0)
		errx(EXIT_FAILURE, _("%s: partition %zu: failed to set partition attributes"),
				devname, partno);

	fdisk_unref_partition(pa);
	return write_changes(sf);
}

static void sfdisk_print_partition(struct sfdisk *sf, size_t n)
{
	struct fdisk_partition *pa = NULL;
	char *data;

	assert(sf);

	if (sf->quiet)
		return;
	if (fdisk_get_partition(sf->cxt, n, &pa) != 0)
		return;

	fdisk_partition_to_string(pa, sf->cxt, FDISK_FIELD_DEVICE, &data);
	printf("%12s : ", data);

	fdisk_partition_to_string(pa, sf->cxt, FDISK_FIELD_START, &data);
	printf("%12s ", data);

	fdisk_partition_to_string(pa, sf->cxt, FDISK_FIELD_END, &data);
	printf("%12s ", data);

	fdisk_partition_to_string(pa, sf->cxt, FDISK_FIELD_SIZE, &data);
	printf("(%s) ", data);

	fdisk_partition_to_string(pa, sf->cxt, FDISK_FIELD_TYPE, &data);
	printf("%s\n", data);

	fdisk_unref_partition(pa);
}

static void command_fdisk_help(void)
{
	fputs(_("\nHelp:\n"), stdout);

	fputc('\n', stdout);
	color_scheme_enable("help-title", UL_COLOR_BOLD);
	fputs(_(" Commands:\n"), stdout);
	color_disable();
	fputs(_("   write    write table to disk and exit\n"), stdout);
	fputs(_("   quit     show new situation and wait for user's feedback before write\n"), stdout);
	fputs(_("   abort    exit sfdisk shell\n"), stdout);
	fputs(_("   print    display the partition table\n"), stdout);
	fputs(_("   help     show this help text\n"), stdout);
	fputc('\n', stdout);
	fputs(_("   Ctrl-D   the same as 'quit'\n"), stdout);

	fputc('\n', stdout);
	color_scheme_enable("help-title", UL_COLOR_BOLD);
	fputs(_(" Input format:\n"), stdout);
	color_disable();
	fputs(_("   <start>, <size>, <type>, <bootable>\n"), stdout);

	fputc('\n', stdout);
	fputs(_("   <start>  Beginning of the partition in sectors, or bytes if\n"
		"            specified in the format <number>{K,M,G,T,P,E,Z,Y}.\n"
		"            The default is the first free space.\n"), stdout);

	fputc('\n', stdout);
	fputs(_("   <size>   Size of the partition in sectors, or bytes if\n"
		"            specified in the format <number>{K,M,G,T,P,E,Z,Y}.\n"
		"            The default is all available space.\n"), stdout);

	fputc('\n', stdout);
	fputs(_("   <type>   The partition type.  Default is a Linux data partition.\n"), stdout);
	fputs(_("            MBR: hex or L,S,E,X,U,R,V shortcuts.\n"), stdout);
	fputs(_("            GPT: UUID or L,S,H,U,R,V shortcuts.\n"), stdout);

	fputc('\n', stdout);
	fputs(_("   <bootable>  Use '*' to mark an MBR partition as bootable.\n"), stdout);

	fputc('\n', stdout);
	color_scheme_enable("help-title", UL_COLOR_BOLD);
	fputs(_(" Example:\n"), stdout);
	color_disable();
	fputs(_("   , 4G     Creates a 4GiB partition at default start offset.\n"), stdout);
	fputc('\n', stdout);
}

enum {
	SFDISK_DONE_NONE = 0,
	SFDISK_DONE_EOF,
	SFDISK_DONE_ABORT,
	SFDISK_DONE_WRITE,
	SFDISK_DONE_ASK
};

/* returns: 0 on success, <0 on error, 1 successfully stop sfdisk */
static int loop_control_commands(struct sfdisk *sf,
				 struct fdisk_script *dp,
				 char *buf)
{
	const char *p = skip_blank(buf);
	int rc = SFDISK_DONE_NONE;

	if (strcmp(p, "print") == 0)
		list_disklabel(sf->cxt);
	else if (strcmp(p, "help") == 0)
		command_fdisk_help();
	else if (strcmp(p, "quit") == 0)
		rc = SFDISK_DONE_ASK;
	else if (strcmp(p, "write") == 0)
		rc = SFDISK_DONE_WRITE;
	else if (strcmp(p, "abort") == 0)
		rc = SFDISK_DONE_ABORT;
	else {
		if (sf->interactive)
			fdisk_warnx(sf->cxt, _("unsupported command"));
		else {
			fdisk_warnx(sf->cxt, _("line %d: unsupported command"),
					fdisk_script_get_nlines(dp));
			rc = -EINVAL;
		}
	}
	return rc;
}

static int has_container(struct sfdisk *sf)
{
	size_t i, nparts;
	struct fdisk_partition *pa = NULL;

	if (sf->container)
		return sf->container;

	nparts = fdisk_get_npartitions(sf->cxt);
	for (i = 0; i < nparts; i++) {
		if (fdisk_get_partition(sf->cxt, i, &pa) != 0)
			continue;
		if (fdisk_partition_is_container(pa)) {
			sf->container = 1;
			break;
		}
	}

	fdisk_unref_partition(pa);
	return sf->container;
}

static size_t last_pt_partno(struct sfdisk *sf)
{
	size_t i, nparts, partno = 0;
	struct fdisk_partition *pa = NULL;


	nparts = fdisk_get_npartitions(sf->cxt);
	for (i = 0; i < nparts; i++) {
		size_t x;

		if (fdisk_get_partition(sf->cxt, i, &pa) != 0 ||
		    !fdisk_partition_is_used(pa))
			continue;
		x = fdisk_partition_get_partno(pa);
		if (x > partno)
			partno = x;
	}

	fdisk_unref_partition(pa);
	return partno;
}

#ifdef HAVE_LIBREADLINE
static char *sfdisk_fgets(struct fdisk_script *dp,
			  char *buf, size_t bufsz, FILE *f)
{
	struct sfdisk *sf = (struct sfdisk *) fdisk_script_get_userdata(dp);

	assert(dp);
	assert(buf);
	assert(bufsz > 2);

	if (sf->interactive) {
		char *p = readline(sf->prompt);
		size_t len;

		if (!p)
			return NULL;
		len = strlen(p);
		if (len > bufsz - 2)
			len = bufsz - 2;

		memcpy(buf, p, len);
		buf[len] = '\n';		/* append \n to be compatible with libc fgetc() */
		buf[len + 1] = '\0';
		free(p);
		fflush(stdout);
		return buf;
	}
	return fgets(buf, bufsz, f);
}
#endif

static int ignore_partition(struct fdisk_partition *pa)
{
	/* incomplete partition setting */
	if (!fdisk_partition_has_start(pa) && !fdisk_partition_start_is_default(pa))
		return 1;
	if (!fdisk_partition_has_size(pa) && !fdisk_partition_end_is_default(pa))
		return 1;

	/* probably dump from old sfdisk with start=0 size=0 */
	if (fdisk_partition_has_start(pa) && fdisk_partition_get_start(pa) == 0 &&
	    fdisk_partition_has_size(pa) && fdisk_partition_get_size(pa) == 0)
		return 1;

	return 0;
}

static void follow_wipe_mode(struct sfdisk *sf)
{
	int dowipe = sf->wipemode == WIPEMODE_ALWAYS ? 1 : 0;

	if (sf->interactive && sf->wipemode == WIPEMODE_AUTO)
		dowipe = 1;	/* do it in interactive mode */

	if (fdisk_is_ptcollision(sf->cxt) && sf->wipemode != WIPEMODE_NEVER)
		dowipe = 1;	/* always wipe old PT */

	fdisk_enable_wipe(sf->cxt, dowipe);
	if (sf->quiet)
		return;

	if (dowipe) {
		if (!fdisk_is_ptcollision(sf->cxt)) {
			fdisk_info(sf->cxt, _("The old %s signature will be removed by a write command."),
					fdisk_get_collision(sf->cxt));
			fputc('\n', stderr);
		}
	} else {
		fdisk_warnx(sf->cxt, _(
			"The old %s signature may remain on the device. "
			"It is recommended to wipe the device with wipefs(8) or "
			"sfdisk --wipe, in order to avoid possible collisions."),
			fdisk_get_collision(sf->cxt));
		fputc('\n', stderr);
	}
}

static int wipe_partition(struct sfdisk *sf, size_t partno)
{
	int rc, yes = 0;
	char *fstype = NULL;
	struct fdisk_partition *tmp = NULL;

	DBG(MISC, ul_debug("checking for signature"));

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

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

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

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

	if (yes) {
		fdisk_info(sf->cxt, _("The signature will be removed by a write command."));
		rc = fdisk_wipe_partition(sf->cxt, partno, TRUE);
	}
done:
	fdisk_unref_partition(tmp);
	free(fstype);
	DBG(MISC, ul_debug("partition wipe check end [rc=%d]", rc));
	return rc;
}

static void refresh_prompt_buffer(struct sfdisk *sf, const char *devname,
		                  size_t next_partno, int created)
{
	if (created) {
		char *partname = fdisk_partname(devname, next_partno + 1);
		if (!partname)
			err(EXIT_FAILURE, _("failed to allocate partition name"));

		if (!sf->prompt || !startswith(sf->prompt, partname)) {
			free(sf->prompt);
			xasprintf(&sf->prompt,"%s: ", partname);
		}
		free(partname);
	} else if (!sf->prompt || !startswith(sf->prompt, SFDISK_PROMPT)) {
		free(sf->prompt);
		sf->prompt = xstrdup(SFDISK_PROMPT);
	}
}

/*
 * sfdisk <device> [[-N] <partno>]
 *
 * Note that the option -N is there for backward compatibility only.
 */
static int command_fdisk(struct sfdisk *sf, int argc, char **argv)
{
	int rc = 0, partno = sf->partno, created = 0, unused = 0;
	struct fdisk_script *dp;
	struct fdisk_table *tb = NULL;
	const char *devname = NULL, *label;
	char buf[BUFSIZ];
	size_t next_partno = (size_t) -1;

	if (argc)
		devname = argv[0];
	if (partno < 0 && argc > 1)
		partno = strtou32_or_err(argv[1],
				_("failed to parse partition number"));
	if (!devname)
		errx(EXIT_FAILURE, _("no disk device specified"));

	rc = fdisk_assign_device(sf->cxt, devname, 0);
	if (rc)
		err(EXIT_FAILURE, _("cannot open %s"), devname);

	dp = fdisk_new_script(sf->cxt);
	if (!dp)
		err(EXIT_FAILURE, _("failed to allocate script handler"));
	fdisk_set_script(sf->cxt, dp);
#ifdef HAVE_LIBREADLINE
	fdisk_script_set_fgets(dp, sfdisk_fgets);
#endif
	fdisk_script_set_userdata(dp, (void *) sf);

	/*
	 * Don't create a new disklabel when [-N] <partno> specified. In this
	 * case reuse already specified disklabel. Let's check that the disk
	 * really contains the partition.
	 */
	if (partno >= 0) {
		size_t n;

		if (!fdisk_has_label(sf->cxt))
			errx(EXIT_FAILURE, _("%s: cannot modify partition %d: "
					     "no partition table was found"),
					devname, partno + 1);
		n = fdisk_get_npartitions(sf->cxt);
		if ((size_t) partno > n)
			errx(EXIT_FAILURE, _("%s: cannot modify partition %d: "
					     "partition table contains only %zu "
					     "partitions"),
					devname, partno + 1, n);

		if (!fdisk_is_partition_used(sf->cxt, partno)) {
			fdisk_warnx(sf->cxt, _("warning: %s: partition %d is not defined yet"),
					devname, partno + 1);
			unused = 1;
		}
		created = 1;
		next_partno = partno;

		if (sf->movedata)
			sf->orig_pa = get_partition(sf->cxt, partno);
	}

	if (sf->append) {
		created = 1;
		next_partno = last_pt_partno(sf) + 1;
	}

	if (!sf->quiet && sf->interactive) {
		color_scheme_enable("welcome", UL_COLOR_GREEN);
		fdisk_info(sf->cxt, _("\nWelcome to sfdisk (%s)."), PACKAGE_STRING);
		color_disable();
		fdisk_info(sf->cxt, _("Changes will remain in memory only, until you decide to write them.\n"
				  "Be careful before using the write command.\n"));
	}

	if (!sf->noact && !sf->noreread) {
		if (!sf->quiet)
			fputs(_("Checking that no-one is using this disk right now ..."), stdout);
		if (fdisk_device_is_used(sf->cxt)) {
			if (!sf->quiet)
				fputs(_(" FAILED\n\n"), stdout);

			fdisk_warnx(sf->cxt, _(
			"This disk is currently in use - repartitioning is probably a bad idea.\n"
			"Umount all file systems, and swapoff all swap partitions on this disk.\n"
			"Use the --no-reread flag to suppress this check.\n"));

			if (!sf->force)
				errx(EXIT_FAILURE, _("Use the --force flag to overrule all checks."));
		} else if (!sf->quiet)
			fputs(_(" OK\n\n"), stdout);
	}

	if (fdisk_get_collision(sf->cxt))
		follow_wipe_mode(sf);

	if (sf->backup)
		backup_partition_table(sf, devname);

	if (!sf->quiet) {
		list_disk_geometry(sf->cxt);
		if (fdisk_has_label(sf->cxt)) {
			fdisk_info(sf->cxt, _("\nOld situation:"));
			list_disklabel(sf->cxt);
		}
	}

	if (sf->label)
		label = sf->label;
	else if (fdisk_has_label(sf->cxt))
		label = fdisk_label_get_name(fdisk_get_label(sf->cxt, NULL));
	else
		label = "dos";	/* just for backward compatibility */

	fdisk_script_set_header(dp, "label", label);


	if (!sf->quiet && sf->interactive) {
		if (!fdisk_has_label(sf->cxt) && !sf->label)
			fdisk_info(sf->cxt,
				_("\nsfdisk is going to create a new '%s' disk label.\n"
				  "Use 'label: <name>' before you define a first partition\n"
				  "to override the default."), label);
		fdisk_info(sf->cxt, _("\nType 'help' to get more information.\n"));
	} else if (!sf->quiet)
		fputc('\n', stdout);

	tb = fdisk_script_get_table(dp);
	assert(tb);

	do {
		size_t nparts;

		DBG(PARSE, ul_debug("<---next-line--->"));
		if (next_partno == (size_t) -1)
			next_partno = fdisk_table_get_nents(tb);

		if (created
		    && partno < 0
		    && next_partno == fdisk_get_npartitions(sf->cxt)
		    && !has_container(sf)) {
			fdisk_info(sf->cxt, _("All partitions used."));
			rc = SFDISK_DONE_ASK;
			break;
		}

		refresh_prompt_buffer(sf, devname, next_partno, created);


		if (sf->prompt && (sf->interactive || !sf->quiet)) {
#ifndef HAVE_LIBREADLINE
			fputs(sf->prompt, stdout);
#else
			if (!sf->interactive)
				fputs(sf->prompt, stdout);
#endif
		}

		rc = fdisk_script_read_line(dp, stdin, buf, sizeof(buf));
		if (rc < 0) {
			DBG(PARSE, ul_debug("script parsing failed, trying sfdisk specific commands"));
			buf[sizeof(buf) - 1] = '\0';
			rc = loop_control_commands(sf, dp, buf);
			if (rc)
				break;
			continue;
		} else if (rc == 1) {
			rc = SFDISK_DONE_EOF;
			if (!sf->quiet)
				fputs(_("Done.\n"), stdout);
			break;
		}

		nparts = fdisk_table_get_nents(tb);
		if (nparts) {
			size_t cur_partno;
			struct fdisk_partition *pa = fdisk_table_get_partition(tb, nparts - 1);

			assert(pa);

			if (ignore_partition(pa)) {
				fdisk_info(sf->cxt, _("Ignoring partition."));
				next_partno++;
				continue;
			}
			if (!created) {		/* create a new disklabel */
				rc = fdisk_apply_script_headers(sf->cxt, dp);
				created = !rc;
				if (rc)
					fdisk_warnx(sf->cxt, _(
					  "Failed to apply script headers, "
					  "disk label not created."));

				if (rc == 0 && fdisk_get_collision(sf->cxt))
					follow_wipe_mode(sf);
			}
			if (!rc && partno >= 0) {	/* -N <partno>, modify partition */
				rc = fdisk_set_partition(sf->cxt, partno, pa);
				rc = rc == 0 ? SFDISK_DONE_ASK : SFDISK_DONE_ABORT;
				break;
			} else if (!rc) {		/* add partition */
				if (!sf->interactive && !sf->quiet &&
				    (!sf->prompt || startswith(sf->prompt, SFDISK_PROMPT))) {
					refresh_prompt_buffer(sf, devname, next_partno, created);
					fputs(sf->prompt, stdout);
				}
				rc = fdisk_add_partition(sf->cxt, pa, &cur_partno);
				if (rc) {
					errno = -rc;
					fdisk_warn(sf->cxt, _("Failed to add #%d partition"), next_partno + 1);
				}
			}

			/* wipe partition on success
			 *
			 * Note that unused=1 means -N <partno> for unused,
			 * otherwise we wipe only newly created partitions.
			 */
			if (rc == 0 && (unused || partno < 0)) {
				rc = wipe_partition(sf, unused ? (size_t) partno : cur_partno);
				if (rc)
					errno = -rc;
			}

			if (!rc) {
				/* success print result */
				if (sf->interactive)
					sfdisk_print_partition(sf, cur_partno);
				next_partno = cur_partno + 1;
			} else if (pa)		/* error, drop partition from script */
				fdisk_table_remove_partition(tb, pa);
		} else
			fdisk_info(sf->cxt, _("Script header accepted."));

		if (rc && !sf->interactive) {
			rc =  SFDISK_DONE_ABORT;
			break;
		}
	} while (1);

	/* create empty disk label if label, but no partition specified */
	if ((rc == SFDISK_DONE_EOF || rc == SFDISK_DONE_WRITE) && created == 0
	    && fdisk_script_has_force_label(dp) == 1
	    && fdisk_table_get_nents(tb) == 0
	    && fdisk_script_get_header(dp, "label")) {

		int xrc = fdisk_apply_script_headers(sf->cxt, dp);
		created = !xrc;
		if (xrc) {
			fdisk_warnx(sf->cxt, _(
				  "Failed to apply script headers, "
				  "disk label not created."));
			rc = SFDISK_DONE_ABORT;
		}
	}

	if (!sf->quiet && rc != SFDISK_DONE_ABORT) {
		fdisk_info(sf->cxt, _("\nNew situation:"));
		list_disk_identifier(sf->cxt);
		list_disklabel(sf->cxt);
	}

	switch (rc) {
	case SFDISK_DONE_ASK:
	case SFDISK_DONE_EOF:
		if (sf->interactive) {
			int yes = 0;
			fdisk_ask_yesno(sf->cxt, _("Do you want to write this to disk?"), &yes);
			if (!yes) {
				fdisk_info(sf->cxt, _("Leaving."));
				rc = 0;
				break;
			}
		}
		/* fallthrough */
	case SFDISK_DONE_WRITE:
		rc = write_changes(sf);
		break;
	case SFDISK_DONE_ABORT:
	default:				/* rc < 0 on error */
		fdisk_info(sf->cxt, _("Leaving.\n"));
		break;
	}

	fdisk_unref_script(dp);
	return rc;
}

static void __attribute__((__noreturn__)) usage(void)
{
	FILE *out = stdout;
	fputs(USAGE_HEADER, out);

	fprintf(out,
	      _(" %1$s [options] <dev> [[-N] <part>]\n"
		" %1$s [options] <command>\n"), program_invocation_short_name);

	fputs(USAGE_SEPARATOR, out);
	fputs(_("Display or manipulate a disk partition table.\n"), out);

	fputs(USAGE_COMMANDS, out);
	fputs(_(" -A, --activate <dev> [<part> ...] list or set bootable (P)MBR partitions\n"), out);
	fputs(_(" -d, --dump <dev>                  dump partition table (usable for later input)\n"), out);
	fputs(_(" -J, --json <dev>                  dump partition table in JSON format\n"), out);
	fputs(_(" -g, --show-geometry [<dev> ...]   list geometry of all or specified devices\n"), out);
	fputs(_(" -l, --list [<dev> ...]            list partitions of each device\n"), out);
	fputs(_(" -F, --list-free [<dev> ...]       list unpartitioned free areas of each device\n"), out);
	fputs(_(" -r, --reorder <dev>               fix partitions order (by start offset)\n"), out);
	fputs(_(" -s, --show-size [<dev> ...]       list sizes of all or specified devices\n"), out);
	fputs(_(" -T, --list-types                  print the recognized types (see -X)\n"), out);
	fputs(_(" -V, --verify [<dev> ...]          test whether partitions seem correct\n"), out);
	fputs(_("     --delete <dev> [<part> ...]   delete all or specified partitions\n"), out);

	fputs(USAGE_SEPARATOR, out);
	fputs(_(" --part-label <dev> <part> [<str>] print or change partition label\n"), out);
	fputs(_(" --part-type <dev> <part> [<type>] print or change partition type\n"), out);
	fputs(_(" --part-uuid <dev> <part> [<uuid>] print or change partition uuid\n"), out);
	fputs(_(" --part-attrs <dev> <part> [<str>] print or change partition attributes\n"), out);

	fputs(USAGE_SEPARATOR, out);
	fputs(_(" <dev>                     device (usually disk) path\n"), out);
	fputs(_(" <part>                    partition number\n"), out);
	fputs(_(" <type>                    partition type, GUID for GPT, hex for MBR\n"), out);

	fputs(USAGE_OPTIONS, out);
	fputs(_(" -a, --append              append partitions to existing partition table\n"), out);
	fputs(_(" -b, --backup              backup partition table sectors (see -O)\n"), out);
	fputs(_("     --bytes               print SIZE in bytes rather than in human readable format\n"), out);
	fputs(_("     --move-data[=<typescript>] move partition data after relocation (requires -N)\n"), out);
	fputs(_(" -f, --force               disable all consistency checking\n"), out);
	fputs(_("     --color[=<when>]      colorize output (auto, always or never)\n"), out);
	fprintf(out,
	        "                             %s\n", USAGE_COLORS_DEFAULT);
	fputs(_(" -N, --partno <num>        specify partition number\n"), out);
	fputs(_(" -n, --no-act              do everything except write to device\n"), out);
	fputs(_("     --no-reread           do not check whether the device is in use\n"), out);
	fputs(_("     --no-tell-kernel      do not tell kernel about changes\n"), out);
	fputs(_(" -O, --backup-file <path>  override default backup file name\n"), out);
	fputs(_(" -o, --output <list>       output columns\n"), out);
	fputs(_(" -q, --quiet               suppress extra info messages\n"), out);
	fputs(_(" -w, --wipe <mode>         wipe signatures (auto, always or never)\n"), out);
	fputs(_(" -W, --wipe-partitions <mode>  wipe signatures from new partitions (auto, always or never)\n"), out);
	fputs(_(" -X, --label <name>        specify label type (dos, gpt, ...)\n"), out);
	fputs(_(" -Y, --label-nested <name> specify nested label type (dos, bsd)\n"), out);
	fputs(USAGE_SEPARATOR, out);
	fputs(_(" -G, --show-pt-geometry    deprecated, alias to --show-geometry\n"), out);
	fputs(_(" -L, --Linux               deprecated, only for backward compatibility\n"), out);
	fputs(_(" -u, --unit S              deprecated, only sector unit is supported\n"), out);

	fputs(USAGE_SEPARATOR, out);
	printf( " -h, --help                %s\n", USAGE_OPTSTR_HELP);
	printf( " -v, --version             %s\n", USAGE_OPTSTR_VERSION);

	list_available_columns(out);

	printf(USAGE_MAN_TAIL("sfdisk(8)"));
	exit(EXIT_SUCCESS);
}


int main(int argc, char *argv[])
{
	const char *outarg = NULL;
	int rc = -EINVAL, c, longidx = -1, bytes = 0;
	int colormode = UL_COLORMODE_UNDEF;
	struct sfdisk _sf = {
		.partno = -1,
		.wipemode = WIPEMODE_AUTO,
		.pwipemode = WIPEMODE_AUTO,
		.interactive = isatty(STDIN_FILENO) ? 1 : 0,
	}, *sf = &_sf;

	enum {
		OPT_CHANGE_ID = CHAR_MAX + 1,
		OPT_PRINT_ID,
		OPT_ID,
		OPT_NOREREAD,
		OPT_PARTUUID,
		OPT_PARTLABEL,
		OPT_PARTTYPE,
		OPT_PARTATTRS,
		OPT_BYTES,
		OPT_COLOR,
		OPT_MOVEDATA,
		OPT_DELETE,
		OPT_NOTELL
	};

	static const struct option longopts[] = {
		{ "activate",no_argument,	NULL, 'A' },
		{ "append",  no_argument,       NULL, 'a' },
		{ "backup",  no_argument,       NULL, 'b' },
		{ "backup-file", required_argument, NULL, 'O' },
		{ "bytes",   no_argument,	NULL, OPT_BYTES },
		{ "color",   optional_argument, NULL, OPT_COLOR },
		{ "delete",  no_argument,	NULL, OPT_DELETE },
		{ "dump",    no_argument,	NULL, 'd' },
		{ "help",    no_argument,       NULL, 'h' },
		{ "force",   no_argument,       NULL, 'f' },
		{ "json",    no_argument,	NULL, 'J' },
		{ "label",   required_argument, NULL, 'X' },
		{ "label-nested", required_argument, NULL, 'Y' },
		{ "list",    no_argument,       NULL, 'l' },
		{ "list-free", no_argument,     NULL, 'F' },
		{ "list-types", no_argument,	NULL, 'T' },
		{ "no-act",  no_argument,       NULL, 'n' },
		{ "no-reread", no_argument,     NULL, OPT_NOREREAD },
		{ "no-tell-kernel", no_argument, NULL, OPT_NOTELL },
		{ "move-data", optional_argument, NULL, OPT_MOVEDATA },
		{ "output",  required_argument, NULL, 'o' },
		{ "partno",  required_argument, NULL, 'N' },
		{ "reorder", no_argument,       NULL, 'r' },
		{ "show-geometry", no_argument, NULL, 'g' },
		{ "quiet",   no_argument,       NULL, 'q' },
		{ "verify",  no_argument,       NULL, 'V' },
		{ "version", no_argument,       NULL, 'v' },
		{ "wipe",    required_argument, NULL, 'w' },
		{ "wipe-partitions",    required_argument, NULL, 'W' },

		{ "part-uuid",  no_argument,    NULL, OPT_PARTUUID },
		{ "part-label", no_argument,    NULL, OPT_PARTLABEL },
		{ "part-type",  no_argument,    NULL, OPT_PARTTYPE },
		{ "part-attrs", no_argument,    NULL, OPT_PARTATTRS },

		{ "show-pt-geometry", no_argument, NULL, 'G' },		/* deprecated */
		{ "unit",    required_argument, NULL, 'u' },		/* deprecated */
		{ "Linux",   no_argument,       NULL, 'L' },		/* deprecated */
		{ "show-size", no_argument,	NULL, 's' },		/* deprecated */

		{ "change-id",no_argument,      NULL, OPT_CHANGE_ID },	/* deprecated */
		{ "id",      no_argument,       NULL, 'c' },		/* deprecated */
		{ "print-id",no_argument,       NULL, OPT_PRINT_ID },	/* deprecated */

		{ NULL, 0, NULL, 0 },
	};
	static const ul_excl_t excl[] = {	/* rows and cols in ASCII order */
		{ 's','u'},			/* --show-size --unit */
		{ 0 }
	};
	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;


	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	atexit(close_stdout);

	while ((c = getopt_long(argc, argv, "aAbcdfFgGhJlLo:O:nN:qrsTu:vVX:Y:w:W:",
					longopts, &longidx)) != -1) {

		err_exclusive_options(c, longopts, excl, excl_st);

		switch(c) {
		case 'A':
			sf->act = ACT_ACTIVATE;
			break;
		case 'a':
			sf->append = 1;
			break;
		case 'b':
			sf->backup = 1;
			break;
		case OPT_CHANGE_ID:
		case OPT_PRINT_ID:
		case OPT_ID:
			warnx(_("%s is deprecated in favour of --part-type"),
				longopts[longidx].name);
			sf->act = ACT_PARTTYPE;
			break;
		case 'c':
			warnx(_("--id is deprecated in favour of --part-type"));
			sf->act = ACT_PARTTYPE;
			break;
		case 'J':
			sf->json = 1;
			/* fallthrough */
		case 'd':
			sf->act = ACT_DUMP;
			break;
		case 'F':
			sf->act = ACT_LIST_FREE;
			break;
		case 'f':
			sf->force = 1;
			break;
		case 'G':
			warnx(_("--show-pt-geometry is no more implemented. Using --show-geometry."));
			/* fallthrough */
		case 'g':
			sf->act = ACT_SHOW_GEOM;
			break;
		case 'h':
			usage();
			break;
		case 'l':
			sf->act = ACT_LIST;
			break;
		case 'L':
			warnx(_("--Linux option is unnecessary and deprecated"));
			break;
		case 'o':
			outarg = optarg;
			break;
		case 'O':
			sf->backup = 1;
			sf->backup_file = optarg;
			break;
		case 'n':
			sf->noact = 1;
			break;
		case 'N':
			sf->partno = strtou32_or_err(optarg, _("failed to parse partition number")) - 1;
			break;
		case 'q':
			sf->quiet = 1;
			break;
		case 'r':
			sf->act = ACT_REORDER;
			break;
		case 's':
			sf->act = ACT_SHOW_SIZE;
			break;
		case 'T':
			sf->act = ACT_LIST_TYPES;
			break;
		case 'u':
			if (*optarg != 'S')
				errx(EXIT_FAILURE, _("unsupported unit '%c'"), *optarg);
			break;
		case 'v':
			printf(_("%s from %s\n"), program_invocation_short_name,
						  PACKAGE_STRING);
			return EXIT_SUCCESS;
		case 'V':
			sf->verify = 1;
			break;
		case 'w':
			sf->wipemode = wipemode_from_string(optarg);
			if (sf->wipemode < 0)
				errx(EXIT_FAILURE, _("unsupported wipe mode"));
			break;
		case 'W':
			sf->pwipemode = wipemode_from_string(optarg);
			if (sf->pwipemode < 0)
				errx(EXIT_FAILURE, _("unsupported wipe mode"));
			break;
		case 'X':
			sf->label = optarg;
			break;
		case 'Y':
			sf->label_nested = optarg;
			break;

		case OPT_PARTUUID:
			sf->act = ACT_PARTUUID;
			break;
		case OPT_PARTTYPE:
			sf->act = ACT_PARTTYPE;
			break;
		case OPT_PARTLABEL:
			sf->act = ACT_PARTLABEL;
			break;
		case OPT_PARTATTRS:
			sf->act = ACT_PARTATTRS;
			break;
		case OPT_NOREREAD:
			sf->noreread = 1;
			break;
		case OPT_BYTES:
			bytes = 1;
			break;
		case OPT_COLOR:
			colormode = UL_COLORMODE_AUTO;
			if (optarg)
				colormode = colormode_or_err(optarg,
						_("unsupported color mode"));
			break;
		case OPT_MOVEDATA:
			sf->movedata = 1;
			sf->move_typescript = optarg;
			break;
		case OPT_DELETE:
			sf->act = ACT_DELETE;
			break;
		case OPT_NOTELL:
			sf->notell = 1;
			break;
		default:
			errtryhelp(EXIT_FAILURE);
		}
	}

	colors_init(colormode, "sfdisk");

	sfdisk_init(sf);
	if (bytes)
		fdisk_set_size_unit(sf->cxt, FDISK_SIZEUNIT_BYTES);

	if (outarg)
		init_fields(NULL, outarg, NULL);

	if (sf->verify && !sf->act)
		sf->act = ACT_VERIFY;	/* --verify make be used with --list too */
	else if (!sf->act)
		sf->act = ACT_FDISK;	/* default */

	if (sf->movedata && !(sf->act == ACT_FDISK && sf->partno >= 0))
		errx(EXIT_FAILURE, _("--movedata requires -N"));

	switch (sf->act) {
	case ACT_ACTIVATE:
		rc = command_activate(sf, argc - optind, argv + optind);
		break;

	case ACT_DELETE:
		rc = command_delete(sf, argc - optind, argv + optind);
		break;

	case ACT_LIST:
		rc = command_list_partitions(sf, argc - optind, argv + optind);
		break;

	case ACT_LIST_TYPES:
		rc = command_list_types(sf);
		break;

	case ACT_LIST_FREE:
		rc = command_list_freespace(sf, argc - optind, argv + optind);
		break;

	case ACT_FDISK:
		rc = command_fdisk(sf, argc - optind, argv + optind);
		break;

	case ACT_DUMP:
		rc = command_dump(sf, argc - optind, argv + optind);
		break;

	case ACT_SHOW_SIZE:
		rc = command_show_size(sf, argc - optind, argv + optind);
		break;

	case ACT_SHOW_GEOM:
		rc = command_show_geometry(sf, argc - optind, argv + optind);
		break;

	case ACT_VERIFY:
		rc = command_verify(sf, argc - optind, argv + optind);
		break;

	case ACT_PARTTYPE:
		rc = command_parttype(sf, argc - optind, argv + optind);
		break;

	case ACT_PARTUUID:
		rc = command_partuuid(sf, argc - optind, argv + optind);
		break;

	case ACT_PARTLABEL:
		rc = command_partlabel(sf, argc - optind, argv + optind);
		break;

	case ACT_PARTATTRS:
		rc = command_partattrs(sf, argc - optind, argv + optind);
		break;

	case ACT_REORDER:
		rc = command_reorder(sf, argc - optind, argv + optind);
		break;
	}

	sfdisk_deinit(sf);

	DBG(MISC, ul_debug("bye! [rc=%d]", rc));
	return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}

