/*

* 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 <sys/time.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 "ttyutils.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_RELOCATE,

ACT_SHOW_SIZE,

ACT_SHOW_GEOM,

ACT_VERIFY,

ACT_PARTTYPE,

ACT_PARTUUID,

ACT_PARTLABEL,

ACT_PARTATTRS,

ACT_DISKID,

ACT_DELETE,

ACT_BACKUP_SECTORS,

};

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 *lockmode; /* as specified by --lock */

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 */

unused : 1, /* PT contains unused partition */

append : 1, /* don't create new PT, append partitions only */

json : 1, /* JSON dump */

movedata: 1, /* move data after resize */

movefsync: 1, /* use fsync() after each write() */

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;

xstrncpy(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] = { '\0' };

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);

if (sf->wipemode != WIPEMODE_ALWAYS)

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 || strcmp(filename, "@default") == 0) {

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 assign_device(struct sfdisk *sf, const char *devname, int rdonly)

{

struct fdisk_context *cxt = sf->cxt;

if (fdisk_assign_device(cxt, devname, rdonly) != 0)

err(EXIT_FAILURE, _("cannot open %s"), devname);

if (!fdisk_is_readonly(cxt)) {

if (blkdev_lock(fdisk_get_devfd(cxt), devname, sf->lockmode) != 0) {

fdisk_deassign_device(cxt, 1);

exit(EXIT_FAILURE);

}

if (sf->backup)

backup_partition_table(sf, devname);

}

return 0;

}

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, prev;

size_t io, ss, step_bytes, cc, ioerr = 0;

uintmax_t src, dst, nbytes;

int progress = 0, rc = 0;

struct timeval prev_time;

uint64_t bytes_per_sec = 0;

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);

/* set move direction and overlay */

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"));

}

/* set optimal step size -- nearest to 1MiB aligned to optimal I/O */

io = fdisk_get_optimal_iosize(sf->cxt);

ss = fdisk_get_sector_size(sf->cxt);

if (!io)

io = ss;

if (io < 1024 * 1024)

step_bytes = ((1024 * 1024) + io/2) / io * io;

else

step_bytes = io;

step = step_bytes / ss;

nbytes = nsectors * 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)

ignore_result( posix_fadvise(fd, from * ss,

nsectors * ss, POSIX_FADV_SEQUENTIAL) );

#endif

devname = fdisk_partname(fdisk_get_devname(sf->cxt), partno+1);

if (sf->move_typescript)

typescript = mk_backup_filename_tpl(sf->move_typescript, devname, ".move");

if (!sf->quiet) {

fdisk_info(sf->cxt, "%s", "");

color_scheme_enable("header", UL_COLOR_BOLD);

fdisk_info(sf->cxt, sf->noact ? _("Data move: (--no-act)") : _("Data move:"));

color_disable();

if (typescript)

fdisk_info(sf->cxt, _(" typescript file: %s"), typescript);

printf(_(" start sector: (from/to) %ju / %ju\n"), (uintmax_t) from, (uintmax_t) to);

printf(_(" sectors: %ju\n"), (uintmax_t) nsectors);

printf(_(" step size: %zu bytes\n"), step_bytes);

putchar('\n');

fflush(stdout);

if (isatty(fileno(stdout)))

progress = 1;

}

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."));

free(devname);

return 0;

}

}

