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