]> git.ipfire.org Git - thirdparty/util-linux.git/blob - disk-utils/cfdisk.c
projects / thirdparty / util-linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'usage-part2' of https://github.com/rudimeier/util-linux
[thirdparty/util-linux.git] / disk-utils / cfdisk.c
1 /*
2 * cfdisk.c - Display or manipulate a disk partition table.
3 *
4 * Copyright (C) 2014-2015 Karel Zak <kzak@redhat.com>
5 * Copyright (C) 1994 Kevin E. Martin (martin@cs.unc.edu)
6 *
7 * The original cfdisk was inspired by the fdisk program
8 * by A. V. Le Blanc (leblanc@mcc.ac.uk.
9 *
10 * cfdisk is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <errno.h>
18 #include <signal.h>
19 #include <ctype.h>
20 #include <getopt.h>
21 #include <assert.h>
22 #include <libsmartcols.h>
23 #include <sys/ioctl.h>
24 #include <libfdisk.h>
25
26 #ifdef HAVE_LIBMOUNT
27 # include <libmount.h> /* keep it optional for non-linux systems */
28 #endif
29
30 #ifdef HAVE_SLANG_H
31 # include <slang.h>
32 #elif defined(HAVE_SLANG_SLANG_H)
33 # include <slang/slang.h>
34 #endif
35
36 #ifdef HAVE_SLCURSES_H
37 # include <slcurses.h>
38 #elif defined(HAVE_SLANG_SLCURSES_H)
39 # include <slang/slcurses.h>
40 #elif defined(HAVE_NCURSESW_NCURSES_H) && defined(HAVE_WIDECHAR)
41 # include <ncursesw/ncurses.h>
42 #elif defined(HAVE_NCURSES_H)
43 # include <ncurses.h>
44 #elif defined(HAVE_NCURSES_NCURSES_H)
45 # include <ncurses/ncurses.h>
46 #endif
47
48 #ifdef HAVE_WIDECHAR
49 # include <wctype.h>
50 # include <wchar.h>
51 #endif
52
53 #include "c.h"
54 #include "closestream.h"
55 #include "nls.h"
56 #include "strutils.h"
57 #include "xalloc.h"
58 #include "mbsalign.h"
59 #include "mbsedit.h"
60 #include "colors.h"
61 #include "debug.h"
62 #include "list.h"
63
64 static const char *default_disks[] = {
65 #ifdef __GNU__
66 "/dev/hd0",
67 "/dev/sd0",
68 #elif defined(__FreeBSD__)
69 "/dev/ad0",
70 "/dev/da0",
71 #else
72 "/dev/sda",
73 "/dev/vda",
74 "/dev/hda",
75 #endif
76 };
77
78 #define ARROW_CURSOR_STRING ">> "
79 #define ARROW_CURSOR_DUMMY " "
80 #define ARROW_CURSOR_WIDTH (sizeof(ARROW_CURSOR_STRING) - 1)
81
82 /* vertical menu */
83 #define MENU_V_SPADDING 1 /* space around menu item string */
84
85 /* horizontal menu */
86 #define MENU_H_SPADDING 0 /* space around menu item string */
87 #define MENU_H_BETWEEN 2 /* space between menu items */
88 #define MENU_H_PRESTR "["
89 #define MENU_H_POSTSTR "]"
90
91 #define MENU_TITLE_PADDING 3
92
93 #define MENU_H_PRESTR_SZ (sizeof(MENU_H_PRESTR) - 1)
94 #define MENU_H_POSTSTR_SZ (sizeof(MENU_H_POSTSTR) - 1)
95
96 #define TABLE_START_LINE 4
97 #define MENU_START_LINE (ui_lines - 4) /* The menu maybe use two lines */
98 #define INFO_LINE (ui_lines - 2)
99 #define WARN_LINE INFO_LINE
100 #define HINT_LINE (ui_lines - 1)
101
102 #define CFDISK_ERR_ESC 5000
103
104 #ifndef KEY_ESC
105 # define KEY_ESC '\033'
106 #endif
107 #ifndef KEY_DELETE
108 # define KEY_DELETE '\177'
109 #endif
110 #ifndef KEY_DC
111 # define KEY_DC 0423
112 #endif
113
114
115 /* colors */
116 enum {
117 CFDISK_CL_NONE = 0,
118 CFDISK_CL_WARNING,
119 CFDISK_CL_FREESPACE,
120 CFDISK_CL_INFO
121 };
122 static const int color_pairs[][2] = {
123 /* color foreground, background */
124 [CFDISK_CL_WARNING] = { COLOR_RED, -1 },
125 [CFDISK_CL_FREESPACE] = { COLOR_GREEN, -1 },
126 [CFDISK_CL_INFO] = { COLOR_BLUE, -1 }
127 };
128
129 struct cfdisk;
130
131 static struct cfdisk_menuitem *menu_get_menuitem(struct cfdisk *cf, size_t idx);
132 static struct cfdisk_menuitem *menu_get_menuitem_by_key(struct cfdisk *cf, int key, size_t *idx);
133 static struct cfdisk_menu *menu_push(struct cfdisk *cf, struct cfdisk_menuitem *item);
134 static struct cfdisk_menu *menu_pop(struct cfdisk *cf);
135 static void menu_refresh_size(struct cfdisk *cf);
136
137 static int ui_refresh(struct cfdisk *cf);
138 static void ui_warnx(const char *fmt, ...);
139 static void ui_warn(const char *fmt, ...);
140 static void ui_info(const char *fmt, ...);
141 static void ui_draw_menu(struct cfdisk *cf);
142 static int ui_menu_move(struct cfdisk *cf, int key);
143 static void ui_menu_resize(struct cfdisk *cf);
144
145 static int ui_get_size(struct cfdisk *cf, const char *prompt, uintmax_t *res,
146 uintmax_t low, uintmax_t up, int *expsize);
147
148 static int ui_enabled;
149 static int ui_resize;
150
151 /* ncurses LINES and COLS may be actual variables or *macros*, but we need
152 * something portable and writable */
153 static size_t ui_lines;
154 static size_t ui_cols;
155
156 /* menu item */
157 struct cfdisk_menuitem {
158 int key; /* keyboard shortcut */
159 const char *name; /* item name */
160 const char *desc; /* item description (hint) */
161 void *userdata;
162 };
163
164 /* menu */
165 struct cfdisk_menu {
166 char *title; /* optional menu title */
167 struct cfdisk_menuitem *items; /* array with menu items */
168 char *ignore;/* string with keys to ignore */
169 size_t width; /* maximal width of the menu item */
170 size_t nitems; /* number of the active menu items */
171 size_t page_sz;/* when menu longer than screen */
172 size_t idx; /* the current menu item */
173 int prefkey;/* preferred menu item */
174 struct cfdisk_menu *prev;
175
176 /* @ignore keys generator */
177 int (*ignore_cb) (struct cfdisk *, char *, size_t);
178
179 unsigned int vertical : 1; /* enable vertical mode */
180 };
181
182 /* main menu */
183 static struct cfdisk_menuitem main_menuitems[] = {
184 { 'b', N_("Bootable"), N_("Toggle bootable flag of the current partition") },
185 { 'd', N_("Delete"), N_("Delete the current partition") },
186 { 'n', N_("New"), N_("Create new partition from free space") },
187 { 'q', N_("Quit"), N_("Quit program without writing changes") },
188 { 't', N_("Type"), N_("Change the partition type") },
189 { 'h', N_("Help"), N_("Print help screen") },
190 { 's', N_("Sort"), N_("Fix partitions order") },
191 { 'W', N_("Write"), N_("Write partition table to disk (this might destroy data)") },
192 { 'u', N_("Dump"), N_("Dump partition table to sfdisk compatible script file") },
193 { 0, NULL, NULL }
194 };
195
196 /* extra partinfo in name:value pairs */
197 struct cfdisk_extra {
198 char *name;
199 char *data;
200
201 struct list_head exs;
202 };
203
204 /* line and extra partinfo list_head */
205 struct cfdisk_line {
206 char *data; /* line data */
207 struct libscols_table *extra; /* extra info ('X') */
208 WINDOW *w; /* window with extra info */
209 };
210
211 /* top level control struct */
212 struct cfdisk {
213 struct fdisk_context *cxt; /* libfdisk context */
214 struct fdisk_table *table; /* partition table */
215
216 struct cfdisk_menu *menu; /* the current menu */
217
218 int *fields; /* output columns IDs */
219 size_t nfields; /* number of columns IDs */
220
221 char *linesbuf; /* table as string */
222 size_t linesbufsz; /* size of the tb_buf */
223
224 struct cfdisk_line *lines; /* list of lines */
225
226 size_t nlines; /* number of lines */
227 size_t lines_idx; /* current line <0..N>, exclude header */
228 size_t page_sz;
229
230 unsigned int nwrites; /* fdisk_write_disklabel() counter */
231
232 WINDOW *act_win; /* the window currently on the screen */
233
234 #ifdef HAVE_LIBMOUNT
235 struct libmnt_table *mtab;
236 struct libmnt_table *fstab;
237 struct libmnt_cache *mntcache;
238 #endif
239 unsigned int wrong_order :1, /* PT not in right order */
240 zero_start :1, /* ignore existing partition table */
241 show_extra :1; /* show extra partinfo */
242 };
243
244
245 /*
246 * let's use include/debug.h stuff for cfdisk too
247 */
248 static UL_DEBUG_DEFINE_MASK(cfdisk);
249 UL_DEBUG_DEFINE_MASKNAMES(cfdisk) = UL_DEBUG_EMPTY_MASKNAMES;
250
251 #define CFDISK_DEBUG_INIT (1 << 1)
252 #define CFDISK_DEBUG_UI (1 << 2)
253 #define CFDISK_DEBUG_MENU (1 << 3)
254 #define CFDISK_DEBUG_MISC (1 << 4)
255 #define CFDISK_DEBUG_TABLE (1 << 5)
256 #define CFDISK_DEBUG_ALL 0xFFFF
257
258 #define DBG(m, x) __UL_DBG(cfdisk, CFDISK_DEBUG_, m, x)
259
260 static void cfdisk_init_debug(void)
261 {
262 __UL_INIT_DEBUG(cfdisk, CFDISK_DEBUG_, 0, CFDISK_DEBUG);
263 }
264
265 /* Initialize output columns -- we follow libfdisk fields (usually specific
266 * to the label type.
267 */
268 static int cols_init(struct cfdisk *cf)
269 {
270 assert(cf);
271
272 free(cf->fields);
273 cf->fields = NULL;
274 cf->nfields = 0;
275
276 return fdisk_label_get_fields_ids(NULL, cf->cxt, &cf->fields, &cf->nfields);
277 }
278
279 static void resize(void)
280 {
281 struct winsize ws;
282
283 if (ioctl(fileno(stdout), TIOCGWINSZ, &ws) != -1
284 && ws.ws_row && ws.ws_col) {
285 ui_lines = ws.ws_row;
286 ui_cols = ws.ws_col;
287 #if HAVE_RESIZETERM
288 resizeterm(ws.ws_row, ws.ws_col);
289 #endif
290 clearok(stdscr, TRUE);
291 }
292 touchwin(stdscr);
293
294 DBG(UI, ul_debug("ui: resize refresh ui_cols=%zu, ui_lines=%zu",
295 ui_cols, ui_lines));
296 ui_resize = 0;
297 }
298
299 /* Reads partition in tree-like order from scols
300 */
301 static int partition_from_scols(struct fdisk_table *tb,
302 struct libscols_line *ln)
303 {
304 struct fdisk_partition *pa = scols_line_get_userdata(ln);
305
306 fdisk_table_add_partition(tb, pa);
307 fdisk_unref_partition(pa);
308
309 if (scols_line_has_children(ln)) {
310 struct libscols_line *chln;
311 struct libscols_iter *itr = scols_new_iter(SCOLS_ITER_FORWARD);
312
313 if (!itr)
314 return -EINVAL;
315 while (scols_line_next_child(ln, itr, &chln) == 0)
316 partition_from_scols(tb, chln);
317 scols_free_iter(itr);
318 }
319 return 0;
320 }
321
322 static char *table_to_string(struct cfdisk *cf, struct fdisk_table *tb)
323 {
324 struct fdisk_partition *pa;
325 struct fdisk_label *lb;
326 struct fdisk_iter *itr;
327 struct libscols_table *table = NULL;
328 struct libscols_iter *s_itr = NULL;
329 char *res = NULL;
330 size_t i;
331 int tree = 0;
332 struct libscols_line *ln, *ln_cont = NULL;
333
334 DBG(TABLE, ul_debug("convert to string"));
335
336 assert(cf);
337 assert(cf->cxt);
338 assert(cf->fields);
339 assert(tb);
340
341 lb = fdisk_get_label(cf->cxt, NULL);
342 assert(lb);
343
344 itr = fdisk_new_iter(FDISK_ITER_FORWARD);
345 if (!itr)
346 goto done;
347
348 /* get container (e.g. extended partition) */
349 while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
350 if (fdisk_partition_is_nested(pa)) {
351 DBG(TABLE, ul_debug("nested detected, using tree"));
352 tree = SCOLS_FL_TREE;
353 break;
354 }
355 }
356
357 table = scols_new_table();
358 if (!table)
359 goto done;
360 scols_table_enable_maxout(table, 1);
361 scols_table_enable_nowrap(table, 1);
362
363 #if !defined(HAVE_LIBNCURSESW) || !defined(HAVE_WIDECHAR)
364 scols_table_enable_ascii(table, 1);
365 #endif
366
367 /* headers */
368 for (i = 0; i < cf->nfields; i++) {
369 int fl = 0;
370 const struct fdisk_field *field =
371 fdisk_label_get_field(lb, cf->fields[i]);
372 if (!field)
373 continue;
374
375 if (fdisk_field_is_number(field))
376 fl |= SCOLS_FL_RIGHT;
377 if (fdisk_field_get_id(field) == FDISK_FIELD_TYPE)
378 fl |= SCOLS_FL_TRUNC;
379 if (tree && fdisk_field_get_id(field) == FDISK_FIELD_DEVICE)
380 fl |= SCOLS_FL_TREE;
381
382 if (!scols_table_new_column(table,
383 _(fdisk_field_get_name(field)),
384 fdisk_field_get_width(field), fl))
385 goto done;
386 }
387
388 /* data */
389 fdisk_reset_iter(itr, FDISK_ITER_FORWARD);
390
391 while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
392 struct libscols_line *parent = fdisk_partition_is_nested(pa) ? ln_cont : NULL;
393
394 ln = scols_table_new_line(table, parent);
395 if (!ln)
396 goto done;
397 for (i = 0; i < cf->nfields; i++) {
398 char *cdata = NULL;
399
400 if (fdisk_partition_to_string(pa, cf->cxt,
401 cf->fields[i], &cdata))
402 continue;
403 scols_line_refer_data(ln, i, cdata);
404 }
405 if (tree && fdisk_partition_is_container(pa))
406 ln_cont = ln;
407
408 scols_line_set_userdata(ln, (void *) pa);
409 fdisk_ref_partition(pa);
410 }
411
412 if (scols_table_is_empty(table))
413 goto done;
414
415 scols_table_reduce_termwidth(table, ARROW_CURSOR_WIDTH);
416 scols_print_table_to_string(table, &res);
417
418 /* scols_* code might reorder lines, let's reorder @tb according to the
419 * final output (it's no problem because partitions are addressed by
420 * parno stored within struct fdisk_partition) */
421
422 /* remove all */
423 fdisk_reset_iter(itr, FDISK_ITER_FORWARD);
424 while (fdisk_table_next_partition(tb, itr, &pa) == 0)
425 fdisk_table_remove_partition(tb, pa);
426
427 s_itr = scols_new_iter(SCOLS_ITER_FORWARD);
428 if (!s_itr)
429 goto done;
430
431 /* add all in the right order (don't forget the output is tree) */
432 while (scols_table_next_line(table, s_itr, &ln) == 0) {
433 if (scols_line_get_parent(ln))
434 continue;
435 if (partition_from_scols(tb, ln))
436 break;
437 }
438 done:
439 scols_unref_table(table);
440 scols_free_iter(s_itr);
441 fdisk_free_iter(itr);
442
443 return res;
444 }
445
446 static void cfdisk_free_lines(struct cfdisk *cf)
447 {
448 size_t i = 0;
449 while(i < cf->nlines) {
450 scols_unref_table(cf->lines[i].extra);
451
452 DBG(UI, ul_debug("delete window: %p",
453 cf->lines[i].w));
454
455 if (cf->lines[i].w)
456 delwin(cf->lines[i].w);
457 cf->lines[i].w = NULL;
458 ++i;
459 }
460 cf->act_win = NULL;
461 free(cf->lines);
462 cf->lines = NULL;
463 }
464 /*
465 * Read data about partitions from libfdisk and prepare output lines.
466 */
467 static int lines_refresh(struct cfdisk *cf)
468 {
469 int rc;
470 char *p;
471 size_t i;
472
473 assert(cf);
474
475 DBG(TABLE, ul_debug("refreshing buffer"));
476
477 free(cf->linesbuf);
478 cfdisk_free_lines(cf);
479 cf->linesbuf = NULL;
480 cf->linesbufsz = 0;
481 cf->lines = NULL;
482 cf->nlines = 0;
483
484 fdisk_unref_table(cf->table);
485 cf->table = NULL;
486
487 /* read partitions and free spaces into cf->table */
488 rc = fdisk_get_partitions(cf->cxt, &cf->table);
489 if (!rc)
490 rc = fdisk_get_freespaces(cf->cxt, &cf->table);
491 if (rc)
492 return rc;
493
494 cf->linesbuf = table_to_string(cf, cf->table);
495 if (!cf->linesbuf)
496 return -ENOMEM;
497
498 cf->linesbufsz = strlen(cf->linesbuf);
499 cf->nlines = fdisk_table_get_nents(cf->table) + 1; /* 1 for header line */
500 cf->page_sz = 0;
501 cf->wrong_order = fdisk_table_wrong_order(cf->table) ? 1 : 0;
502
503 if (MENU_START_LINE - TABLE_START_LINE < cf->nlines)
504 cf->page_sz = MENU_START_LINE - TABLE_START_LINE - 1;
505
506 cf->lines = xcalloc(cf->nlines, sizeof(struct cfdisk_line));
507
508 for (p = cf->linesbuf, i = 0; p && i < cf->nlines; i++) {
509 cf->lines[i].data = p;
510 p = strchr(p, '\n');
511 if (p) {
512 *p = '\0';
513 p++;
514 }
515 cf->lines[i].extra = scols_new_table();
516 scols_table_enable_noheadings(cf->lines[i].extra, 1);
517 scols_table_new_column(cf->lines[i].extra, NULL, 0, SCOLS_FL_RIGHT);
518 scols_table_new_column(cf->lines[i].extra, NULL, 0, SCOLS_FL_TRUNC);
519 }
520
521 return 0;
522 }
523
524 static struct fdisk_partition *get_current_partition(struct cfdisk *cf)
525 {
526 assert(cf);
527 assert(cf->table);
528
529 return fdisk_table_get_partition(cf->table, cf->lines_idx);
530 }
531
532 static int is_freespace(struct cfdisk *cf, size_t i)
533 {
534 struct fdisk_partition *pa;
535
536 assert(cf);
537 assert(cf->table);
538
539 pa = fdisk_table_get_partition(cf->table, i);
540 return fdisk_partition_is_freespace(pa);
541 }
542
543 /* converts libfdisk FDISK_ASKTYPE_MENU to cfdisk menu and returns user's
544 * response back to libfdisk
545 */
546 static int ask_menu(struct fdisk_ask *ask, struct cfdisk *cf)
547 {
548 struct cfdisk_menuitem *d, *cm;
549 int key;
550 size_t i = 0, nitems;
551 const char *name, *desc;
552
553 assert(ask);
554 assert(cf);
555
556 /* create cfdisk menu according to libfdisk ask-menu, note that the
557 * last cm[] item has to be empty -- so nitems + 1 */
558 nitems = fdisk_ask_menu_get_nitems(ask);
559 cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
560
561 for (i = 0; i < nitems; i++) {
562 if (fdisk_ask_menu_get_item(ask, i, &key, &name, &desc))
563 break;
564 cm[i].key = key;
565 cm[i].desc = desc;
566 cm[i].name = name;
567 }
568
569 /* make the new menu active */
570 menu_push(cf, cm);
571 ui_draw_menu(cf);
572 refresh();
573
574 /* wait for keys */
575 do {
576 key = getch();
577
578 if (ui_resize)
579 ui_menu_resize(cf);
580 if (ui_menu_move(cf, key) == 0)
581 continue;
582
583 switch (key) {
584 case KEY_ENTER:
585 case '\n':
586 case '\r':
587 d = menu_get_menuitem(cf, cf->menu->idx);
588 if (d)
589 fdisk_ask_menu_set_result(ask, d->key);
590 menu_pop(cf);
591 free(cm);
592 return 0;
593 }
594 } while (1);
595
596 menu_pop(cf);
597 free(cm);
598 return -1;
599 }
600
601 /* libfdisk callback
602 */
603 static int ask_callback(struct fdisk_context *cxt __attribute__((__unused__)),
604 struct fdisk_ask *ask,
605 void *data __attribute__((__unused__)))
606 {
607 int rc = 0;
608
609 assert(ask);
610
611 switch(fdisk_ask_get_type(ask)) {
612 case FDISK_ASKTYPE_INFO:
613 ui_info(fdisk_ask_print_get_mesg(ask));
614 break;
615 case FDISK_ASKTYPE_WARNX:
616 ui_warnx(fdisk_ask_print_get_mesg(ask));
617 break;
618 case FDISK_ASKTYPE_WARN:
619 ui_warn(fdisk_ask_print_get_mesg(ask));
620 break;
621 case FDISK_ASKTYPE_MENU:
622 ask_menu(ask, (struct cfdisk *) data);
623 break;
624 default:
625 ui_warnx(_("internal error: unsupported dialog type %d"),
626 fdisk_ask_get_type(ask));
627 return -EINVAL;
628 }
629 return rc;
630 }
631
632 static int ui_end(void)
633 {
634 if (!ui_enabled)
635 return -EINVAL;
636
637 #if defined(HAVE_SLCURSES_H) || defined(HAVE_SLANG_SLCURSES_H)
638 SLsmg_gotorc(ui_lines - 1, 0);
639 SLsmg_refresh();
640 #else
641 mvcur(0, ui_cols - 1, ui_lines-1, 0);
642 #endif
643 curs_set(1);
644 nl();
645 endwin();
646 printf("\n");
647 ui_enabled = 0;
648 return 0;
649 }
650
651 static void ui_vprint_center(size_t line, int attrs, const char *fmt, va_list ap)
652 {
653 size_t width;
654 char *buf = NULL;
655
656 move(line, 0);
657 clrtoeol();
658
659 xvasprintf(&buf, fmt, ap);
660
661 width = mbs_safe_width(buf);
662 if (width > (size_t) ui_cols) {
663 char *p = strrchr(buf + ui_cols, ' ');
664 if (!p)
665 p = buf + ui_cols;
666 *p = '\0';
667 if (line + 1 >= ui_lines)
668 line--;
669 attron(attrs);
670 mvaddstr(line, 0, buf);
671 mvaddstr(line + 1, 0, p+1);
672 attroff(attrs);
673 } else {
674 attron(attrs);
675 mvaddstr(line, (ui_cols - width) / 2, buf);
676 attroff(attrs);
677 }
678 free(buf);
679 }
680
681 static void ui_center(size_t line, const char *fmt, ...)
682 {
683 va_list ap;
684 va_start(ap, fmt);
685 ui_vprint_center(line, 0, fmt, ap);
686 va_end(ap);
687 }
688
689 static void ui_warnx(const char *fmt, ...)
690 {
691 va_list ap;
692 va_start(ap, fmt);
693 if (ui_enabled)
694 ui_vprint_center(WARN_LINE,
695 colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING) : 0,
696 fmt, ap);
697 else {
698 vfprintf(stderr, fmt, ap);
699 fputc('\n', stderr);
700 }
701 va_end(ap);
702 }
703
704 static void ui_warn(const char *fmt, ...)
705 {
706 char *fmt_m;
707 va_list ap;
708
709 xasprintf(&fmt_m, "%s: %m", fmt);
710
711 va_start(ap, fmt);
712 if (ui_enabled)
713 ui_vprint_center(WARN_LINE,
714 colors_wanted() ? COLOR_PAIR(CFDISK_CL_WARNING) : 0,
715 fmt_m, ap);
716 else {
717 vfprintf(stderr, fmt_m, ap);
718 fputc('\n', stderr);
719 }
720 va_end(ap);
721 free(fmt_m);
722 }
723
724 static void ui_clean_warn(void)
725 {
726 move(WARN_LINE, 0);
727 clrtoeol();
728 }
729
730 static int __attribute__((__noreturn__)) ui_errx(int rc, const char *fmt, ...)
731 {
732 va_list ap;
733 ui_end();
734
735 va_start(ap, fmt);
736 fprintf(stderr, "%s: ", program_invocation_short_name);
737 vfprintf(stderr, fmt, ap);
738 fputc('\n', stderr);
739 va_end(ap);
740
741 exit(rc);
742 }
743
744 static void ui_info(const char *fmt, ...)
745 {
746 va_list ap;
747 va_start(ap, fmt);
748 if (ui_enabled)
749 ui_vprint_center(INFO_LINE,
750 colors_wanted() ? COLOR_PAIR(CFDISK_CL_INFO) : 0,
751 fmt, ap);
752 else {
753 vfprintf(stdout, fmt, ap);
754 fputc('\n', stdout);
755 }
756 va_end(ap);
757 }
758
759 static void ui_clean_info(void)
760 {
761 move(INFO_LINE, 0);
762 clrtoeol();
763 }
764
765 static void ui_hint(const char *fmt, ...)
766 {
767 va_list ap;
768 va_start(ap, fmt);
769 if (ui_enabled)
770 ui_vprint_center(HINT_LINE, A_BOLD, fmt, ap);
771 else {
772 vfprintf(stdout, fmt, ap);
773 fputc('\n', stdout);
774 }
775 va_end(ap);
776 }
777
778 static void ui_clean_hint(void)
779 {
780 move(HINT_LINE, 0);
781 clrtoeol();
782 }
783
784 static void die_on_signal(int dummy __attribute__((__unused__)))
785 {
786 DBG(MISC, ul_debug("die on signal."));
787 ui_end();
788 exit(EXIT_FAILURE);
789 }
790
791 static void resize_on_signal(int dummy __attribute__((__unused__)))
792 {
793 DBG(MISC, ul_debug("resize on signal."));
794 ui_resize = 1;
795 }
796
797 static void menu_refresh_size(struct cfdisk *cf)
798 {
799 if (cf->menu && cf->menu->nitems)
800 cf->menu->page_sz = (cf->menu->nitems / (ui_lines - 4)) ? ui_lines - 4 : 0;
801 }
802
803 static void menu_update_ignore(struct cfdisk *cf)
804 {
805 char ignore[128] = { 0 };
806 int i = 0;
807 struct cfdisk_menu *m;
808 struct cfdisk_menuitem *d, *org = NULL;
809 size_t idx;
810
811 assert(cf);
812 assert(cf->menu);
813 assert(cf->menu->ignore_cb);
814
815 m = cf->menu;
816 DBG(MENU, ul_debug("update menu ignored keys"));
817
818 i = m->ignore_cb(cf, ignore, sizeof(ignore));
819 ignore[i] = '\0';
820
821 /* return if no change */
822 if ((!m->ignore && !*ignore)
823 || (m->ignore && *ignore && strcmp(m->ignore, ignore) == 0)) {
824 return;
825 }
826
827 if (!m->prefkey)
828 org = menu_get_menuitem(cf, m->idx);
829
830 free(m->ignore);
831 m->ignore = xstrdup(ignore);
832 m->nitems = 0;
833
834 for (d = m->items; d->name; d++) {
835 if (m->ignore && strchr(m->ignore, d->key))
836 continue;
837 m->nitems++;
838 }
839
840 DBG(MENU, ul_debug("update menu preferred keys"));
841
842 /* refresh menu index to be at the same menuitem or go to the first */
843 if (org && menu_get_menuitem_by_key(cf, org->key, &idx))
844 m->idx = idx;
845 else if (m->prefkey && menu_get_menuitem_by_key(cf, m->prefkey, &idx))
846 m->idx = idx;
847 else
848 m->idx = 0;
849
850 menu_refresh_size(cf);
851 }
852
853 static struct cfdisk_menu *menu_push(
854 struct cfdisk *cf,
855 struct cfdisk_menuitem *items)
856 {
857 struct cfdisk_menu *m = xcalloc(1, sizeof(*m));
858 struct cfdisk_menuitem *d;
859
860 assert(cf);
861
862 DBG(MENU, ul_debug("new menu"));
863
864 m->prev = cf->menu;
865 m->items = items;
866
867 for (d = m->items; d->name; d++) {
868 const char *name = _(d->name);
869 size_t len = mbs_safe_width(name);
870 if (len > m->width)
871 m->width = len;
872 m->nitems++;
873 }
874
875 cf->menu = m;
876
877 menu_refresh_size(cf);
878 return m;
879 }
880
881 static struct cfdisk_menu *menu_pop(struct cfdisk *cf)
882 {
883 struct cfdisk_menu *m = NULL;
884
885 assert(cf);
886
887 DBG(MENU, ul_debug("pop menu"));
888
889 if (cf->menu) {
890 m = cf->menu->prev;
891 free(cf->menu->ignore);
892 free(cf->menu->title);
893 free(cf->menu);
894 }
895 cf->menu = m;
896 return cf->menu;
897 }
898
899 static void menu_set_title(struct cfdisk_menu *m, const char *title)
900 {
901 char *str = NULL;
902
903 if (title) {
904 size_t len = mbs_safe_width(title);
905 if (len + MENU_TITLE_PADDING > m->width)
906 m->width = len + MENU_TITLE_PADDING;
907 str = xstrdup(title);
908 }
909 m->title = str;
910 }
911
912
913 static int ui_init(struct cfdisk *cf __attribute__((__unused__)))
914 {
915 struct sigaction sa;
916
917 DBG(UI, ul_debug("init"));
918
919 /* setup SIGCHLD handler */
920 sigemptyset(&sa.sa_mask);
921 sa.sa_flags = 0;
922 sa.sa_handler = die_on_signal;
923 sigaction(SIGINT, &sa, NULL);
924 sigaction(SIGTERM, &sa, NULL);
925
926 sa.sa_handler = resize_on_signal;
927 sigaction(SIGWINCH, &sa, NULL);
928
929 ui_enabled = 1;
930 initscr();
931
932 #ifdef HAVE_USE_DEFAULT_COLORS
933 if (colors_wanted() && has_colors()) {
934 size_t i;
935
936 start_color();
937 use_default_colors();
938 for (i = 1; i < ARRAY_SIZE(color_pairs); i++) /* yeah, start from 1! */
939 init_pair(i, color_pairs[i][0], color_pairs[i][1]);
940 }
941 #else
942 colors_off();
943 #endif
944
945 cbreak();
946 noecho();
947 nonl();
948 curs_set(0);
949 keypad(stdscr, TRUE);
950
951 return 0;
952 }
953
954 /* "[ string ]" */
955 #define MENU_H_ITEMWIDTH(m) ( MENU_H_PRESTR_SZ \
956 + MENU_H_SPADDING \
957 + (m)->width \
958 + MENU_H_SPADDING \
959 + MENU_H_POSTSTR_SZ)
960
961 #define MENU_V_ITEMWIDTH(m) (MENU_V_SPADDING + (m)->width + MENU_V_SPADDING)
962
963
964 static size_t menuitem_get_line(struct cfdisk *cf, size_t idx)
965 {
966 struct cfdisk_menu *m = cf->menu;
967
968 if (m->vertical) {
969 if (!m->page_sz) /* small menu */
970 return (ui_lines - (cf->menu->nitems + 1)) / 2 + idx;
971 return (idx % m->page_sz) + 1;
972 } else {
973 size_t len = MENU_H_ITEMWIDTH(m) + MENU_H_BETWEEN; /** item width */
974 size_t items = ui_cols / len; /* items per line */
975
976 if (items == 0)
977 return 0;
978 return MENU_START_LINE + ((idx / items));
979 }
980 }
981
982 static int menuitem_get_column(struct cfdisk *cf, size_t idx)
983 {
984 if (cf->menu->vertical) {
985 size_t nc = MENU_V_ITEMWIDTH(cf->menu);
986 if ((size_t) ui_cols <= nc)
987 return 0;
988 return (ui_cols - nc) / 2;
989 } else {
990 size_t len = MENU_H_ITEMWIDTH(cf->menu) + MENU_H_BETWEEN; /* item width */
991 size_t items = ui_cols / len; /* items per line */
992 size_t extra = items < cf->menu->nitems ? /* extra space on line */
993 ui_cols % len : /* - multi-line menu */
994 ui_cols - (cf->menu->nitems * len); /* - one line menu */
995
996 if (items == 0)
997 return 0; /* hmm... no space */
998
999 extra += MENU_H_BETWEEN; /* add padding after last item to extra */
1000
1001 if (idx < items)
1002 return (idx * len) + (extra / 2);
1003 return ((idx % items) * len) + (extra / 2);
1004 }
1005 }
1006
1007 static int menuitem_on_page(struct cfdisk *cf, size_t idx)
1008 {
1009 struct cfdisk_menu *m = cf->menu;
1010
1011 if (m->page_sz == 0 ||
1012 m->idx / m->page_sz == idx / m->page_sz)
1013 return 1;
1014 return 0;
1015 }
1016
1017 static struct cfdisk_menuitem *menu_get_menuitem(struct cfdisk *cf, size_t idx)
1018 {
1019 struct cfdisk_menuitem *d;
1020 size_t i;
1021
1022 for (i = 0, d = cf->menu->items; d->name; d++) {
1023 if (cf->menu->ignore && strchr(cf->menu->ignore, d->key))
1024 continue;
1025 if (i++ == idx)
1026 return d;
1027 }
1028
1029 return NULL;
1030 }
1031
1032 static struct cfdisk_menuitem *menu_get_menuitem_by_key(struct cfdisk *cf,
1033 int key, size_t *idx)
1034 {
1035 struct cfdisk_menuitem *d;
1036
1037 for (*idx = 0, d = cf->menu->items; d->name; d++) {
1038 if (cf->menu->ignore && strchr(cf->menu->ignore, d->key))
1039 continue;
1040 if (key == d->key)
1041 return d;
1042 (*idx)++;
1043 }
1044
1045 return NULL;
1046 }
1047
1048 static void ui_draw_menuitem(struct cfdisk *cf,
1049 struct cfdisk_menuitem *d,
1050 size_t idx)
1051 {
1052 char *buf, *ptr;
1053 const char *name;
1054 size_t width;
1055 const size_t buf_sz = 80 * MB_CUR_MAX;
1056 int ln, cl, vert = cf->menu->vertical;
1057
1058 if (!menuitem_on_page(cf, idx))
1059 return; /* no visible item */
1060 ln = menuitem_get_line(cf, idx);
1061 cl = menuitem_get_column(cf, idx);
1062
1063 ptr = buf = xmalloc(buf_sz);
1064 /* string width */
1065 if (vert) {
1066 width = cf->menu->width + MENU_V_SPADDING;
1067 memset(ptr, ' ', MENU_V_SPADDING);
1068 ptr += MENU_V_SPADDING;
1069 } else
1070 width = MENU_H_SPADDING + cf->menu->width + MENU_H_SPADDING;
1071
1072 name = _(d->name);
1073 mbsalign(name, ptr, buf_sz, &width,
1074 vert ? MBS_ALIGN_LEFT : MBS_ALIGN_CENTER,
1075 0);
1076
1077 DBG(MENU, ul_debug("menuitem: cl=%d, ln=%d, item='%s'",
1078 cl, ln, buf));
1079
1080 if (vert) {
1081 mvaddch(ln, cl - 1, ACS_VLINE);
1082 mvaddch(ln, cl + MENU_V_ITEMWIDTH(cf->menu), ACS_VLINE);
1083 }
1084
1085 if (cf->menu->idx == idx)
1086 standout();
1087
1088 if (vert)
1089 mvprintw(ln, cl, "%s", buf);
1090 else
1091 mvprintw(ln, cl, "%s%s%s", MENU_H_PRESTR, buf, MENU_H_POSTSTR);
1092 free(buf);
1093
1094 if (cf->menu->idx == idx) {
1095 standend();
1096 if (d->desc)
1097 ui_hint(_(d->desc));
1098 }
1099 }
1100
1101 static void ui_clean_menu(struct cfdisk *cf)
1102 {
1103 size_t i;
1104 size_t lastline;
1105 struct cfdisk_menu *m = cf->menu;
1106 size_t ln = menuitem_get_line(cf, 0);
1107
1108 if (m->vertical)
1109 lastline = ln + (m->page_sz ? m->page_sz : m->nitems);
1110 else
1111 lastline = menuitem_get_line(cf, m->nitems);
1112
1113 for (i = ln; i <= lastline; i++) {
1114 move(i, 0);
1115 clrtoeol();
1116 DBG(MENU, ul_debug("clean_menu: line %zu", i));
1117 }
1118 if (m->vertical) {
1119 move(ln - 1, 0);
1120 clrtoeol();
1121 }
1122 ui_clean_hint();
1123 }
1124
1125 static void ui_draw_menu(struct cfdisk *cf)
1126 {
1127 struct cfdisk_menuitem *d;
1128 struct cfdisk_menu *m;
1129 size_t i = 0;
1130 size_t ln = menuitem_get_line(cf, 0);
1131 size_t nlines;
1132
1133 assert(cf);
1134 assert(cf->menu);
1135
1136 DBG(MENU, ul_debug("draw start"));
1137
1138 ui_clean_menu(cf);
1139 m = cf->menu;
1140
1141 if (m->vertical)
1142 nlines = m->page_sz ? m->page_sz : m->nitems;
1143 else
1144 nlines = menuitem_get_line(cf, m->nitems);
1145
1146 if (m->ignore_cb)
1147 menu_update_ignore(cf);
1148 i = 0;
1149 while ((d = menu_get_menuitem(cf, i)))
1150 ui_draw_menuitem(cf, d, i++);
1151
1152 if (m->vertical) {
1153 size_t cl = menuitem_get_column(cf, 0);
1154 size_t curpg = m->page_sz ? m->idx / m->page_sz : 0;
1155
1156 /* corners and horizontal lines */
1157 mvaddch(ln - 1, cl - 1, ACS_ULCORNER);
1158 mvaddch(ln + nlines, cl - 1, ACS_LLCORNER);
1159
1160 for (i = 0; i < MENU_V_ITEMWIDTH(m); i++) {
1161 mvaddch(ln - 1, cl + i, ACS_HLINE);
1162 mvaddch(ln + nlines, cl + i, ACS_HLINE);
1163 }
1164
1165 mvaddch(ln - 1, cl + i, ACS_URCORNER);
1166 mvaddch(ln + nlines, cl + i, ACS_LRCORNER);
1167
1168 /* draw also lines around empty lines on last page */
1169 if (m->page_sz &&
1170 m->nitems / m->page_sz == m->idx / m->page_sz) {
1171 for (i = m->nitems % m->page_sz + 1; i <= m->page_sz; i++) {
1172 mvaddch(i, cl - 1, ACS_VLINE);
1173 mvaddch(i, cl + MENU_V_ITEMWIDTH(m), ACS_VLINE);
1174 }
1175 }
1176 if (m->title) {
1177 attron(A_BOLD);
1178 mvprintw(ln - 1, cl, " %s ", m->title);
1179 attroff(A_BOLD);
1180 }
1181 if (curpg != 0)
1182 mvaddch(ln - 1, cl + MENU_V_ITEMWIDTH(m) - 2, ACS_UARROW);
1183 if (m->page_sz && curpg < m->nitems / m->page_sz)
1184 mvaddch(ln + nlines, cl + MENU_V_ITEMWIDTH(m) - 2, ACS_DARROW);
1185 }
1186
1187 DBG(MENU, ul_debug("draw end."));
1188 }
1189
1190 inline static int extra_insert_pair(struct cfdisk_line *l, const char *name, const char *data)
1191 {
1192 struct libscols_line *lsl;
1193 int rc;
1194
1195 assert(l);
1196 assert(l->extra);
1197
1198 if (!data || !*data)
1199 return 0;
1200
1201 lsl = scols_table_new_line(l->extra, NULL);
1202 if (!lsl)
1203 return -ENOMEM;
1204
1205 rc = scols_line_set_data(lsl, 0, name);
1206 if (!rc)
1207 rc = scols_line_set_data(lsl, 1, data);
1208
1209 return rc;
1210 }
1211
1212 #ifndef HAVE_LIBMOUNT
1213 static char *get_mountpoint( struct cfdisk *cf __attribute__((unused)),
1214 const char *tagname __attribute__((unused)),
1215 const char *tagdata __attribute__((unused)))
1216 {
1217 return NULL;
1218 }
1219 #else
1220 static char *get_mountpoint(struct cfdisk *cf, const char *tagname, const char *tagdata)
1221 {
1222 struct libmnt_fs *fs = NULL;
1223 char *target = NULL;
1224 int mounted = 0;
1225
1226 assert(tagname);
1227 assert(tagdata);
1228
1229 DBG(UI, ul_debug("asking for mountpoint [%s=%s]", tagname, tagdata));
1230
1231 if (!cf->mntcache)
1232 cf->mntcache = mnt_new_cache();
1233
1234 /* 1st try between mounted filesystems */
1235 if (!cf->mtab) {
1236 cf->mtab = mnt_new_table();
1237 if (cf->mtab) {
1238 mnt_table_set_cache(cf->mtab, cf->mntcache);
1239 mnt_table_parse_mtab(cf->mtab, NULL);
1240 }
1241 }
1242
1243 if (cf->mtab)
1244 fs = mnt_table_find_tag(cf->mtab, tagname, tagdata, MNT_ITER_FORWARD);
1245
1246 /* 2nd try fstab */
1247 if (!fs) {
1248 if (!cf->fstab) {
1249 cf->fstab = mnt_new_table();
1250 if (cf->fstab) {
1251 mnt_table_set_cache(cf->fstab, cf->mntcache);
1252 mnt_table_parse_fstab(cf->fstab, NULL);
1253 }
1254 }
1255 if (cf->fstab)
1256 fs = mnt_table_find_tag(cf->fstab, tagname, tagdata, MNT_ITER_FORWARD);
1257 } else
1258 mounted = 1;
1259
1260 if (fs) {
1261 if (mounted)
1262 xasprintf(&target, _("%s (mounted)"), mnt_fs_get_target(fs));
1263 else
1264 target = xstrdup(mnt_fs_get_target(fs));
1265 }
1266
1267 return target;
1268 }
1269 #endif /* HAVE_LIBMOUNT */
1270
1271 static void extra_prepare_data(struct cfdisk *cf)
1272 {
1273 struct fdisk_partition *pa = get_current_partition(cf);
1274 struct cfdisk_line *l = &cf->lines[cf->lines_idx];
1275 char *data = NULL;
1276 char *mountpoint = NULL;
1277
1278 DBG(UI, ul_debug("preparing extra data"));
1279
1280 /* string data should not equal an empty string */
1281 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_NAME, &data) && data) {
1282 extra_insert_pair(l, _("Partition name:"), data);
1283 if (!mountpoint)
1284 mountpoint = get_mountpoint(cf, "PARTLABEL", data);
1285 free(data);
1286 }
1287
1288 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_UUID, &data) && data) {
1289 extra_insert_pair(l, _("Partition UUID:"), data);
1290 if (!mountpoint)
1291 mountpoint = get_mountpoint(cf, "PARTUUID", data);
1292 free(data);
1293 }
1294
1295 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_TYPE, &data) && data) {
1296 char *code = NULL, *type = NULL;
1297
1298 fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_TYPEID, &code);
1299 xasprintf(&type, "%s (%s)", data, code);
1300
1301 extra_insert_pair(l, _("Partition type:"), type);
1302 free(data);
1303 free(code);
1304 free(type);
1305 }
1306
1307 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_ATTR, &data) && data) {
1308 extra_insert_pair(l, _("Attributes:"), data);
1309 free(data);
1310 }
1311
1312 /* for numeric data, only show non-zero rows */
1313 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_BSIZE, &data) && data) {
1314 if (atoi(data))
1315 extra_insert_pair(l, "BSIZE:", data);
1316 free(data);
1317 }
1318
1319 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_CPG, &data) && data) {
1320 if (atoi(data))
1321 extra_insert_pair(l, "CPG:", data);
1322 free(data);
1323 }
1324
1325 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSIZE, &data) && data) {
1326 if (atoi(data))
1327 extra_insert_pair(l, "FSIZE:", data);
1328 free(data);
1329 }
1330
1331 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSUUID, &data) && data) {
1332 extra_insert_pair(l, _("Filesystem UUID:"), data);
1333 if (!mountpoint)
1334 mountpoint = get_mountpoint(cf, "UUID", data);
1335 free(data);
1336 }
1337
1338 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSLABEL, &data) && data) {
1339 extra_insert_pair(l, _("Filesystem LABEL:"), data);
1340 if (!mountpoint)
1341 mountpoint = get_mountpoint(cf, "LABEL", data);
1342 free(data);
1343 }
1344 if (!fdisk_partition_to_string(pa, cf->cxt, FDISK_FIELD_FSTYPE, &data) && data) {
1345 extra_insert_pair(l, _("Filesystem:"), data);
1346 free(data);
1347 }
1348
1349 if (mountpoint) {
1350 extra_insert_pair(l, _("Mountpoint:"), mountpoint);
1351 free(mountpoint);
1352 }
1353 }
1354
1355 static int ui_draw_extra(struct cfdisk *cf)
1356 {
1357 WINDOW *win_ex;
1358 int wline = 1;
1359 struct cfdisk_line *ln = &cf->lines[cf->lines_idx];
1360 char *tbstr = NULL, *end;
1361 int win_ex_start_line, win_height, tblen;
1362 int ndatalines;
1363
1364 if (!cf->show_extra)
1365 return 0;
1366
1367 DBG(UI, ul_debug("draw extra"));
1368
1369 assert(ln->extra);
1370
1371 if (cf->act_win) {
1372 wclear(cf->act_win);
1373 touchwin(stdscr);
1374 }
1375
1376 if (scols_table_is_empty(ln->extra)) {
1377 extra_prepare_data(cf);
1378 if (scols_table_is_empty(ln->extra))
1379 return 0;
1380 }
1381
1382 ndatalines = fdisk_table_get_nents(cf->table) + 1;
1383
1384 /* nents + header + one free line */
1385 win_ex_start_line = TABLE_START_LINE + ndatalines;
1386 win_height = MENU_START_LINE - win_ex_start_line;
1387 tblen = scols_table_get_nlines(ln->extra);
1388
1389 /* we can't get a single line of data under the partlist*/
1390 if (win_height < 3)
1391 return 1;
1392
1393 /* number of data lines + 2 for top/bottom lines */
1394 win_height = win_height < tblen + 2 ? win_height : tblen + 2;
1395
1396 if ((size_t) win_ex_start_line + win_height + 1 < MENU_START_LINE)
1397 win_ex_start_line = MENU_START_LINE - win_height;
1398
1399 win_ex = subwin(stdscr, win_height, ui_cols - 2, win_ex_start_line, 1);
1400
1401 scols_table_reduce_termwidth(ln->extra, 4);
1402 scols_print_table_to_string(ln->extra, &tbstr);
1403
1404 end = tbstr;
1405 while ((end = strchr(end, '\n')))
1406 *end++ = '\0';
1407
1408 box(win_ex, 0, 0);
1409
1410 end = tbstr;
1411 while (--win_height > 1) {
1412 mvwaddstr(win_ex, wline++, 1 /* window column*/, tbstr);
1413 tbstr += strlen(tbstr) + 1;
1414 }
1415 free(end);
1416
1417 if (ln->w)
1418 delwin(ln->w);
1419
1420 DBG(UI, ul_debug("draw window: %p", win_ex));
1421 touchwin(stdscr);
1422 wrefresh(win_ex);
1423
1424 cf->act_win = ln->w = win_ex;
1425 return 0;
1426 }
1427
1428 static void ui_menu_goto(struct cfdisk *cf, int where)
1429 {
1430 struct cfdisk_menuitem *d;
1431 size_t old;
1432
1433 /* stop and begin/end for vertical menus */
1434 if (cf->menu->vertical) {
1435 if (where < 0)
1436 where = 0;
1437 else if (where > (int) cf->menu->nitems - 1)
1438 where = cf->menu->nitems - 1;
1439 } else {
1440 /* continue from begin/end */
1441 if (where < 0)
1442 where = cf->menu->nitems - 1;
1443 else if ((size_t) where > cf->menu->nitems - 1)
1444 where = 0;
1445 }
1446 if ((size_t) where == cf->menu->idx)
1447 return;
1448
1449 ui_clean_info();
1450
1451 old = cf->menu->idx;
1452 cf->menu->idx = where;
1453
1454 if (!menuitem_on_page(cf, old)) {
1455 ui_draw_menu(cf);
1456 return;
1457 }
1458
1459 d = menu_get_menuitem(cf, old);
1460 ui_draw_menuitem(cf, d, old);
1461
1462 d = menu_get_menuitem(cf, where);
1463 ui_draw_menuitem(cf, d, where);
1464
1465 }
1466
1467 static int ui_menu_move(struct cfdisk *cf, int key)
1468 {
1469 struct cfdisk_menu *m;
1470
1471 assert(cf);
1472 assert(cf->menu);
1473
1474 if (key == (int) ERR)
1475 return 0; /* ignore errors */
1476
1477 m = cf->menu;
1478
1479 DBG(MENU, ul_debug("menu move key >%c<.", key));
1480
1481 if (m->vertical)
1482 {
1483 switch (key) {
1484 case KEY_DOWN:
1485 case '\016': /* ^N */
1486 case 'j': /* Vi-like alternative */
1487 ui_menu_goto(cf, m->idx + 1);
1488 return 0;
1489 case KEY_UP:
1490 case '\020': /* ^P */
1491 case 'k': /* Vi-like alternative */
1492 ui_menu_goto(cf, (int) m->idx - 1);
1493 return 0;
1494 case KEY_PPAGE:
1495 if (m->page_sz) {
1496 ui_menu_goto(cf, (int) m->idx - m->page_sz);
1497 return 0;
1498 }
1499 /* fallthrough */
1500 case KEY_HOME:
1501 ui_menu_goto(cf, 0);
1502 return 0;
1503 case KEY_NPAGE:
1504 if (m->page_sz) {
1505 ui_menu_goto(cf, m->idx + m->page_sz);
1506 return 0;
1507 }
1508 /* fallthrough */
1509 case KEY_END:
1510 ui_menu_goto(cf, m->nitems);
1511 return 0;
1512 }
1513 } else {
1514 switch (key) {
1515 case KEY_RIGHT:
1516 case '\t':
1517 ui_menu_goto(cf, m->idx + 1);
1518 return 0;
1519 case KEY_LEFT:
1520 #ifdef KEY_BTAB
1521 case KEY_BTAB:
1522 #endif
1523 ui_menu_goto(cf, (int) m->idx - 1);
1524 return 0;
1525 }
1526 }
1527
1528 if (key == '\014') { /* ^L refresh */
1529 ui_menu_resize(cf);
1530 return 0;
1531 }
1532
1533 DBG(MENU, ul_debug(" no menu move key"));
1534 return 1;
1535 }
1536
1537 /* but don't call me from ui_run(), this is for pop-up menus only */
1538 static void ui_menu_resize(struct cfdisk *cf)
1539 {
1540 DBG(MENU, ul_debug("menu resize/refresh"));
1541 resize();
1542 ui_clean_menu(cf);
1543 menu_refresh_size(cf);
1544 ui_draw_menu(cf);
1545 refresh();
1546 }
1547
1548 static int partition_on_page(struct cfdisk *cf, size_t i)
1549 {
1550 if (cf->page_sz == 0 ||
1551 cf->lines_idx / cf->page_sz == i / cf->page_sz)
1552 return 1;
1553 return 0;
1554 }
1555
1556 static void ui_draw_partition(struct cfdisk *cf, size_t i)
1557 {
1558 int ln = TABLE_START_LINE + 1 + i; /* skip table header */
1559 int cl = ARROW_CURSOR_WIDTH; /* we need extra space for cursor */
1560 int cur = cf->lines_idx == i;
1561 size_t curpg = 0;
1562
1563 if (cf->page_sz) {
1564 if (!partition_on_page(cf, i))
1565 return;
1566 ln = TABLE_START_LINE + (i % cf->page_sz) + 1;
1567 curpg = cf->lines_idx / cf->page_sz;
1568 }
1569
1570 DBG(UI, ul_debug(
1571 "draw partition %zu [page_sz=%zu, "
1572 "line=%d, idx=%zu]",
1573 i, cf->page_sz, ln, cf->lines_idx));
1574
1575 if (cur) {
1576 attron(A_REVERSE);
1577 mvaddstr(ln, 0, ARROW_CURSOR_STRING);
1578 mvaddstr(ln, cl, cf->lines[i + 1].data);
1579 attroff(A_REVERSE);
1580 } else {
1581 int at = 0;
1582
1583 if (colors_wanted() && is_freespace(cf, i)) {
1584 attron(COLOR_PAIR(CFDISK_CL_FREESPACE));
1585 at = 1;
1586 }
1587 mvaddstr(ln, 0, ARROW_CURSOR_DUMMY);
1588 mvaddstr(ln, cl, cf->lines[i + 1].data);
1589 if (at)
1590 attroff(COLOR_PAIR(CFDISK_CL_FREESPACE));
1591 }
1592
1593 if ((size_t) ln == MENU_START_LINE - 1 &&
1594 cf->page_sz && curpg < cf->nlines / cf->page_sz) {
1595 if (cur)
1596 attron(A_REVERSE);
1597 mvaddch(ln, ui_cols - 1, ACS_DARROW);
1598 mvaddch(ln, 0, ACS_DARROW);
1599 if (cur)
1600 attroff(A_REVERSE);
1601 }
1602
1603 }
1604
1605 static int ui_draw_table(struct cfdisk *cf)
1606 {
1607 int cl = ARROW_CURSOR_WIDTH;
1608 size_t i, nparts = fdisk_table_get_nents(cf->table);
1609 size_t curpg = cf->page_sz ? cf->lines_idx / cf->page_sz : 0;
1610
1611 DBG(UI, ul_debug("draw table"));
1612
1613 for (i = TABLE_START_LINE; i <= TABLE_START_LINE + cf->page_sz; i++) {
1614 move(i, 0);
1615 clrtoeol();
1616 }
1617
1618 if (nparts == 0 || (size_t) cf->lines_idx > nparts - 1)
1619 cf->lines_idx = nparts ? nparts - 1 : 0;
1620
1621 /* print header */
1622 attron(A_BOLD);
1623 mvaddstr(TABLE_START_LINE, cl, cf->lines[0].data);
1624 attroff(A_BOLD);
1625
1626 /* print partitions */
1627 for (i = 0; i < nparts; i++)
1628 ui_draw_partition(cf, i);
1629
1630 if (curpg != 0) {
1631 mvaddch(TABLE_START_LINE, ui_cols - 1, ACS_UARROW);
1632 mvaddch(TABLE_START_LINE, 0, ACS_UARROW);
1633 }
1634 if (cf->page_sz && curpg < cf->nlines / cf->page_sz) {
1635 mvaddch(MENU_START_LINE - 1, ui_cols - 1, ACS_DARROW);
1636 mvaddch(MENU_START_LINE - 1, 0, ACS_DARROW);
1637 }
1638 return 0;
1639 }
1640
1641 static int ui_table_goto(struct cfdisk *cf, int where)
1642 {
1643 size_t old;
1644 size_t nparts = fdisk_table_get_nents(cf->table);
1645
1646 DBG(UI, ul_debug("goto table %d", where));
1647
1648 if (where < 0)
1649 where = 0;
1650 else if ((size_t) where > nparts - 1)
1651 where = nparts - 1;
1652
1653 if ((size_t) where == cf->lines_idx)
1654 return 0;
1655
1656 old = cf->lines_idx;
1657 cf->lines_idx = where;
1658
1659 if (!partition_on_page(cf, old) ||!partition_on_page(cf, where))
1660 ui_draw_table(cf);
1661 else {
1662 ui_draw_partition(cf, old); /* cleanup old */
1663 ui_draw_partition(cf, where); /* draw new */
1664 }
1665 ui_clean_info();
1666 ui_draw_menu(cf);
1667 ui_draw_extra(cf);
1668 refresh();
1669
1670 return 0;
1671 }
1672
1673 static int ui_refresh(struct cfdisk *cf)
1674 {
1675 struct fdisk_label *lb;
1676 char *id = NULL;
1677 uint64_t bytes = fdisk_get_nsectors(cf->cxt) * fdisk_get_sector_size(cf->cxt);
1678 char *strsz;
1679
1680 if (!ui_enabled)
1681 return -EINVAL;
1682
1683 strsz = size_to_human_string(SIZE_SUFFIX_SPACE
1684 | SIZE_SUFFIX_3LETTER, bytes);
1685
1686 lb = fdisk_get_label(cf->cxt, NULL);
1687 assert(lb);
1688
1689 clear();
1690
1691 /* header */
1692 attron(A_BOLD);
1693 ui_center(0, _("Disk: %s"), fdisk_get_devname(cf->cxt));
1694 attroff(A_BOLD);
1695 ui_center(1, _("Size: %s, %ju bytes, %ju sectors"),
1696 strsz, bytes, (uintmax_t) fdisk_get_nsectors(cf->cxt));
1697 if (fdisk_get_disklabel_id(cf->cxt, &id) == 0 && id)
1698 ui_center(2, _("Label: %s, identifier: %s"),
1699 fdisk_label_get_name(lb), id);
1700 else
1701 ui_center(2, _("Label: %s"), fdisk_label_get_name(lb));
1702 free(strsz);
1703
1704 ui_draw_table(cf);
1705 ui_draw_menu(cf);
1706 refresh();
1707 return 0;
1708 }
1709
1710 static ssize_t ui_get_string(const char *prompt,
1711 const char *hint, char *buf, size_t len)
1712 {
1713 int ln = MENU_START_LINE, cl = 1;
1714 ssize_t rc = -1;
1715 struct mbs_editor *edit;
1716
1717 DBG(UI, ul_debug("ui get string"));
1718
1719 assert(buf);
1720 assert(len);
1721
1722 move(ln, 0);
1723 clrtoeol();
1724
1725 move(ln + 1, 0);
1726 clrtoeol();
1727
1728 if (prompt) {
1729 mvaddstr(ln, cl, (char *) prompt);
1730 cl += mbs_safe_width(prompt);
1731 }
1732
1733 edit = mbs_new_edit(buf, len, ui_cols - cl);
1734 if (!edit)
1735 goto done;
1736
1737 mbs_edit_goto(edit, MBS_EDIT_END);
1738
1739 if (hint)
1740 ui_hint(hint);
1741 else
1742 ui_clean_hint();
1743
1744 curs_set(1);
1745
1746 while (1) {
1747 wint_t c; /* we have fallback in widechar.h */
1748
1749 move(ln, cl);
1750 clrtoeol();
1751 mvaddstr(ln, cl, edit->buf);
1752 move(ln, cl + edit->cursor_cells);
1753 refresh();
1754
1755 #if !defined(HAVE_SLCURSES_H) && !defined(HAVE_SLANG_SLCURSES_H) && \
1756 defined(HAVE_LIBNCURSESW) && defined(HAVE_WIDECHAR)
1757 if (get_wch(&c) == ERR) {
1758 #else
1759 if ((c = getch()) == (wint_t) ERR) {
1760 #endif
1761 if (ui_resize) {
1762 resize();
1763 continue;
1764 }
1765 if (!isatty(STDIN_FILENO))
1766 exit(2);
1767 else
1768 goto done;
1769 }
1770
1771 DBG(UI, ul_debug("ui get string: key=%lc", c));
1772
1773 if (c == '\r' || c == '\n' || c == KEY_ENTER)
1774 break;
1775
1776 rc = 1;
1777
1778 switch (c) {
1779 case KEY_ESC:
1780 rc = -CFDISK_ERR_ESC;
1781 goto done;
1782 case KEY_LEFT:
1783 rc = mbs_edit_goto(edit, MBS_EDIT_LEFT);
1784 break;
1785 case KEY_RIGHT:
1786 rc = mbs_edit_goto(edit, MBS_EDIT_RIGHT);
1787 break;
1788 case KEY_END:
1789 rc = mbs_edit_goto(edit, MBS_EDIT_END);
1790 break;
1791 case KEY_HOME:
1792 rc = mbs_edit_goto(edit, MBS_EDIT_HOME);
1793 break;
1794 case KEY_UP:
1795 case KEY_DOWN:
1796 break;
1797 case KEY_DC:
1798 rc = mbs_edit_delete(edit);
1799 break;
1800 case '\b':
1801 case KEY_BACKSPACE:
1802 rc = mbs_edit_backspace(edit);
1803 break;
1804 default:
1805 rc = mbs_edit_insert(edit, c);
1806 break;
1807 }
1808 if (rc == 1)
1809 beep();
1810 }
1811
1812 rc = strlen(edit->buf); /* success */
1813 done:
1814 move(ln, 0);
1815 clrtoeol();
1816 curs_set(0);
1817 refresh();
1818 mbs_free_edit(edit);
1819
1820 return rc;
1821 }
1822
1823 /* @res is default value as well as result in bytes */
1824 static int ui_get_size(struct cfdisk *cf, const char *prompt, uintmax_t *res,
1825 uintmax_t low, uintmax_t up, int *expsize)
1826 {
1827 char buf[128];
1828 uintmax_t user = 0;
1829 ssize_t rc;
1830 char *dflt = size_to_human_string(0, *res);
1831
1832 DBG(UI, ul_debug("get_size (default=%ju)", *res));
1833
1834 ui_clean_info();
1835
1836 snprintf(buf, sizeof(buf), "%s", dflt);
1837
1838 do {
1839 int pwr = 0, insec = 0;
1840
1841 rc = ui_get_string(prompt,
1842 _("May be followed by M for MiB, G for GiB, "
1843 "T for TiB, or S for sectors."),
1844 buf, sizeof(buf));
1845 ui_clean_warn();
1846
1847 if (rc == 0) {
1848 ui_warnx(_("Please, specify size."));
1849 continue; /* nothing specified */
1850 } else if (rc == -CFDISK_ERR_ESC)
1851 break; /* cancel dialog */
1852
1853 if (strcmp(buf, dflt) == 0)
1854 user = *res, rc = 0; /* no change, use default */
1855 else {
1856 size_t len = strlen(buf);
1857 if (buf[len - 1] == 'S' || buf[len - 1] == 's') {
1858 insec = 1;
1859 buf[len - 1] = '\0';
1860 }
1861 rc = parse_size(buf, &user, &pwr); /* parse */
1862 }
1863
1864 if (rc == 0) {
1865 DBG(UI, ul_debug("get_size user=%ju, power=%d, sectors=%s",
1866 user, pwr, insec ? "yes" : "no"));
1867 if (insec)
1868 user *= fdisk_get_sector_size(cf->cxt);
1869 if (user < low) {
1870 ui_warnx(_("Minimum size is %ju bytes."), low);
1871 rc = -ERANGE;
1872 }
1873 if (user > up && pwr && user < up + (1ULL << pwr * 10))
1874 /* ignore when the user specified size overflow
1875 * with in range specified by suffix (e.g. MiB) */
1876 user = up;
1877
1878 if (user > up) {
1879 ui_warnx(_("Maximum size is %ju bytes."), up);
1880 rc = -ERANGE;
1881 }
1882 if (rc == 0 && insec && expsize)
1883 *expsize = 1;
1884
1885 } else
1886 ui_warnx(_("Failed to parse size."));
1887 } while (rc != 0);
1888
1889 if (rc == 0)
1890 *res = user;
1891 free(dflt);
1892
1893 DBG(UI, ul_debug("get_size (result=%ju, rc=%zd)", *res, rc));
1894 return rc;
1895 }
1896
1897 static struct fdisk_parttype *ui_get_parttype(struct cfdisk *cf,
1898 struct fdisk_parttype *cur)
1899 {
1900 struct cfdisk_menuitem *d, *cm;
1901 size_t i = 0, nitems, idx = 0;
1902 struct fdisk_parttype *t = NULL;
1903 struct fdisk_label *lb;
1904 int codetypes = 0;
1905
1906 DBG(UI, ul_debug("asking for parttype."));
1907
1908 lb = fdisk_get_label(cf->cxt, NULL);
1909
1910 /* create cfdisk menu according to label types, note that the
1911 * last cm[] item has to be empty -- so nitems + 1 */
1912 nitems = fdisk_label_get_nparttypes(lb);
1913 if (!nitems)
1914 return NULL;
1915
1916 cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
1917 if (!cm)
1918 return NULL;
1919
1920 codetypes = fdisk_label_has_code_parttypes(lb);
1921
1922 for (i = 0; i < nitems; i++) {
1923 const struct fdisk_parttype *x = fdisk_label_get_parttype(lb, i);
1924 char *name;
1925
1926 cm[i].userdata = (void *) x;
1927 if (codetypes)
1928 xasprintf(&name, "%2x %s",
1929 fdisk_parttype_get_code(x),
1930 _(fdisk_parttype_get_name(x)));
1931 else {
1932 name = (char *) _(fdisk_parttype_get_name(x));
1933 cm[i].desc = fdisk_parttype_get_string(x);
1934 }
1935 cm[i].name = name;
1936 if (x == cur)
1937 idx = i;
1938 }
1939
1940 /* make the new menu active */
1941 menu_push(cf, cm);
1942 cf->menu->vertical = 1;
1943 cf->menu->idx = idx;
1944 menu_set_title(cf->menu, _("Select partition type"));
1945 ui_draw_menu(cf);
1946 refresh();
1947
1948 do {
1949 int key = getch();
1950
1951 if (ui_resize)
1952 ui_menu_resize(cf);
1953 if (ui_menu_move(cf, key) == 0)
1954 continue;
1955
1956 switch (key) {
1957 case KEY_ENTER:
1958 case '\n':
1959 case '\r':
1960 d = menu_get_menuitem(cf, cf->menu->idx);
1961 if (d)
1962 t = (struct fdisk_parttype *) d->userdata;
1963 goto done;
1964 case KEY_ESC:
1965 case 'q':
1966 case 'Q':
1967 goto done;
1968 }
1969 } while (1);
1970
1971 done:
1972 menu_pop(cf);
1973 if (codetypes) {
1974 for (i = 0; i < nitems; i++)
1975 free((char *) cm[i].name);
1976 }
1977 free(cm);
1978 DBG(UI, ul_debug("get parrtype done [type=%s] ", t ?
1979 fdisk_parttype_get_name(t) : NULL));
1980 return t;
1981 }
1982
1983 static int ui_script_read(struct cfdisk *cf)
1984 {
1985 struct fdisk_script *sc = NULL;
1986 char buf[PATH_MAX] = { 0 };
1987 int rc;
1988
1989 erase();
1990 rc = ui_get_string( _("Enter script file name: "),
1991 _("The script file will be applied to in-memory partition table."),
1992 buf, sizeof(buf));
1993 if (rc <= 0)
1994 return rc;
1995
1996 rc = -1;
1997 errno = 0;
1998 sc = fdisk_new_script_from_file(cf->cxt, buf);
1999 if (!sc && errno)
2000 ui_warn(_("Cannot open %s"), buf);
2001 else if (!sc)
2002 ui_warnx(_("Failed to parse script file %s"), buf);
2003 else if (fdisk_apply_script(cf->cxt, sc) != 0)
2004 ui_warnx(_("Failed to apply script %s"), buf);
2005 else
2006 rc = 0;
2007
2008 ui_clean_hint();
2009 fdisk_unref_script(sc);
2010 return rc;
2011 }
2012
2013 static int ui_script_write(struct cfdisk *cf)
2014 {
2015 struct fdisk_script *sc = NULL;
2016 char buf[PATH_MAX] = { 0 };
2017 FILE *f = NULL;
2018 int rc;
2019
2020 rc = ui_get_string( _("Enter script file name: "),
2021 _("The current in-memory partition table will be dumped to the file."),
2022 buf, sizeof(buf));
2023 if (rc <= 0)
2024 return rc;
2025
2026 rc = 0;
2027 sc = fdisk_new_script(cf->cxt);
2028 if (!sc) {
2029 ui_warn(_("Failed to allocate script handler"));
2030 goto done;
2031 }
2032
2033 rc = fdisk_script_read_context(sc, NULL);
2034 if (rc) {
2035 ui_warnx(_("Failed to read disk layout into script."));
2036 goto done;
2037 }
2038
2039 DBG(UI, ul_debug("writing dump into: '%s'", buf));
2040 f = fopen(buf, "w");
2041 if (!f) {
2042 ui_warn(_("Cannot open %s"), buf);
2043 rc = -errno;
2044 goto done;
2045 }
2046
2047 rc = fdisk_script_write_file(sc, f);
2048 if (!rc)
2049 ui_info(_("Disk layout successfully dumped."));
2050 done:
2051 if (rc)
2052 ui_warn(_("Failed to write script %s"), buf);
2053 if (f)
2054 fclose(f);
2055 fdisk_unref_script(sc);
2056 return rc;
2057 }
2058
2059 /* prints menu with libfdisk labels and waits for users response */
2060 static int ui_create_label(struct cfdisk *cf)
2061 {
2062 struct cfdisk_menuitem *d, *cm;
2063 int rc = 1, refresh_menu = 1;
2064 size_t i = 0, nitems;
2065 struct fdisk_label *lb = NULL;
2066
2067 assert(cf);
2068
2069 DBG(UI, ul_debug("asking for new disklabe."));
2070
2071 /* create cfdisk menu according to libfdisk labels, note that the
2072 * last cm[] item has to be empty -- so nitems + 1 */
2073 nitems = fdisk_get_nlabels(cf->cxt);
2074 cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
2075
2076 while (fdisk_next_label(cf->cxt, &lb) == 0) {
2077 if (fdisk_label_is_disabled(lb) ||
2078 fdisk_label_get_type(lb) == FDISK_DISKLABEL_BSD)
2079 continue;
2080 cm[i++].name = fdisk_label_get_name(lb);
2081 }
2082
2083 erase();
2084
2085 /* make the new menu active */
2086 menu_push(cf, cm);
2087 cf->menu->vertical = 1;
2088 menu_set_title(cf->menu, _("Select label type"));
2089
2090 if (!cf->zero_start)
2091 ui_info(_("Device does not contain a recognized partition table."));
2092
2093
2094 do {
2095 int key;
2096
2097 if (refresh_menu) {
2098 ui_draw_menu(cf);
2099 ui_hint(_("Select a type to create a new label or press 'L' to load script file."));
2100 refresh();
2101 refresh_menu = 0;
2102 }
2103
2104 key = getch();
2105
2106 if (ui_resize)
2107 ui_menu_resize(cf);
2108 if (ui_menu_move(cf, key) == 0)
2109 continue;
2110 switch (key) {
2111 case KEY_ENTER:
2112 case '\n':
2113 case '\r':
2114 d = menu_get_menuitem(cf, cf->menu->idx);
2115 if (d)
2116 rc = fdisk_create_disklabel(cf->cxt, d->name);
2117 goto done;
2118 case KEY_ESC:
2119 case 'q':
2120 case 'Q':
2121 goto done;
2122 case 'l':
2123 case 'L':
2124 rc = ui_script_read(cf);
2125 if (rc == 0)
2126 goto done;
2127 refresh_menu = 1;
2128 break;
2129 }
2130 } while (1);
2131
2132 done:
2133 menu_pop(cf);
2134 free(cm);
2135 DBG(UI, ul_debug("create label done [rc=%d] ", rc));
2136 return rc;
2137 }
2138
2139
2140 static int ui_help(void)
2141 {
2142 size_t i;
2143 static const char *help[] = {
2144 N_("This is cfdisk, a curses-based disk partitioning program."),
2145 N_("It lets you create, delete, and modify partitions on a block device."),
2146 " ",
2147 N_("Command Meaning"),
2148 N_("------- -------"),
2149 N_(" b Toggle bootable flag of the current partition"),
2150 N_(" d Delete the current partition"),
2151 N_(" h Print this screen"),
2152 N_(" n Create new partition from free space"),
2153 N_(" q Quit program without writing partition table"),
2154 N_(" s Fix partitions order (only when in disarray)"),
2155 N_(" t Change the partition type"),
2156 N_(" u Dump disk layout to sfdisk compatible script file"),
2157 N_(" W Write partition table to disk (you must enter uppercase W);"),
2158 N_(" since this might destroy data on the disk, you must either"),
2159 N_(" confirm or deny the write by entering 'yes' or 'no'"),
2160 N_(" x Display/hide extra information about a partition"),
2161 N_("Up Arrow Move cursor to the previous partition"),
2162 N_("Down Arrow Move cursor to the next partition"),
2163 N_("Left Arrow Move cursor to the previous menu item"),
2164 N_("Right Arrow Move cursor to the next menu item"),
2165 " ",
2166 N_("Note: All of the commands can be entered with either upper or lower"),
2167 N_("case letters (except for Write)."),
2168 " ",
2169 N_("Use lsblk(8) or partx(8) to see more details about the device."),
2170 " ",
2171 " ",
2172 "Copyright (C) 2014-2017 Karel Zak <kzak@redhat.com>"
2173 };
2174
2175 erase();
2176 for (i = 0; i < ARRAY_SIZE(help); i++)
2177 mvaddstr(i, 1, _(help[i]));
2178
2179 ui_info(_("Press a key to continue."));
2180
2181 getch();
2182 return 0;
2183 }
2184
2185 /* TODO: use @sz, now 128bytes */
2186 static int main_menu_ignore_keys(struct cfdisk *cf, char *ignore,
2187 size_t sz __attribute__((__unused__)))
2188 {
2189 struct fdisk_partition *pa = get_current_partition(cf);
2190 size_t i = 0;
2191
2192 if (!pa)
2193 return 0;
2194 if (fdisk_partition_is_freespace(pa)) {
2195 ignore[i++] = 'd'; /* delete */
2196 ignore[i++] = 't'; /* set type */
2197 ignore[i++] = 'b'; /* set bootable */
2198 cf->menu->prefkey = 'n';
2199 } else {
2200 cf->menu->prefkey = 'q';
2201 ignore[i++] = 'n';
2202 if (!fdisk_is_label(cf->cxt, DOS) &&
2203 !fdisk_is_label(cf->cxt, SGI))
2204 ignore[i++] = 'b';
2205 }
2206
2207 if (!cf->wrong_order)
2208 ignore[i++] = 's';
2209
2210 if (fdisk_is_readonly(cf->cxt))
2211 ignore[i++] = 'W';
2212
2213 return i;
2214 }
2215
2216
2217 /* returns: error: < 0, success: 0, quit: 1 */
2218 static int main_menu_action(struct cfdisk *cf, int key)
2219 {
2220 size_t n;
2221 int ref = 0, rc, org_order = cf->wrong_order;
2222 const char *info = NULL, *warn = NULL;
2223 struct fdisk_partition *pa;
2224
2225 assert(cf);
2226 assert(cf->cxt);
2227 assert(cf->menu);
2228
2229 if (key == 0) {
2230 struct cfdisk_menuitem *d = menu_get_menuitem(cf, cf->menu->idx);
2231 if (!d)
2232 return 0;
2233 key = d->key;
2234
2235 } else if (key != 'w' && key != 'W')
2236 key = tolower(key); /* case insensitive except 'W'rite */
2237
2238 DBG(MENU, ul_debug("main menu action: key=%c", key));
2239
2240 if (cf->menu->ignore && strchr(cf->menu->ignore, key)) {
2241 DBG(MENU, ul_debug(" ignore '%c'", key));
2242 return 0;
2243 }
2244
2245 pa = get_current_partition(cf);
2246 if (!pa)
2247 return -EINVAL;
2248 n = fdisk_partition_get_partno(pa);
2249
2250 DBG(MENU, ul_debug("menu action on %p", pa));
2251 ui_clean_hint();
2252 ui_clean_info();
2253
2254 switch (key) {
2255 case 'b': /* Bootable flag */
2256 {
2257 int fl = fdisk_is_label(cf->cxt, DOS) ? DOS_FLAG_ACTIVE :
2258 fdisk_is_label(cf->cxt, SGI) ? SGI_FLAG_BOOT : 0;
2259
2260 if (fl && fdisk_toggle_partition_flag(cf->cxt, n, fl))
2261 warn = _("Could not toggle the flag.");
2262 else if (fl)
2263 ref = 1;
2264 break;
2265 }
2266 #ifdef KEY_DC
2267 case KEY_DC:
2268 #endif
2269 case 'd': /* Delete */
2270 if (fdisk_delete_partition(cf->cxt, n) != 0)
2271 warn = _("Could not delete partition %zu.");
2272 else
2273 info = _("Partition %zu has been deleted.");
2274 ref = 1;
2275 break;
2276 case 'h': /* Help */
2277 case '?':
2278 ui_help();
2279 ref = 1;
2280 break;
2281 case 'n': /* New */
2282 {
2283 uint64_t start, size, dflt_size, secs;
2284 struct fdisk_partition *npa; /* the new partition */
2285 int expsize = 0; /* size specified explicitly in sectors */
2286
2287 if (!fdisk_partition_is_freespace(pa) || !fdisk_partition_has_start(pa))
2288 return -EINVAL;
2289
2290 /* free space range */
2291 start = fdisk_partition_get_start(pa);
2292 size = dflt_size = fdisk_partition_get_size(pa) * fdisk_get_sector_size(cf->cxt);
2293
2294 if (ui_get_size(cf, _("Partition size: "), &size,
2295 fdisk_get_sector_size(cf->cxt),
2296 size, &expsize) == -CFDISK_ERR_ESC)
2297 break;
2298
2299 secs = size / fdisk_get_sector_size(cf->cxt);
2300
2301 npa = fdisk_new_partition();
2302 if (!npa)
2303 return -ENOMEM;
2304
2305 if (dflt_size == size) /* default is to fillin all free space */
2306 fdisk_partition_end_follow_default(npa, 1);
2307 else
2308 fdisk_partition_set_size(npa, secs);
2309
2310 if (expsize)
2311 fdisk_partition_size_explicit(pa, 1);
2312
2313 fdisk_partition_set_start(npa, start);
2314 fdisk_partition_partno_follow_default(npa, 1);
2315 /* add to disk label -- libfdisk will ask for missing details */
2316 rc = fdisk_add_partition(cf->cxt, npa, NULL);
2317 fdisk_unref_partition(npa);
2318 if (rc == 0)
2319 ref = 1;
2320 break;
2321 }
2322 case 'q': /* Quit */
2323 return 1;
2324 case 't': /* Type */
2325 {
2326 struct fdisk_parttype *t;
2327
2328 if (fdisk_partition_is_freespace(pa))
2329 return -EINVAL;
2330 t = (struct fdisk_parttype *) fdisk_partition_get_type(pa);
2331 t = ui_get_parttype(cf, t);
2332 ref = 1;
2333
2334 if (t && fdisk_set_partition_type(cf->cxt, n, t) == 0)
2335 info = _("Changed type of partition %zu.");
2336 else
2337 info = _("The type of partition %zu is unchanged.");
2338 break;
2339 }
2340 case 's': /* Sort */
2341 if (cf->wrong_order) {
2342 fdisk_reorder_partitions(cf->cxt);
2343 ref = 1;
2344 }
2345 break;
2346 case 'u': /* dUmp */
2347 ui_script_write(cf);
2348 break;
2349 case 'W': /* Write */
2350 {
2351 char buf[64] = { 0 };
2352
2353 if (fdisk_is_readonly(cf->cxt)) {
2354 warn = _("Device is open in read-only mode.");
2355 break;
2356 }
2357
2358 rc = ui_get_string(
2359 _("Are you sure you want to write the partition "
2360 "table to disk? "),
2361 _("Type \"yes\" or \"no\", or press ESC to leave this dialog."),
2362 buf, sizeof(buf));
2363
2364 ref = 1;
2365 if (rc <= 0 || (strcasecmp(buf, "yes") != 0 &&
2366 strcasecmp(buf, _("yes")) != 0)) {
2367 info = _("Did not write partition table to disk.");
2368 break;
2369 }
2370 rc = fdisk_write_disklabel(cf->cxt);
2371 if (rc)
2372 warn = _("Failed to write disklabel.");
2373 else {
2374 fdisk_reread_partition_table(cf->cxt);
2375 info = _("The partition table has been altered.");
2376 }
2377 cf->nwrites++;
2378 break;
2379 }
2380 default:
2381 break;
2382 }
2383
2384 if (ref) {
2385 lines_refresh(cf);
2386 ui_refresh(cf);
2387 ui_draw_extra(cf);
2388 } else
2389 ui_draw_menu(cf);
2390
2391 ui_clean_hint();
2392
2393 if (warn)
2394 ui_warnx(warn, n + 1);
2395 else if (info)
2396 ui_info(info, n + 1);
2397 else if (key == 'n' && cf->wrong_order && org_order == 0)
2398 ui_info(_("Note that partition table entries are not in disk order now."));
2399
2400 return 0;
2401 }
2402
2403 static void ui_resize_refresh(struct cfdisk *cf)
2404 {
2405 DBG(UI, ul_debug("ui resize/refresh"));
2406 resize();
2407 menu_refresh_size(cf);
2408 lines_refresh(cf);
2409 ui_refresh(cf);
2410 ui_draw_extra(cf);
2411 }
2412
2413 static void toggle_show_extra(struct cfdisk *cf)
2414 {
2415 if (cf->show_extra && cf->act_win) {
2416 wclear(cf->act_win);
2417 touchwin(stdscr);
2418 }
2419 cf->show_extra = cf->show_extra ? 0 : 1;
2420
2421 if (cf->show_extra)
2422 ui_draw_extra(cf);
2423 DBG(MENU, ul_debug("extra: %s", cf->show_extra ? "ENABLED" : "DISABLED" ));
2424 }
2425
2426 static int ui_run(struct cfdisk *cf)
2427 {
2428 int rc = 0;
2429
2430 ui_lines = LINES;
2431 ui_cols = COLS;
2432 DBG(UI, ul_debug("start cols=%zu, lines=%zu", ui_cols, ui_lines));
2433
2434 if (fdisk_get_collision(cf->cxt)) {
2435 ui_warnx(_("Device already contains a %s signature; it will be removed by a write command."),
2436 fdisk_get_collision(cf->cxt));
2437 fdisk_enable_wipe(cf->cxt, 1);
2438 ui_hint(_("Press a key to continue."));
2439 getch();
2440 }
2441
2442 if (!fdisk_has_label(cf->cxt) || cf->zero_start) {
2443 rc = ui_create_label(cf);
2444 if (rc < 0)
2445 ui_errx(EXIT_FAILURE,
2446 _("failed to create a new disklabel"));
2447 if (rc)
2448 return rc;
2449 }
2450
2451 cols_init(cf);
2452 rc = lines_refresh(cf);
2453 if (rc)
2454 ui_errx(EXIT_FAILURE, _("failed to read partitions"));
2455
2456 menu_push(cf, main_menuitems);
2457 cf->menu->ignore_cb = main_menu_ignore_keys;
2458
2459 rc = ui_refresh(cf);
2460 if (rc)
2461 return rc;
2462
2463 cf->show_extra = 1;
2464 ui_draw_extra(cf);
2465
2466 if (fdisk_is_readonly(cf->cxt))
2467 ui_warnx(_("Device is open in read-only mode."));
2468 else if (cf->wrong_order)
2469 ui_info(_("Note that partition table entries are not in disk order now."));
2470
2471 do {
2472 int key = getch();
2473
2474 rc = 0;
2475 if (ui_resize)
2476 /* Note that ncurses getch() returns ERR when interrupted
2477 * by signal, but SLang does not interrupt at all. */
2478 ui_resize_refresh(cf);
2479 if (key == ERR)
2480 continue;
2481 if (key == '\014') { /* ^L refresh */
2482 ui_resize_refresh(cf);
2483 continue;
2484 }
2485 if (ui_menu_move(cf, key) == 0)
2486 continue;
2487
2488 DBG(UI, ul_debug("main action key >%1$c< [\\0%1$o].", key));
2489
2490 switch (key) {
2491 case KEY_DOWN:
2492 case '\016': /* ^N */
2493 case 'j': /* Vi-like alternative */
2494 ui_table_goto(cf, cf->lines_idx + 1);
2495 break;
2496 case KEY_UP:
2497 case '\020': /* ^P */
2498 case 'k': /* Vi-like alternative */
2499 ui_table_goto(cf, (int) cf->lines_idx - 1);
2500 break;
2501 case KEY_PPAGE:
2502 if (cf->page_sz) {
2503 ui_table_goto(cf, (int) cf->lines_idx - cf->page_sz);
2504 break;
2505 }
2506 /* fallthrough */
2507 case KEY_HOME:
2508 ui_table_goto(cf, 0);
2509 break;
2510 case KEY_NPAGE:
2511 if (cf->page_sz) {
2512 ui_table_goto(cf, cf->lines_idx + cf->page_sz);
2513 break;
2514 }
2515 /* fallthrough */
2516 case KEY_END:
2517 ui_table_goto(cf, (int) cf->nlines - 1);
2518 break;
2519 case KEY_ENTER:
2520 case '\n':
2521 case '\r':
2522 rc = main_menu_action(cf, 0);
2523 break;
2524 case 'X':
2525 case 'x': /* Extra */
2526 toggle_show_extra(cf);
2527 break;
2528 default:
2529 rc = main_menu_action(cf, key);
2530 if (rc < 0)
2531 beep();
2532 break;
2533 }
2534
2535 if (rc == 1)
2536 break; /* quit */
2537 } while (1);
2538
2539 menu_pop(cf);
2540
2541 DBG(UI, ul_debug("end"));
2542 return 0;
2543 }
2544
2545 static void __attribute__((__noreturn__)) usage(void)
2546 {
2547 FILE *out = stdout;
2548 fputs(USAGE_HEADER, out);
2549 fprintf(out,
2550 _(" %1$s [options] <disk>\n"), program_invocation_short_name);
2551
2552 fputs(USAGE_SEPARATOR, out);
2553 fputs(_("Display or manipulate a disk partition table.\n"), out);
2554
2555 fputs(USAGE_OPTIONS, out);
2556 fputs(_(" -L, --color[=<when>] colorize output (auto, always or never)\n"), out);
2557 fprintf(out,
2558 " %s\n", USAGE_COLORS_DEFAULT);
2559 fputs(_(" -z, --zero start with zeroed partition table\n"), out);
2560
2561 fputs(USAGE_SEPARATOR, out);
2562 fputs(USAGE_HELP, out);
2563 fputs(USAGE_VERSION, out);
2564
2565 fprintf(out, USAGE_MAN_TAIL("cfdisk(8)"));
2566 exit(EXIT_SUCCESS);
2567 }
2568
2569 int main(int argc, char *argv[])
2570 {
2571 const char *diskpath = NULL;
2572 int rc, c, colormode = UL_COLORMODE_UNDEF;
2573 struct cfdisk _cf = { .lines_idx = 0 },
2574 *cf = &_cf;
2575
2576 static const struct option longopts[] = {
2577 { "color", optional_argument, NULL, 'L' },
2578 { "help", no_argument, NULL, 'h' },
2579 { "version", no_argument, NULL, 'V' },
2580 { "zero", no_argument, NULL, 'z' },
2581 { NULL, 0, NULL, 0 },
2582 };
2583
2584 setlocale(LC_ALL, "");
2585 bindtextdomain(PACKAGE, LOCALEDIR);
2586 textdomain(PACKAGE);
2587 atexit(close_stdout);
2588
2589 while((c = getopt_long(argc, argv, "L::hVz", longopts, NULL)) != -1) {
2590 switch(c) {
2591 case 'h':
2592 usage();
2593 break;
2594 case 'L':
2595 colormode = UL_COLORMODE_AUTO;
2596 if (optarg)
2597 colormode = colormode_or_err(optarg,
2598 _("unsupported color mode"));
2599 break;
2600 case 'V':
2601 printf(UTIL_LINUX_VERSION);
2602 return EXIT_SUCCESS;
2603 case 'z':
2604 cf->zero_start = 1;
2605 break;
2606 default:
2607 errtryhelp(EXIT_FAILURE);
2608 }
2609 }
2610
2611 colors_init(colormode, "cfdisk");
2612
2613 fdisk_init_debug(0);
2614 scols_init_debug(0);
2615 cfdisk_init_debug();
2616 cf->cxt = fdisk_new_context();
2617 if (!cf->cxt)
2618 err(EXIT_FAILURE, _("failed to allocate libfdisk context"));
2619
2620 fdisk_set_ask(cf->cxt, ask_callback, (void *) cf);
2621
2622 if (optind == argc) {
2623 size_t i;
2624
2625 for (i = 0; i < ARRAY_SIZE(default_disks); i++) {
2626 if (access(default_disks[i], F_OK) == 0) {
2627 diskpath = default_disks[i];
2628 break;
2629 }
2630 }
2631 if (!diskpath)
2632 diskpath = default_disks[0]; /* default, used for "cannot open" */
2633 } else
2634 diskpath = argv[optind];
2635
2636 rc = fdisk_assign_device(cf->cxt, diskpath, 0);
2637 if (rc == -EACCES)
2638 rc = fdisk_assign_device(cf->cxt, diskpath, 1);
2639 if (rc != 0)
2640 err(EXIT_FAILURE, _("cannot open %s"), diskpath);
2641
2642 /* Don't use err(), warn() from this point */
2643 ui_init(cf);
2644 ui_run(cf);
2645 ui_end();
2646
2647 cfdisk_free_lines(cf);
2648 free(cf->linesbuf);
2649
2650 fdisk_unref_table(cf->table);
2651 #ifdef HAVE_LIBMOUNT
2652 mnt_unref_table(cf->fstab);
2653 mnt_unref_table(cf->mtab);
2654 mnt_unref_cache(cf->mntcache);
2655 #endif
2656 rc = fdisk_deassign_device(cf->cxt, cf->nwrites == 0);
2657 fdisk_unref_context(cf->cxt);
2658 DBG(MISC, ul_debug("bye! [rc=%d]", rc));
2659 return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
2660 }
Unnamed repository; edit this file 'description' to name the repository.