if (typescript) {

f = fopen(typescript, "w");

if (!f) {

rc = -errno;

fdisk_warn(sf->cxt, _("cannot open %s"), typescript);

goto done;

}

/* 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, "# Sector size: %zu\n", ss);

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, "# Step size (sectors/bytes): %" PRIu64 "/%zu\n", step, step_bytes);

fprintf(f, "# Steps: %ju\n", ((uintmax_t) nsectors / step) + 1);

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));

gettimeofday(&prev_time, NULL);

prev = 0;

for (cc = 1, i = 0; i < nsectors && nbytes > 0; i += step, cc++) {

if (nbytes < step_bytes) {

DBG(MISC, ul_debug("aligning step #%05zu from %zu to %ju",

cc, step_bytes, nbytes));

step_bytes = nbytes;

}

nbytes -= step_bytes;

if (backward)

src -= step_bytes, dst -= step_bytes;

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

if (!sf->noact) {

/* read source */

if (lseek(fd, src, SEEK_SET) == (off_t) -1 ||

read_all(fd, buf, step_bytes) != (ssize_t) step_bytes) {

if (f)

fprintf(f, "%05zu: read error %12ju %12ju\n", cc, src, dst);

fdisk_warn(sf->cxt,

_("cannot read at offset: %ju; continue"), src);

ioerr++;

goto next;

}

/* write target */

if (lseek(fd, dst, SEEK_SET) == (off_t) -1 ||

write_all(fd, buf, step_bytes) != 0) {

if (f)

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

fdisk_warn(sf->cxt,

_("cannot write at offset: %ju; continue"), dst);

ioerr++;

goto next;

}

if (sf->movefsync && fsync(fd) != 0)

fdisk_warn(sf->cxt,

_("cannot fsync at offset: %ju; continue"), dst);

}

/* write log */

if (f)

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

if (progress && i % 10 == 0) {

unsigned int elapsed = 0; /* usec */

struct timeval cur_time;

gettimeofday(&cur_time, NULL);

if (cur_time.tv_sec - prev_time.tv_sec > 1) {

elapsed = ((cur_time.tv_sec - prev_time.tv_sec) * 1000000) +

(cur_time.tv_usec - prev_time.tv_usec);

bytes_per_sec = ((i - prev) * ss) / elapsed; /* per usec */

bytes_per_sec *= 1000000; /* per sec */

prev_time = cur_time;

prev = i;

}

if (bytes_per_sec)

fprintf(stdout, _("Moved %ju from %ju sectors (%.3f%%, %.1f MiB/s)."),

i + 1, nsectors,

100.0 / ((double) nsectors/(i+1)),

(double) (bytes_per_sec / (1024 * 1024)));

else

fprintf(stdout, _("Moved %ju from %ju sectors (%.3f%%)."),

i + 1, nsectors,

100.0 / ((double) nsectors/(i+1)));

fflush(stdout);

fputc('\r', stdout);

}

next:

if (!backward)

src += step_bytes, dst += step_bytes;

}

if (progress && nsectors) {

int x = get_terminal_width(80);

for (; x > 0; x--)

fputc(' ', stdout);

fflush(stdout);

fputc('\r', stdout);

if (i > nsectors)

/* see for() above; @i has to be greater than @nsectors

* on success due to i += step */

i = nsectors;

fprintf(stdout, _("Moved %ju from %ju sectors (%.0f%%)."),

i, nsectors,

100.0 / ((double) nsectors/(i+1)));

fputc('\n', stdout);

}

rc = 0;

done:

if (f)

fclose(f);

free(buf);

free(typescript);

if (sf->noact)

fdisk_info(sf->cxt, _("Your data has not been moved (--no-act)."));

if (ioerr) {

fdisk_info(sf->cxt, _("%zu I/O errors detected!"), ioerr);

rc = -EIO;

} else if (rc)

warn(_("%s: failed to move data"), devname);

free(devname);

return rc;

}

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 (!sf->noact && !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;

for (i = 0; i < argc; i++)

if (print_device_pt(sf->cxt, argv[i], 1, sf->verify, i) != 0)

fail++;

} 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;

for (i = 0; i < argc; i++)

if (print_device_freespace(sf->cxt, argv[i], 1, i) != 0)

fail++;

} 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);

assign_device(sf, devname, 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);

assign_device(sf, devname, 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;

assign_device(sf, devname, listonly);

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"));

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];

assign_device(sf, devname, 0);

/* delete all */

if (argc == 1) {