openkylin
/
util-linux
mirror of https://gitee.com/openkylin/util-linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
util-linux/disk-utils/cfdisk.c

2848 lines
64 KiB
C
Raw Blame History

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