disk-utils/fdisk-menu.c

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include <stdint.h>
   7
   8 #include "c.h"
   9 #include "rpmatch.h"
  10 #include "fdisk.h"
  11 #include "pt-sun.h"
  12 #include "pt-mbr.h"
  13
  14 struct menu_entry {
  15         const char      key;                    /* command key */
  16         const char      *title;                 /* help string */
  17         unsigned int    normal : 1,             /* normal mode */
  18                         expert : 1,             /* expert mode */
  19                         hidden : 1;             /* be sensitive for this key,
  20                                                    but don't print it in help */
  21
  22         enum fdisk_labeltype    label;          /* only for this label */
  23         int                     exclude;    /* all labels except these */
  24         enum fdisk_labeltype    parent;         /* for nested PT */
  25 };
  26
  27 #define IS_MENU_SEP(e)  ((e)->key == '-')
  28 #define IS_MENU_HID(e)  ((e)->hidden)
  29
  30 struct menu {
  31         enum fdisk_labeltype    label;          /* only for this label */
  32         int                     exclude;    /* all labels except these */
  33
  34         unsigned int            nonested : 1;   /* don't make this menu active in nested PT */
  35
  36         int (*callback)(struct fdisk_context **,
  37                         const struct menu *,
  38                         const struct menu_entry *);
  39
  40         struct menu_entry       entries[];      /* NULL terminated array */
  41 };
  42
  43 struct menu_context {
  44         size_t          menu_idx;               /* the current menu */
  45         size_t          entry_idx;              /* index with in the current menu */
  46 };
  47
  48 #define MENU_CXT_EMPTY  { 0, 0 }
  49 #define DECLARE_MENU_CB(x) \
  50         static int x(struct fdisk_context **, \
  51                      const struct menu *, \
  52                      const struct menu_entry *)
  53
  54 DECLARE_MENU_CB(gpt_menu_cb);
  55 DECLARE_MENU_CB(sun_menu_cb);
  56 DECLARE_MENU_CB(sgi_menu_cb);
  57 DECLARE_MENU_CB(geo_menu_cb);
  58 DECLARE_MENU_CB(dos_menu_cb);
  59 DECLARE_MENU_CB(bsd_menu_cb);
  60 DECLARE_MENU_CB(createlabel_menu_cb);
  61 DECLARE_MENU_CB(generic_menu_cb);
  62
  63 /*
  64  * Menu entry macros:
  65  *      MENU_X*    expert mode only
  66  *      MENU_B*    both -- expert + normal mode
  67  *
  68  *      *_E  exclude this label
  69  *      *_H  hidden
  70  *      *_L  only for this label
  71  */
  72
  73 /* separator */
  74 #define MENU_SEP(t)             { .title = t, .key = '-', .normal = 1 }
  75 #define MENU_XSEP(t)            { .title = t, .key = '-', .expert = 1 }
  76 #define MENU_BSEP(t)            { .title = t, .key = '-', .expert = 1, .normal = 1 }
  77
  78 /* entry */
  79 #define MENU_ENT(k, t)          { .title = t, .key = k, .normal = 1 }
  80 #define MENU_ENT_E(k, t, l)     { .title = t, .key = k, .normal = 1, .exclude = l }
  81 #define MENU_ENT_L(k, t, l)     { .title = t, .key = k, .normal = 1, .label = l }
  82
  83 #define MENU_XENT(k, t)         { .title = t, .key = k, .expert = 1 }
  84 #define MENU_XENT_H(k, t)       { .title = t, .key = k, .expert = 1, .hidden = 1 }
  85
  86 #define MENU_BENT(k, t)         { .title = t, .key = k, .expert = 1, .normal = 1 }
  87 #define MENU_BENT_E(k, t, l)    { .title = t, .key = k, .expert = 1, .normal = 1, .exclude = l }
  88
  89 #define MENU_ENT_NEST(k, t, l, p)       { .title = t, .key = k, .normal = 1, .label = l, .parent = p }
  90 #define MENU_BENT_NEST_H(k, t, l, p)    { .title = t, .key = k, .expert = 1, .normal = 1, .label = l, .parent = p, .hidden = 1 }
  91
  92 /* Generic menu */
  93 static const struct menu menu_generic = {
  94         .callback       = generic_menu_cb,
  95         .entries        = {
  96                 MENU_BSEP(N_("Generic")),
  97                 MENU_ENT  ('d', N_("delete a partition")),
  98                 MENU_ENT  ('F', N_("list free unpartitioned space")),
  99                 MENU_ENT  ('l', N_("list known partition types")),
 100                 MENU_ENT  ('n', N_("add a new partition")),
 101                 MENU_BENT ('p', N_("print the partition table")),
 102                 MENU_ENT  ('t', N_("change a partition type")),
 103                 MENU_BENT_E('v', N_("verify the partition table"), FDISK_DISKLABEL_BSD),
 104                 MENU_ENT  ('i', N_("print information about a partition")),
 105
 106                 MENU_XENT('d', N_("print the raw data of the first sector from the device")),
 107                 MENU_XENT('D', N_("print the raw data of the disklabel from the device")),
 108                 MENU_XENT('f', N_("fix partitions order")),
 109
 110                 MENU_SEP(N_("Misc")),
 111                 MENU_BENT ('m', N_("print this menu")),
 112                 MENU_ENT_E('u', N_("change display/entry units"), FDISK_DISKLABEL_GPT),
 113                 MENU_ENT_E('x', N_("extra functionality (experts only)"), FDISK_DISKLABEL_BSD),
 114
 115                 MENU_SEP(N_("Script")),
 116                 MENU_ENT  ('I', N_("load disk layout from sfdisk script file")),
 117                 MENU_ENT  ('O', N_("dump disk layout to sfdisk script file")),
 118
 119                 MENU_BSEP(N_("Save & Exit")),
 120                 MENU_ENT_E('w', N_("write table to disk and exit"), FDISK_DISKLABEL_BSD),
 121                 MENU_ENT_L('w', N_("write table to disk"), FDISK_DISKLABEL_BSD),
 122                 MENU_BENT ('q', N_("quit without saving changes")),
 123                 MENU_XENT ('r', N_("return to main menu")),
 124
 125                 MENU_ENT_NEST('r', N_("return from BSD to DOS (MBR)"), FDISK_DISKLABEL_BSD, FDISK_DISKLABEL_DOS),
 126
 127                 MENU_ENT_NEST('r', N_("return from protective/hybrid MBR to GPT"), FDISK_DISKLABEL_DOS, FDISK_DISKLABEL_GPT),
 128
 129                 { 0, NULL }
 130         }
 131 };
 132
 133 static const struct menu menu_createlabel = {
 134         .callback = createlabel_menu_cb,
 135         .exclude = FDISK_DISKLABEL_BSD,
 136         .nonested = 1,
 137         .entries = {
 138                 MENU_SEP(N_("Create a new label")),
 139                 MENU_ENT('g', N_("create a new empty GPT partition table")),
 140                 MENU_ENT('G', N_("create a new empty SGI (IRIX) partition table")),
 141                 MENU_ENT('o', N_("create a new empty MBR (DOS) partition table")),
 142                 MENU_ENT('s', N_("create a new empty Sun partition table")),
 143
 144                 /* backward compatibility -- be sensitive to 'g', but don't
 145                  * print it in the expert menu */
 146                 MENU_XENT_H('g', N_("create an IRIX (SGI) partition table")),
 147                 { 0, NULL }
 148         }
 149 };
 150
 151 static const struct menu menu_geo = {
 152         .callback = geo_menu_cb,
 153         .exclude = FDISK_DISKLABEL_GPT | FDISK_DISKLABEL_BSD,
 154         .entries = {
 155                 MENU_XSEP(N_("Geometry (for the current label)")),
 156                 MENU_XENT('c', N_("change number of cylinders")),
 157                 MENU_XENT('h', N_("change number of heads")),
 158                 MENU_XENT('s', N_("change number of sectors/track")),
 159                 { 0, NULL }
 160         }
 161 };
 162
 163 static const struct menu menu_gpt = {
 164         .callback = gpt_menu_cb,
 165         .label = FDISK_DISKLABEL_GPT,
 166         .entries = {
 167                 MENU_BSEP(N_("GPT")),
 168                 MENU_XENT('i', N_("change disk GUID")),
 169                 MENU_XENT('n', N_("change partition name")),
 170                 MENU_XENT('u', N_("change partition UUID")),
 171                 MENU_XENT('l', N_("change table length")),
 172                 MENU_BENT('M', N_("enter protective/hybrid MBR")),
 173
 174                 MENU_XSEP(""),
 175                 MENU_XENT('A', N_("toggle the legacy BIOS bootable flag")),
 176                 MENU_XENT('B', N_("toggle the no block IO protocol flag")),
 177                 MENU_XENT('R', N_("toggle the required partition flag")),
 178                 MENU_XENT('S', N_("toggle the GUID specific bits")),
 179
 180                 { 0, NULL }
 181         }
 182 };
 183
 184 static const struct menu menu_sun = {
 185         .callback = sun_menu_cb,
 186         .label = FDISK_DISKLABEL_SUN,
 187         .entries = {
 188                 MENU_BSEP(N_("Sun")),
 189                 MENU_ENT('a', N_("toggle the read-only flag")),
 190                 MENU_ENT('c', N_("toggle the mountable flag")),
 191
 192                 MENU_XENT('a', N_("change number of alternate cylinders")),
 193                 MENU_XENT('e', N_("change number of extra sectors per cylinder")),
 194                 MENU_XENT('i', N_("change interleave factor")),
 195                 MENU_XENT('o', N_("change rotation speed (rpm)")),
 196                 MENU_XENT('y', N_("change number of physical cylinders")),
 197                 { 0, NULL }
 198         }
 199 };
 200
 201 static const struct menu menu_sgi = {
 202         .callback = sgi_menu_cb,
 203         .label = FDISK_DISKLABEL_SGI,
 204         .entries = {
 205                 MENU_SEP(N_("SGI")),
 206                 MENU_ENT('a', N_("select bootable partition")),
 207                 MENU_ENT('b', N_("edit bootfile entry")),
 208                 MENU_ENT('c', N_("select sgi swap partition")),
 209                 MENU_ENT('i', N_("create SGI info")),
 210                 { 0, NULL }
 211         }
 212 };
 213
 214 static const struct menu menu_dos = {
 215         .callback = dos_menu_cb,
 216         .label = FDISK_DISKLABEL_DOS,
 217         .entries = {
 218                 MENU_BSEP(N_("DOS (MBR)")),
 219                 MENU_ENT('a', N_("toggle a bootable flag")),
 220                 MENU_ENT('b', N_("edit nested BSD disklabel")),
 221                 MENU_ENT('c', N_("toggle the dos compatibility flag")),
 222
 223                 MENU_XENT('b', N_("move beginning of data in a partition")),
 224                 MENU_XENT('F', N_("fix partitions C/H/S values")),
 225                 MENU_XENT('i', N_("change the disk identifier")),
 226
 227                 MENU_BENT_NEST_H('M', N_("return from protective/hybrid MBR to GPT"), FDISK_DISKLABEL_DOS, FDISK_DISKLABEL_GPT),
 228
 229                 { 0, NULL }
 230         }
 231 };
 232
 233 static const struct menu menu_bsd = {
 234         .callback = bsd_menu_cb,
 235         .label = FDISK_DISKLABEL_BSD,
 236         .entries = {
 237                 MENU_SEP(N_("BSD")),
 238                 MENU_ENT('e', N_("edit drive data")),
 239                 MENU_ENT('i', N_("install bootstrap")),
 240                 MENU_ENT('s', N_("show complete disklabel")),
 241                 MENU_ENT('x', N_("link BSD partition to non-BSD partition")),
 242                 { 0, NULL }
 243         }
 244 };
 245
 246 static const struct menu *menus[] = {
 247         &menu_gpt,
 248         &menu_sun,
 249         &menu_sgi,
 250         &menu_dos,
 251         &menu_bsd,
 252         &menu_geo,
 253         &menu_generic,
 254         &menu_createlabel,
 255 };
 256
 257 static const struct menu_entry *next_menu_entry(
 258                         struct fdisk_context *cxt,
 259                         struct menu_context *mc)
 260 {
 261         struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
 262         struct fdisk_context *parent = fdisk_get_parent(cxt);
 263         unsigned int type = 0, pr_type = 0;
 264
 265         assert(cxt);
 266
 267         if (lb)
 268                 type = fdisk_label_get_type(lb);
 269         if (parent)
 270                 pr_type = fdisk_label_get_type(fdisk_get_label(parent, NULL));
 271
 272         while (mc->menu_idx < ARRAY_SIZE(menus)) {
 273                 const struct menu *m = menus[mc->menu_idx];
 274                 const struct menu_entry *e = &(m->entries[mc->entry_idx]);
 275
 276                 /*
 277                  * whole-menu filter
 278                  */
 279
 280                 /* no more entries */
 281                 if (e->title == NULL ||
 282                 /* menu wanted for specified labels only */
 283                     (m->label && (!lb || !(m->label & type))) ||
 284                 /* unwanted for nested PT */
 285                     (m->nonested && parent) ||
 286                 /* menu excluded for specified labels */
 287                     (m->exclude && lb && (m->exclude & type))) {
 288                         mc->menu_idx++;
 289                         mc->entry_idx = 0;
 290                         continue;
 291                 }
 292
 293                 /*
 294                  * per entry filter
 295                  */
 296
 297                 /* excluded for the current label */
 298                 if ((e->exclude && lb && e->exclude & type) ||
 299                 /* entry wanted for specified labels only */
 300                     (e->label && (!lb || !(e->label & type))) ||
 301                 /* exclude non-expert entries in expect mode */
 302                     (e->expert == 0 && fdisk_is_details(cxt)) ||
 303                 /* nested only */
 304                     (e->parent && (!parent || pr_type != e->parent)) ||
 305                 /* exclude non-normal entries in normal mode */
 306                     (e->normal == 0 && !fdisk_is_details(cxt))) {
 307                         mc->entry_idx++;
 308                         continue;
 309                 }
 310                 mc->entry_idx++;
 311                 return e;
 312
 313         }
 314         return NULL;
 315 }
 316
 317 /* returns @menu and menu entry for then @key */
 318 static const struct menu_entry *get_fdisk_menu_entry(
 319                 struct fdisk_context *cxt,
 320                 int key,
 321                 const struct menu **menu)
 322 {
 323         struct menu_context mc = MENU_CXT_EMPTY;
 324         const struct menu_entry *e;
 325
 326         while ((e = next_menu_entry(cxt, &mc))) {
 327                 if (IS_MENU_SEP(e) || e->key != key)
 328                         continue;
 329
 330                 if (menu)
 331                         *menu = menus[mc.menu_idx];
 332                 return e;
 333         }
 334
 335         return NULL;
 336 }
 337
 338 static int menu_detect_collisions(struct fdisk_context *cxt)
 339 {
 340         struct menu_context mc = MENU_CXT_EMPTY;
 341         const struct menu_entry *e, *r;
 342
 343         while ((e = next_menu_entry(cxt, &mc))) {
 344                 if (IS_MENU_SEP(e))
 345                         continue;
 346
 347                 r = get_fdisk_menu_entry(cxt, e->key, NULL);
 348                 if (!r) {
 349                         DBG(MENU, ul_debug("warning: not found "
 350                                         "entry for %c", e->key));
 351                         return -1;
 352                 }
 353                 if (r != e) {
 354                         DBG(MENU, ul_debug("warning: duplicate key '%c'",
 355                                                 e->key));
 356                         DBG(MENU, ul_debug("       : %s", e->title));
 357                         DBG(MENU, ul_debug("       : %s", r->title));
 358                         abort();
 359                 }
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int print_fdisk_menu(struct fdisk_context *cxt)
 366 {
 367         struct menu_context mc = MENU_CXT_EMPTY;
 368         const struct menu_entry *e;
 369
 370         ON_DBG(MENU, menu_detect_collisions(cxt));
 371
 372         if (fdisk_is_details(cxt))
 373                 printf(_("\nHelp (expert commands):\n"));
 374         else
 375                 printf(_("\nHelp:\n"));
 376
 377         while ((e = next_menu_entry(cxt, &mc))) {
 378                 if (IS_MENU_HID(e))
 379                         continue;       /* hidden entry */
 380                 if (IS_MENU_SEP(e) && (!e->title || !*e->title))
 381                         printf("\n");
 382                 else if (IS_MENU_SEP(e)) {
 383                         color_scheme_enable("help-title", UL_COLOR_BOLD);
 384                         printf("\n  %s\n", _(e->title));
 385                         color_disable();
 386                 } else
 387                         printf("   %c   %s\n", e->key, _(e->title));
 388         }
 389         fputc('\n', stdout);
 390
 391         if (fdisk_get_parent(cxt)) {
 392                 struct fdisk_label *l = fdisk_get_label(cxt, NULL),
 393                                    *p = fdisk_get_label(fdisk_get_parent(cxt), NULL);
 394
 395                 fdisk_info(cxt, _("You're editing nested '%s' partition table, "
 396                                   "primary partition table is '%s'."),
 397                                 fdisk_label_get_name(l),
 398                                 fdisk_label_get_name(p));
 399         }
 400
 401         return 0;
 402 }
 403
 404 /* Asks for command, verify the key and perform the command or
 405  * returns the command key if no callback for the command is
 406  * implemented.
 407  *
 408  * Note that this function might exchange the context pointer to
 409  * switch to another (nested) context.
 410  *
 411  * Returns: <0 on error
 412  *           0 on success (the command performed)
 413  *          >0 if no callback (then returns the key)
 414  */
 415 int process_fdisk_menu(struct fdisk_context **cxt0)
 416 {
 417         struct fdisk_context *cxt = *cxt0;
 418         const struct menu_entry *ent;
 419         const struct menu *menu;
 420         int key, rc;
 421         const char *prompt;
 422         char buf[BUFSIZ] = { '\0' };
 423
 424         if (fdisk_is_details(cxt))
 425                 prompt = _("Expert command (m for help): ");
 426         else
 427                 prompt = _("Command (m for help): ");
 428
 429         fputc('\n',stdout);
 430         rc = get_user_reply(prompt, buf, sizeof(buf));
 431
 432         if (rc == -ECANCELED) {
 433                 /* Map ^C and ^D in main menu to 'q' */
 434                 if (is_interactive
 435                     && fdisk_label_is_changed(fdisk_get_label(cxt, NULL))) {
 436                         rc = get_user_reply(
 437                                 _("\nAll unwritten changes will be lost, do you really want to quit? "),
 438                                 buf, sizeof(buf));
 439                         if (rc || !rpmatch(buf))
 440                                 return 0;
 441                 }
 442                 key = 'q';
 443         } else if (rc) {
 444                 return rc;
 445         } else
 446                 key = buf[0];
 447
 448         ent = get_fdisk_menu_entry(cxt, key, &menu);
 449         if (!ent) {
 450                 fdisk_warnx(cxt, _("%c: unknown command"), key);
 451                 return -EINVAL;
 452         }
 453
 454         DBG(MENU, ul_debug("selected: key=%c, entry='%s'",
 455                                 key, ent->title));
 456
 457         /* menu has implemented callback, use it */
 458         if (menu->callback)
 459                 rc = menu->callback(cxt0, menu, ent);
 460         else {
 461                 DBG(MENU, ul_debug("no callback for key '%c'", key));
 462                 rc = -EINVAL;
 463         }
 464
 465         DBG(MENU, ul_debug("process menu done [rc=%d]", rc));
 466         return rc;
 467 }
 468
 469 static int script_read(struct fdisk_context *cxt)
 470 {
 471         struct fdisk_script *sc = NULL;
 472         char *filename = NULL;
 473         int rc;
 474
 475         rc = fdisk_ask_string(cxt, _("Enter script file name"), &filename);
 476         if (rc)
 477                 return rc;
 478
 479         errno = 0;
 480         sc = fdisk_new_script_from_file(cxt, filename);
 481         if (!sc && errno)
 482                 fdisk_warn(cxt, _("Cannot open %s"), filename);
 483         else if (!sc)
 484                 fdisk_warnx(cxt, _("Failed to parse script file %s"), filename);
 485         else if (fdisk_apply_script(cxt, sc) != 0) {
 486                 fdisk_warnx(cxt, _("Failed to apply script %s"), filename);
 487                 fdisk_warnx(cxt, _("Resetting fdisk!"));
 488                 rc = fdisk_reassign_device(cxt);
 489                 if (rc == 0 && !fdisk_has_label(cxt)) {
 490                         fdisk_info(cxt, _("Device does not contain a recognized partition table."));
 491                         rc = fdisk_create_disklabel(cxt, NULL);
 492                 }
 493         } else
 494                 fdisk_info(cxt, _("Script successfully applied."));
 495
 496         fdisk_unref_script(sc);
 497         free(filename);
 498         return rc;
 499 }
 500
 501 static int script_write(struct fdisk_context *cxt)
 502 {
 503         struct fdisk_script *sc = NULL;
 504         char *filename = NULL;
 505         FILE *f = NULL;
 506         int rc;
 507
 508         rc = fdisk_ask_string(cxt, _("Enter script file name"), &filename);
 509         if (rc)
 510                 return rc;
 511
 512         sc = fdisk_new_script(cxt);
 513         if (!sc) {
 514                 fdisk_warn(cxt, _("Failed to allocate script handler"));
 515                 goto done;
 516         }
 517
 518         rc = fdisk_script_read_context(sc, NULL);
 519         if (rc) {
 520                 fdisk_warnx(cxt, _("Failed to transform disk layout into script"));
 521                 goto done;
 522         }
 523
 524         f = fopen(filename, "w");
 525         if (!f) {
 526                 fdisk_warn(cxt, _("Cannot open %s"), filename);
 527                 goto done;
 528         }
 529
 530         rc = fdisk_script_write_file(sc, f);
 531         if (rc)
 532                 fdisk_warn(cxt, _("Failed to write script %s"), filename);
 533         else
 534                 fdisk_info(cxt, _("Script successfully saved."));
 535 done:
 536         if (f)
 537                 fclose(f);
 538         fdisk_unref_script(sc);
 539         free(filename);
 540         return rc;
 541 }
 542
 543 static int ask_for_wipe(struct fdisk_context *cxt, size_t partno)
 544 {
 545         struct fdisk_partition *tmp = NULL;
 546         char *fstype = NULL;
 547         int rc, yes = 0;
 548
 549         rc = fdisk_get_partition(cxt, partno, &tmp);
 550         if (rc)
 551                 goto done;
 552
 553         rc = fdisk_partition_to_string(tmp, cxt, FDISK_FIELD_FSTYPE, &fstype);
 554         if (rc || fstype == NULL)
 555                 goto done;
 556
 557         fdisk_warnx(cxt, _("Partition #%zu contains a %s signature."), partno + 1, fstype);
 558
 559         if (pwipemode == WIPEMODE_AUTO && isatty(STDIN_FILENO))
 560                 fdisk_ask_yesno(cxt, _("Do you want to remove the signature?"), &yes);
 561         else if (pwipemode == WIPEMODE_ALWAYS)
 562                 yes = 1;
 563
 564         if (yes) {
 565                 fdisk_info(cxt, _("The signature will be removed by a write command."));
 566                 rc = fdisk_wipe_partition(cxt, partno, TRUE);
 567         }
 568 done:
 569         fdisk_unref_partition(tmp);
 570         free(fstype);
 571         return rc;
 572 }
 573
 574 /*
 575  * Basic fdisk actions
 576  */
 577 static int generic_menu_cb(struct fdisk_context **cxt0,
 578                        const struct menu *menu __attribute__((__unused__)),
 579                        const struct menu_entry *ent)
 580 {
 581         struct fdisk_context *cxt = *cxt0;
 582         int rc = 0;
 583         size_t n;
 584
 585         /* actions shared between expert and normal mode */
 586         switch (ent->key) {
 587         case 'p':
 588                 list_disk_geometry(cxt);
 589                 list_disklabel(cxt);
 590                 break;
 591         case 'w':
 592                 if (fdisk_is_readonly(cxt)) {
 593                         fdisk_warnx(cxt, _("Device is open in read-only mode."));
 594                         break;
 595                 }
 596                 rc = fdisk_write_disklabel(cxt);
 597                 if (rc)
 598                         err(EXIT_FAILURE, _("failed to write disklabel"));
 599
 600                 fdisk_info(cxt, _("The partition table has been altered."));
 601                 if (fdisk_get_parent(cxt))
 602                         break; /* nested PT, don't leave */
 603
 604                 if (device_is_used)
 605                         rc = fdisk_reread_changes(cxt, original_layout);
 606                 else
 607                         rc = fdisk_reread_partition_table(cxt);
 608                 if (!rc)
 609                         rc = fdisk_deassign_device(cxt, 0);
 610                 /* fallthrough */
 611         case 'q':
 612                 fdisk_unref_context(cxt);
 613                 fputc('\n', stdout);
 614                 exit(rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 615         case 'm':
 616                 rc = print_fdisk_menu(cxt);
 617                 break;
 618         case 'v':
 619                 rc = fdisk_verify_disklabel(cxt);
 620                 break;
 621         case 'i':
 622                 rc = print_partition_info(cxt);
 623                 break;
 624         case 'F':
 625                 list_freespace(cxt);
 626                 break;
 627         }
 628
 629         /* expert mode */
 630         if (ent->expert) {
 631                 switch (ent->key) {
 632                 case 'd':
 633                         dump_firstsector(cxt);
 634                         break;
 635                 case 'D':
 636                         dump_disklabel(cxt);
 637                         break;
 638                 case 'f':
 639                         rc = fdisk_reorder_partitions(cxt);
 640                         break;
 641                 case 'r':
 642                         rc = fdisk_enable_details(cxt, 0);
 643                         break;
 644                 }
 645                 return rc;
 646         }
 647
 648         /* normal mode */
 649         switch (ent->key) {
 650         case 'd':
 651                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 652                 if (rc)
 653                         break; /* no partitions yet (or ENOMEM, ...) */
 654
 655                 rc = fdisk_delete_partition(cxt, n);
 656                 if (rc)
 657                         fdisk_warnx(cxt, _("Could not delete partition %zu"), n + 1);
 658                 else
 659                         fdisk_info(cxt, _("Partition %zu has been deleted."), n + 1);
 660                 break;
 661         case 'I':
 662                 script_read(cxt);
 663                 break;
 664         case 'O':
 665                 script_write(cxt);
 666                 break;
 667         case 'l':
 668                 list_partition_types(cxt);
 669                 break;
 670         case 'n':
 671         {
 672                 size_t partno;
 673                 rc = fdisk_add_partition(cxt, NULL, &partno);
 674                 if (!rc)
 675                         rc = ask_for_wipe(cxt, partno);
 676                 break;
 677         }
 678         case 't':
 679                 change_partition_type(cxt);
 680                 break;
 681         case 'u':
 682                 fdisk_set_unit(cxt,
 683                         fdisk_use_cylinders(cxt) ? "sectors" :
 684                                                            "cylinders");
 685                 if (fdisk_use_cylinders(cxt))
 686                         fdisk_info(cxt, _("Changing display/entry units to cylinders (DEPRECATED!)."));
 687                 else
 688                         fdisk_info(cxt, _("Changing display/entry units to sectors."));
 689                 break;
 690         case 'x':
 691                 fdisk_enable_details(cxt, 1);
 692                 break;
 693         case 'r':
 694                 /* return from nested BSD to DOS or MBR to GPT */
 695                 if (fdisk_get_parent(cxt)) {
 696                         *cxt0 = fdisk_get_parent(cxt);
 697
 698                         fdisk_info(cxt, _("Leaving nested disklabel."));
 699                         fdisk_unref_context(cxt);
 700                 }
 701                 break;
 702         }
 703
 704         return rc;
 705 }
 706
 707
 708 /*
 709  * This is fdisk frontend for GPT specific libfdisk functions that
 710  * are not exported by generic libfdisk API.
 711  */
 712 static int gpt_menu_cb(struct fdisk_context **cxt0,
 713                        const struct menu *menu __attribute__((__unused__)),
 714                        const struct menu_entry *ent)
 715 {
 716         struct fdisk_context *cxt = *cxt0;
 717         struct fdisk_context *mbr;
 718         struct fdisk_partition *pa = NULL;
 719         size_t n;
 720         int rc = 0;
 721         uintmax_t length = 0;
 722
 723         assert(cxt);
 724         assert(ent);
 725         assert(fdisk_is_label(cxt, GPT));
 726
 727         DBG(MENU, ul_debug("enter GPT menu"));
 728
 729         if (ent->expert) {
 730                 switch (ent->key) {
 731                 case 'i':
 732                         return fdisk_set_disklabel_id(cxt);
 733                 case 'l':
 734                         rc =  fdisk_ask_number(cxt, 1, fdisk_get_npartitions(cxt),
 735                                         ~(uint32_t)0, _("New maximum entries"), &length);
 736                         if (rc)
 737                                 return rc;
 738                         return fdisk_gpt_set_npartitions(cxt, (uint32_t) length);
 739                 case 'M':
 740                         mbr = fdisk_new_nested_context(cxt, "dos");
 741                         if (!mbr)
 742                                 return -ENOMEM;
 743                         *cxt0 = cxt = mbr;
 744                         if (fdisk_is_details(cxt))
 745                                 fdisk_enable_details(cxt, 1);   /* keep us in expert mode */
 746                         fdisk_info(cxt, _("Entering protective/hybrid MBR disklabel."));
 747                         return 0;
 748                 }
 749
 750                 /* actions where is necessary partnum */
 751                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 752                 if (rc)
 753                         return rc;
 754
 755                 switch(ent->key) {
 756                 case 'u':
 757                         pa = fdisk_new_partition();     /* new template */
 758                         if (!pa)
 759                                 rc = -ENOMEM;
 760                         else {
 761                                 char *str = NULL;
 762                                 rc = fdisk_ask_string(cxt, _("New UUID (in 8-4-4-4-12 format)"), &str);
 763                                 if (!rc)
 764                                         rc = fdisk_partition_set_uuid(pa, str);
 765                                 if (!rc)
 766                                         rc = fdisk_set_partition(cxt, n, pa);
 767                                 free(str);
 768                                 fdisk_unref_partition(pa);
 769                         }
 770                         break;
 771                 case 'n':
 772                         pa = fdisk_new_partition();     /* new template */
 773                         if (!pa)
 774                                 rc = -ENOMEM;
 775                         else {
 776                                 char *str = NULL;
 777                                 rc = fdisk_ask_string(cxt, _("New name"), &str);
 778                                 if (!rc)
 779                                         rc = fdisk_partition_set_name(pa, str);
 780                                 if (!rc)
 781                                         rc = fdisk_set_partition(cxt, n, pa);
 782                                 free(str);
 783                                 fdisk_unref_partition(pa);
 784                         }
 785                         break;
 786                 case 'A':
 787                         rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_LEGACYBOOT);
 788                         break;
 789                 case 'B':
 790                         rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_NOBLOCK);
 791                         break;
 792                 case 'R':
 793                         rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_REQUIRED);
 794                         break;
 795                 case 'S':
 796                         rc = fdisk_toggle_partition_flag(cxt, n, GPT_FLAG_GUIDSPECIFIC);
 797                         break;
 798                 }
 799         }
 800
 801         return rc;
 802 }
 803
 804
 805 /*
 806  * This is fdisk frontend for MBR specific libfdisk functions that
 807  * are not exported by generic libfdisk API.
 808  */
 809 static int dos_menu_cb(struct fdisk_context **cxt0,
 810                        const struct menu *menu __attribute__((__unused__)),
 811                        const struct menu_entry *ent)
 812 {
 813         struct fdisk_context *cxt = *cxt0;
 814         int rc = 0;
 815
 816         DBG(MENU, ul_debug("enter DOS menu"));
 817
 818         if (!ent->expert) {
 819                 switch (ent->key) {
 820                 case 'a':
 821                 {
 822                         size_t n;
 823                         rc = fdisk_ask_partnum(cxt, &n, FALSE);
 824                         if (!rc)
 825                                 rc = fdisk_toggle_partition_flag(cxt, n, DOS_FLAG_ACTIVE);
 826                         break;
 827                 }
 828                 case 'b':
 829                 {
 830                         struct fdisk_context *bsd
 831                                         = fdisk_new_nested_context(cxt, "bsd");
 832                         if (!bsd)
 833                                 return -ENOMEM;
 834                         if (!fdisk_has_label(bsd))
 835                                 rc = fdisk_create_disklabel(bsd, "bsd");
 836                         if (rc)
 837                                 fdisk_unref_context(bsd);
 838                         else {
 839                                 *cxt0 = cxt = bsd;
 840                                 fdisk_info(cxt, _("Entering nested BSD disklabel."));
 841                         }
 842                         break;
 843                 }
 844                 case 'c':
 845                         toggle_dos_compatibility_flag(cxt);
 846                         break;
 847                 }
 848                 return rc;
 849         }
 850
 851         /* expert mode */
 852         switch (ent->key) {
 853         case 'b':
 854         {
 855                 size_t n;
 856                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 857                 if (!rc)
 858                         rc = fdisk_dos_move_begin(cxt, n);
 859                 break;
 860         }
 861         case 'i':
 862                 rc = fdisk_set_disklabel_id(cxt);
 863                 break;
 864         case 'M':
 865                 /* return from nested MBR to GPT (backward compatibility only) */
 866                 if (fdisk_get_parent(cxt)) {
 867                         *cxt0 = fdisk_get_parent(cxt);
 868
 869                         fdisk_info(cxt, _("Leaving nested disklabel."));
 870                         fdisk_unref_context(cxt);
 871                 }
 872                 break;
 873         case 'F':
 874                 rc = fdisk_dos_fix_chs(cxt);
 875                 if (rc)
 876                         fdisk_info(cxt, _("C/H/S values fixed."));
 877                 else
 878                         fdisk_info(cxt, _("Nothing to do. C/H/S values are correct already."));
 879                 break;
 880         }
 881         return rc;
 882 }
 883
 884 static int sun_menu_cb(struct fdisk_context **cxt0,
 885                        const struct menu *menu __attribute__((__unused__)),
 886                        const struct menu_entry *ent)
 887 {
 888         struct fdisk_context *cxt = *cxt0;
 889         int rc = 0;
 890
 891         DBG(MENU, ul_debug("enter SUN menu"));
 892
 893         assert(cxt);
 894         assert(ent);
 895         assert(fdisk_is_label(cxt, SUN));
 896
 897         DBG(MENU, ul_debug("enter SUN menu"));
 898
 899         /* normal mode */
 900         if (!ent->expert) {
 901                 size_t n;
 902
 903                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 904                 if (rc)
 905                         return rc;
 906                 switch (ent->key) {
 907                 case 'a':
 908                         rc = fdisk_toggle_partition_flag(cxt, n, SUN_FLAG_RONLY);
 909                         break;
 910                 case 'c':
 911                         rc = fdisk_toggle_partition_flag(cxt, n, SUN_FLAG_UNMNT);
 912                         break;
 913                 }
 914                 return rc;
 915         }
 916
 917         /* expert mode */
 918         switch (ent->key) {
 919         case 'a':
 920                 rc = fdisk_sun_set_alt_cyl(cxt);
 921                 break;
 922         case 'e':
 923                 rc = fdisk_sun_set_xcyl(cxt);
 924                 break;
 925         case 'i':
 926                 rc = fdisk_sun_set_ilfact(cxt);
 927                 break;
 928         case 'o':
 929                 rc = fdisk_sun_set_rspeed(cxt);
 930                 break;
 931         case 'y':
 932                 rc = fdisk_sun_set_pcylcount(cxt);
 933                 break;
 934         }
 935         return rc;
 936 }
 937
 938 static int sgi_menu_cb(struct fdisk_context **cxt0,
 939                        const struct menu *menu __attribute__((__unused__)),
 940                        const struct menu_entry *ent)
 941 {
 942         struct fdisk_context *cxt = *cxt0;
 943         int rc = -EINVAL;
 944         size_t n = 0;
 945
 946         DBG(MENU, ul_debug("enter SGI menu"));
 947
 948         assert(cxt);
 949         assert(ent);
 950         assert(fdisk_is_label(cxt, SGI));
 951
 952         if (ent->expert)
 953                 return rc;
 954
 955         switch (ent->key) {
 956         case 'a':
 957                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 958                 if (!rc)
 959                         rc = fdisk_toggle_partition_flag(cxt, n, SGI_FLAG_BOOT);
 960                 break;
 961         case 'b':
 962                 fdisk_sgi_set_bootfile(cxt);
 963                 break;
 964         case 'c':
 965                 rc = fdisk_ask_partnum(cxt, &n, FALSE);
 966                 if (!rc)
 967                         rc = fdisk_toggle_partition_flag(cxt, n, SGI_FLAG_SWAP);
 968                 break;
 969         case 'i':
 970                 rc = fdisk_sgi_create_info(cxt);
 971                 break;
 972         }
 973
 974         return rc;
 975 }
 976
 977 /*
 978  * This is fdisk frontend for BSD specific libfdisk functions that
 979  * are not exported by generic libfdisk API.
 980  */
 981 static int bsd_menu_cb(struct fdisk_context **cxt0,
 982                        const struct menu *menu __attribute__((__unused__)),
 983                        const struct menu_entry *ent)
 984 {
 985         struct fdisk_context *cxt = *cxt0;
 986         int rc = 0, org;
 987
 988         assert(cxt);
 989         assert(ent);
 990         assert(fdisk_is_label(cxt, BSD));
 991
 992         DBG(MENU, ul_debug("enter BSD menu"));
 993
 994         switch(ent->key) {
 995         case 'e':
 996                 rc = fdisk_bsd_edit_disklabel(cxt);
 997                 break;
 998         case 'i':
 999                 rc = fdisk_bsd_write_bootstrap(cxt);
1000                 break;
1001         case 's':
1002                 org = fdisk_is_details(cxt);
1003
1004                 fdisk_enable_details(cxt, 1);
1005                 list_disklabel(cxt);
1006                 fdisk_enable_details(cxt, org);
1007                 break;
1008         case 'x':
1009                 rc = fdisk_bsd_link_partition(cxt);
1010                 break;
1011         }
1012         return rc;
1013 }
1014
1015 /* C/H/S commands
1016  *
1017  * The geometry setting from this dialog is not persistent and maybe reset by
1018  * fdisk_reset_device_properties() (for example when you create a new disk
1019  * label). Note that on command line specified -C/-H/-S setting is persistent
1020  * as it's based on fdisk_save_user_geometry().
1021  */
1022 static int geo_menu_cb(struct fdisk_context **cxt0,
1023                        const struct menu *menu __attribute__((__unused__)),
1024                        const struct menu_entry *ent)
1025 {
1026         struct fdisk_context *cxt = *cxt0;
1027         struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
1028         int rc = -EINVAL;
1029         uintmax_t c = 0, h = 0, s = 0;
1030         fdisk_sector_t mi, ma;
1031
1032         DBG(MENU, ul_debug("enter GEO menu"));
1033
1034         assert(cxt);
1035         assert(ent);
1036
1037         /* default */
1038         if (!lb)
1039                 lb = fdisk_get_label(cxt, "dos");
1040
1041         switch (ent->key) {
1042         case 'c':
1043                 fdisk_label_get_geomrange_cylinders(lb, &mi, &ma);
1044                 rc =  fdisk_ask_number(cxt, mi, fdisk_get_geom_cylinders(cxt),
1045                                 ma, _("Number of cylinders"), &c);
1046                 break;
1047         case 'h':
1048         {
1049                 unsigned int i, a;
1050                 fdisk_label_get_geomrange_heads(lb, &i, &a);
1051                 rc =  fdisk_ask_number(cxt, i, fdisk_get_geom_heads(cxt),
1052                                 a, _("Number of heads"), &h);
1053                 break;
1054         }
1055         case 's':
1056                 fdisk_label_get_geomrange_sectors(lb, &mi, &ma);
1057                 rc =  fdisk_ask_number(cxt, mi, fdisk_get_geom_sectors(cxt),
1058                                 ma, _("Number of sectors"), &s);
1059                 break;
1060         }
1061
1062         if (!rc)
1063                 fdisk_override_geometry(cxt, c, h, s);
1064         return rc;
1065 }
1066
1067 static int createlabel_menu_cb(struct fdisk_context **cxt0,
1068                        const struct menu *menu __attribute__((__unused__)),
1069                        const struct menu_entry *ent)
1070 {
1071         struct fdisk_context *cxt = *cxt0;
1072         const char *wanted = NULL;
1073         int rc = -EINVAL;
1074
1075         DBG(MENU, ul_debug("enter Create label menu"));
1076
1077         assert(cxt);
1078         assert(ent);
1079
1080         if (ent->expert) {
1081                 switch (ent->key) {
1082                 case 'g':
1083                         /* Deprecated, use 'G' in main menu, just for backward
1084                          * compatibility only. */
1085                         wanted = "sgi";
1086                         break;
1087                 }
1088         } else {
1089                 switch (ent->key) {
1090                         case 'g':
1091                                 wanted = "gpt";
1092                                 break;
1093                         case 'G':
1094                                 wanted = "sgi";
1095                                 break;
1096                         case 'o':
1097                                 wanted = "dos";
1098                                 break;
1099                         case 's':
1100                                 wanted = "sun";
1101                                 break;
1102                 }
1103         }
1104
1105         if (wanted) {
1106                 rc = fdisk_create_disklabel(cxt, wanted);
1107                 if (rc) {
1108                         errno = -rc;
1109                         fdisk_warn(cxt, _("Failed to create '%s' disk label"), wanted);
1110                 }
1111         }
1112         if (rc == 0 && fdisk_get_collision(cxt))
1113                 follow_wipe_mode(cxt);
1114
1115         return rc;
1116 }