diff options
Diffstat (limited to '')
| -rw-r--r-- | disk-utils/sfdisk.c | 2226 |
1 files changed, 2226 insertions, 0 deletions
diff --git a/disk-utils/sfdisk.c b/disk-utils/sfdisk.c new file mode 100644 index 0000000..3911dda --- /dev/null +++ b/disk-utils/sfdisk.c @@ -0,0 +1,2226 @@ +/* + * 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)) { + if (fdisk_gpt_is_hybrid(sf->cxt)) + errx(EXIT_FAILURE, _("toggle boot flags is unsupported for Hybrid GPT/MBR")); + + /* Switch from GPT to PMBR */ + sf->cxt = fdisk_new_nested_context(sf->cxt, "dos"); + if (!sf->cxt) + err(EXIT_FAILURE, _("cannot switch to PMBR")); + fdisk_info(sf->cxt, _("Activation is unsupported for GPT -- entering nested 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; +} + |