disk-utils/fdisk.c

   1 /*
   2  * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
   3  * Copyright (C) 2012  Davidlohr Bueso <dave@gnu.org>
   4  *
   5  * Copyright (C) 2007-2013 Karel Zak <kzak@redhat.com>
   6  *
   7  * This program is free software.  You can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation: either version 1 or
  10  * (at your option) any later version.
  11  */
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <fcntl.h>
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <getopt.h>
  20 #include <sys/stat.h>
  21 #include <sys/time.h>
  22 #include <time.h>
  23 #include <limits.h>
  24 #include <libsmartcols.h>
  25 #ifdef HAVE_LIBREADLINE
  26 # include <readline/readline.h>
  27 #endif
  28
  29 #include "c.h"
  30 #include "xalloc.h"
  31 #include "all-io.h"
  32 #include "nls.h"
  33 #include "rpmatch.h"
  34 #include "blkdev.h"
  35 #include "mbsalign.h"
  36 #include "pathnames.h"
  37 #include "canonicalize.h"
  38 #include "strutils.h"
  39 #include "closestream.h"
  40 #include "sysfs.h"
  41
  42 #include "fdisk.h"
  43
  44 #include "pt-sun.h"             /* to toggle flags */
  45
  46 #ifdef HAVE_LINUX_COMPILER_H
  47 # include <linux/compiler.h>
  48 #endif
  49 #ifdef HAVE_LINUX_BLKPG_H
  50 # include <linux/blkpg.h>
  51 #endif
  52
  53 /*
  54  * fdisk debug stuff (see fdisk.h and include/debug.h)
  55  */
  56 UL_DEBUG_DEFINE_MASK(fdisk);
  57 UL_DEBUG_DEFINE_MASKNAMES(fdisk) = UL_DEBUG_EMPTY_MASKNAMES;
  58
  59 static void fdiskprog_init_debug(void)
  60 {
  61         __UL_INIT_DEBUG(fdisk, FDISKPROG_DEBUG_, 0, FDISK_DEBUG);
  62 }
  63
  64 #ifdef HAVE_LIBREADLINE
  65 static char *rl_fgets(char *s, int n, FILE *stream, const char *prompt)
  66 {
  67         char *p;
  68
  69         rl_outstream = stream;
  70         p = readline(prompt);
  71         if (!p)
  72                 return NULL;
  73
  74         strncpy(s, p, n);
  75         s[n - 1] = '\0';
  76         free(p);
  77         return s;
  78 }
  79 #endif
  80
  81 int get_user_reply(struct fdisk_context *cxt, const char *prompt,
  82                           char *buf, size_t bufsz)
  83 {
  84         char *p;
  85         size_t sz;
  86
  87         do {
  88 #ifdef HAVE_LIBREADLINE
  89                 if (isatty(STDIN_FILENO)) {
  90                         if (!rl_fgets(buf, bufsz, stdout, prompt)) {
  91                                 if (fdisk_label_is_changed(fdisk_get_label(cxt, NULL))) {
  92                                         if (rl_fgets(buf, bufsz, stderr,
  93                                                         _("\nDo you really want to quit? "))
  94                                                         && !rpmatch(buf))
  95                                                 continue;
  96                                 }
  97                                 fdisk_unref_context(cxt);
  98                                 exit(EXIT_FAILURE);
  99                         } else
 100                                 break;
 101                 }
 102                 else
 103 #endif
 104                 {
 105                         fputs(prompt, stdout);
 106                         fflush(stdout);
 107                         if (!fgets(buf, bufsz, stdin)) {
 108                                 if (fdisk_label_is_changed(fdisk_get_label(cxt, NULL))) {
 109                                         fprintf(stderr, _("\nDo you really want to quit? "));
 110
 111                                         if (fgets(buf, bufsz, stdin) && !rpmatch(buf))
 112                                                 continue;
 113                                 }
 114                                 fdisk_unref_context(cxt);
 115                                 exit(EXIT_FAILURE);
 116                         } else
 117                                 break;
 118                 }
 119         } while (1);
 120
 121         for (p = buf; *p && !isgraph(*p); p++); /* get first non-blank */
 122
 123         if (p > buf)
 124                 memmove(buf, p, p - buf);               /* remove blank space */
 125         sz = strlen(buf);
 126         if (sz && *(buf + sz - 1) == '\n')
 127                 *(buf + sz - 1) = '\0';
 128
 129         DBG(ASK, ul_debug("user's reply: >>>%s<<<", buf));
 130         return 0;
 131 }
 132
 133 static int ask_menu(struct fdisk_context *cxt, struct fdisk_ask *ask,
 134                     char *buf, size_t bufsz)
 135
 136 {
 137         const char *q = fdisk_ask_get_query(ask);
 138         int dft = fdisk_ask_menu_get_default(ask);
 139
 140         if (q) {
 141                 fputs(q, stdout);               /* print header */
 142                 fputc('\n', stdout);
 143         }
 144
 145         do {
 146                 char prompt[128];
 147                 int key, c, rc;
 148                 const char *name, *desc;
 149                 size_t i = 0;
 150
 151                 /* print menu items */
 152                 while (fdisk_ask_menu_get_item(ask, i++, &key, &name, &desc) == 0)
 153                         fprintf(stdout, "   %c   %s (%s)\n", key, name, desc);
 154
 155                 /* ask for key */
 156                 snprintf(prompt, sizeof(prompt), _("Select (default %c): "), dft);
 157                 rc = get_user_reply(cxt, prompt, buf, bufsz);
 158                 if (rc)
 159                         return rc;
 160                 if (!*buf) {
 161                         fdisk_info(cxt, _("Using default response %c."), dft);
 162                         c = dft;
 163                 } else
 164                         c = tolower(buf[0]);
 165
 166                 /* check result */
 167                 i = 0;
 168                 while (fdisk_ask_menu_get_item(ask, i++, &key, NULL, NULL) == 0) {
 169                         if (c == key) {
 170                                 fdisk_ask_menu_set_result(ask, c);
 171                                 return 0;       /* success */
 172                         }
 173                 }
 174                 fdisk_warnx(cxt, _("Value out of range."));
 175         } while (1);
 176
 177         return -EINVAL;
 178 }
 179
 180
 181 #define tochar(num)     ((int) ('a' + num - 1))
 182 static int ask_number(struct fdisk_context *cxt,
 183                       struct fdisk_ask *ask,
 184                       char *buf, size_t bufsz)
 185 {
 186         char prompt[128] = { '\0' };
 187         const char *q = fdisk_ask_get_query(ask);
 188         const char *range = fdisk_ask_number_get_range(ask);
 189
 190         uint64_t dflt = fdisk_ask_number_get_default(ask),
 191                  low = fdisk_ask_number_get_low(ask),
 192                  high = fdisk_ask_number_get_high(ask);
 193         int inchar = fdisk_ask_number_inchars(ask);
 194
 195         assert(q);
 196
 197         DBG(ASK, ul_debug("asking for number "
 198                         "['%s', <%ju,%ju>, default=%ju, range: %s]",
 199                         q, low, high, dflt, range));
 200
 201         if (range && dflt >= low && dflt <= high) {
 202                 if (inchar)
 203                         snprintf(prompt, sizeof(prompt), _("%s (%s, default %c): "),
 204                                         q, range, tochar(dflt));
 205                 else
 206                         snprintf(prompt, sizeof(prompt), _("%s (%s, default %ju): "),
 207                                         q, range, dflt);
 208
 209         } else if (dflt >= low && dflt <= high) {
 210                 if (inchar)
 211                         snprintf(prompt, sizeof(prompt), _("%s (%c-%c, default %c): "),
 212                                         q, tochar(low), tochar(high), tochar(dflt));
 213                 else
 214                         snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju, default %ju): "),
 215                                         q, low, high, dflt);
 216         } else if (inchar)
 217                 snprintf(prompt, sizeof(prompt), _("%s (%c-%c): "),
 218                                 q, tochar(low), tochar(high));
 219         else
 220                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju): "),
 221                                 q, low, high);
 222
 223         do {
 224                 int rc = get_user_reply(cxt, prompt, buf, bufsz);
 225                 uint64_t num;
 226
 227                 if (rc)
 228                         return rc;
 229                 if (!*buf && dflt >= low && dflt <= high)
 230                         return fdisk_ask_number_set_result(ask, dflt);
 231
 232                 if (isdigit_string(buf)) {
 233                         char *end;
 234
 235                         errno = 0;
 236                         num = strtoumax(buf, &end, 10);
 237                         if (errno || buf == end || (end && *end))
 238                                 continue;
 239                 } else if (inchar && isalpha(*buf)) {
 240                         num = tolower(*buf) - 'a' + 1;
 241                 } else
 242                         rc = -EINVAL;
 243
 244                 if (rc == 0 && num >= low && num <= high)
 245                         return fdisk_ask_number_set_result(ask, num);
 246
 247                 fdisk_warnx(cxt, _("Value out of range."));
 248         } while (1);
 249
 250         return -1;
 251 }
 252
 253 static int ask_offset(struct fdisk_context *cxt,
 254                       struct fdisk_ask *ask,
 255                       char *buf, size_t bufsz)
 256 {
 257         char prompt[128] = { '\0' };
 258         const char *q = fdisk_ask_get_query(ask);
 259         const char *range = fdisk_ask_number_get_range(ask);
 260
 261         uint64_t dflt = fdisk_ask_number_get_default(ask),
 262                  low = fdisk_ask_number_get_low(ask),
 263                  high = fdisk_ask_number_get_high(ask),
 264                  base = fdisk_ask_number_get_base(ask);
 265
 266         assert(q);
 267
 268         DBG(ASK, ul_debug("asking for offset ['%s', <%ju,%ju>, base=%ju, default=%ju, range: %s]",
 269                                 q, low, high, base, dflt, range));
 270
 271         if (range && dflt >= low && dflt <= high)
 272                 snprintf(prompt, sizeof(prompt), _("%s (%s, default %ju): "), q, range, dflt);
 273         else if (dflt >= low && dflt <= high)
 274                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju, default %ju): "), q, low, high, dflt);
 275         else
 276                 snprintf(prompt, sizeof(prompt), _("%s (%ju-%ju): "), q, low, high);
 277
 278         do {
 279                 uint64_t num = 0;
 280                 char sig = 0, *p;
 281                 int pwr = 0;
 282
 283                 int rc = get_user_reply(cxt, prompt, buf, bufsz);
 284                 if (rc)
 285                         return rc;
 286                 if (!*buf && dflt >= low && dflt <= high)
 287                         return fdisk_ask_number_set_result(ask, dflt);
 288
 289                 p = buf;
 290                 if (*p == '+' || *p == '-') {
 291                         sig = *buf;
 292                         p++;
 293                 }
 294
 295                 rc = parse_size(p, &num, &pwr);
 296                 if (rc)
 297                         continue;
 298                 DBG(ASK, ul_debug("parsed size: %ju", num));
 299                 if (sig && pwr) {
 300                         /* +{size}{K,M,...} specified, the "num" is in bytes */
 301                         uint64_t unit = fdisk_ask_number_get_unit(ask);
 302                         num += unit/2;  /* round */
 303                         num /= unit;
 304                 }
 305                 if (sig == '+')
 306                         num += base;
 307                 else if (sig == '-')
 308                         num = base - num;
 309
 310                 DBG(ASK, ul_debug("final offset: %ju [sig: %c, power: %d, %s]",
 311                                 num, sig, pwr,
 312                                 sig ? "relative" : "absolute"));
 313                 if (num >= low && num <= high) {
 314                         if (sig && pwr)
 315                                 fdisk_ask_number_set_relative(ask, 1);
 316                         return fdisk_ask_number_set_result(ask, num);
 317                 }
 318                 fdisk_warnx(cxt, _("Value out of range."));
 319         } while (1);
 320
 321         return -1;
 322 }
 323
 324 static unsigned int info_count;
 325
 326 static void fputs_info(struct fdisk_ask *ask, FILE *out)
 327 {
 328         const char *msg;
 329         assert(ask);
 330
 331         msg = fdisk_ask_print_get_mesg(ask);
 332         if (!msg)
 333                 return;
 334         if (info_count == 1)
 335                 fputc('\n', out);
 336
 337         fputs(msg, out);
 338         fputc('\n', out);
 339 }
 340
 341 int ask_callback(struct fdisk_context *cxt, struct fdisk_ask *ask,
 342                     void *data __attribute__((__unused__)))
 343 {
 344         int rc = 0;
 345         char buf[BUFSIZ];
 346
 347         assert(cxt);
 348         assert(ask);
 349
 350         if (fdisk_ask_get_type(ask) != FDISK_ASKTYPE_INFO)
 351                 info_count = 0;
 352
 353         switch(fdisk_ask_get_type(ask)) {
 354         case FDISK_ASKTYPE_MENU:
 355                 return ask_menu(cxt, ask, buf, sizeof(buf));
 356         case FDISK_ASKTYPE_NUMBER:
 357                 return ask_number(cxt, ask, buf, sizeof(buf));
 358         case FDISK_ASKTYPE_OFFSET:
 359                 return ask_offset(cxt, ask, buf, sizeof(buf));
 360         case FDISK_ASKTYPE_INFO:
 361                 if (!fdisk_is_listonly(cxt))
 362                         info_count++;
 363                 fputs_info(ask, stdout);
 364                 break;
 365         case FDISK_ASKTYPE_WARNX:
 366                 color_scheme_fenable("warn", UL_COLOR_RED, stderr);
 367                 fputs(fdisk_ask_print_get_mesg(ask), stderr);
 368                 color_fdisable(stderr);
 369                 fputc('\n', stderr);
 370                 break;
 371         case FDISK_ASKTYPE_WARN:
 372                 color_scheme_fenable("warn", UL_COLOR_RED, stderr);
 373                 fputs(fdisk_ask_print_get_mesg(ask), stderr);
 374                 errno = fdisk_ask_print_get_errno(ask);
 375                 fprintf(stderr, ": %m\n");
 376                 color_fdisable(stderr);
 377                 break;
 378         case FDISK_ASKTYPE_YESNO:
 379                 fputc('\n', stdout);
 380                 do {
 381                         int x;
 382                         fputs(fdisk_ask_get_query(ask), stdout);
 383                         rc = get_user_reply(cxt, _(" [Y]es/[N]o: "), buf, sizeof(buf));
 384                         if (rc)
 385                                 break;
 386                         x = rpmatch(buf);
 387                         if (x == RPMATCH_YES || x == RPMATCH_NO) {
 388                                 fdisk_ask_yesno_set_result(ask, x);
 389                                 break;
 390                         }
 391                 } while(1);
 392                 DBG(ASK, ul_debug("yes-no ask: reply '%s' [rc=%d]", buf, rc));
 393                 break;
 394         case FDISK_ASKTYPE_STRING:
 395         {
 396                 char prmt[BUFSIZ];
 397                 snprintf(prmt, sizeof(prmt), "%s: ", fdisk_ask_get_query(ask));
 398                 fputc('\n', stdout);
 399                 rc = get_user_reply(cxt, prmt, buf, sizeof(buf));
 400                 if (rc == 0)
 401                         fdisk_ask_string_set_result(ask, xstrdup(buf));
 402                 DBG(ASK, ul_debug("string ask: reply '%s' [rc=%d]", buf, rc));
 403                 break;
 404         }
 405         default:
 406                 warnx(_("internal error: unsupported dialog type %d"), fdisk_ask_get_type(ask));
 407                 return -EINVAL;
 408         }
 409         return rc;
 410 }
 411
 412 static struct fdisk_parttype *ask_partition_type(struct fdisk_context *cxt)
 413 {
 414         const char *q;
 415         struct fdisk_label *lb;
 416
 417         assert(cxt);
 418         lb = fdisk_get_label(cxt, NULL);
 419
 420         if (!lb)
 421                 return NULL;
 422
 423         q = fdisk_label_has_code_parttypes(lb) ?
 424                 _("Partition type (type L to list all types): ") :
 425                 _("Hex code (type L to list all codes): ");
 426         do {
 427                 char buf[256];
 428                 int rc = get_user_reply(cxt, q, buf, sizeof(buf));
 429
 430                 if (rc)
 431                         break;
 432
 433                 if (buf[1] == '\0' && toupper(*buf) == 'L')
 434                         list_partition_types(cxt);
 435                 else if (*buf)
 436                         return fdisk_label_parse_parttype(lb, buf);
 437         } while (1);
 438
 439         return NULL;
 440 }
 441
 442 void list_partition_types(struct fdisk_context *cxt)
 443 {
 444         size_t ntypes = 0;
 445         struct fdisk_label *lb;
 446
 447         assert(cxt);
 448         lb = fdisk_get_label(cxt, NULL);
 449         if (!lb)
 450                 return;
 451         ntypes = fdisk_label_get_nparttypes(lb);
 452         if (!ntypes)
 453                 return;
 454
 455         if (fdisk_label_has_code_parttypes(lb)) {
 456                 /*
 457                  * Prints in 4 columns in format <hex> <name>
 458                  */
 459                 size_t last[4], done = 0, next = 0, size;
 460                 int i;
 461
 462                 size = ntypes;
 463
 464                 for (i = 3; i >= 0; i--)
 465                         last[3 - i] = done += (size + i - done) / (i + 1);
 466                 i = done = 0;
 467
 468                 do {
 469                         #define NAME_WIDTH 15
 470                         char name[NAME_WIDTH * MB_LEN_MAX];
 471                         size_t width = NAME_WIDTH;
 472                         const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, next);
 473                         size_t ret;
 474
 475                         if (fdisk_parttype_get_name(t)) {
 476                                 printf("%c%2x  ", i ? ' ' : '\n',
 477                                                 fdisk_parttype_get_code(t));
 478                                 ret = mbsalign(_(fdisk_parttype_get_name(t)),
 479                                                 name, sizeof(name),
 480                                                 &width, MBS_ALIGN_LEFT, 0);
 481
 482                                 if (ret == (size_t)-1 || ret >= sizeof(name))
 483                                         printf("%-15.15s",
 484                                                 _(fdisk_parttype_get_name(t)));
 485                                 else
 486                                         fputs(name, stdout);
 487                         }
 488
 489                         next = last[i++] + done;
 490                         if (i > 3 || next >= last[i]) {
 491                                 i = 0;
 492                                 next = ++done;
 493                         }
 494                 } while (done < last[0]);
 495
 496         } else {
 497                 /*
 498                  * Prints 1 column in format <idx> <name> <typestr>
 499                  */
 500                 size_t i;
 501
 502                 for (i = 0; i < ntypes; i++) {
 503                         const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, i);
 504                         printf("%3zu %-30s %s\n", i + 1,
 505                                         fdisk_parttype_get_name(t),
 506                                         fdisk_parttype_get_string(t));
 507                 }
 508         }
 509         putchar('\n');
 510 }
 511
 512 void toggle_dos_compatibility_flag(struct fdisk_context *cxt)
 513 {
 514         struct fdisk_label *lb = fdisk_get_label(cxt, "dos");
 515         int flag;
 516
 517         if (!lb)
 518                 return;
 519
 520         flag = !fdisk_dos_is_compatible(lb);
 521         fdisk_info(cxt, flag ?
 522                         _("DOS Compatibility flag is set (DEPRECATED!)") :
 523                         _("DOS Compatibility flag is not set"));
 524
 525         fdisk_dos_enable_compatible(lb, flag);
 526
 527         if (fdisk_is_label(cxt, DOS))
 528                 fdisk_reset_alignment(cxt);     /* reset the current label */
 529 }
 530
 531 void change_partition_type(struct fdisk_context *cxt)
 532 {
 533         size_t i;
 534         struct fdisk_parttype *t = NULL;
 535         struct fdisk_partition *pa = NULL;
 536         const char *old = NULL;
 537
 538         assert(cxt);
 539
 540         if (fdisk_ask_partnum(cxt, &i, FALSE))
 541                 return;
 542
 543         if (fdisk_get_partition(cxt, i, &pa)) {
 544                 fdisk_warnx(cxt, _("Partition %zu does not exist yet!"), i + 1);
 545                 return;
 546         }
 547
 548         t = (struct fdisk_parttype *) fdisk_partition_get_type(pa);
 549         old = t ? fdisk_parttype_get_name(t) : _("Unknown");
 550
 551         do {
 552                 t = ask_partition_type(cxt);
 553         } while (!t);
 554
 555         if (fdisk_set_partition_type(cxt, i, t) == 0)
 556                 fdisk_info(cxt,
 557                         _("Changed type of partition '%s' to '%s'."),
 558                         old, t ? fdisk_parttype_get_name(t) : _("Unknown"));
 559         else
 560                 fdisk_info(cxt,
 561                         _("Type of partition %zu is unchanged: %s."),
 562                         i + 1, old);
 563
 564         fdisk_unref_partition(pa);
 565         fdisk_unref_parttype(t);
 566 }
 567
 568 int print_partition_info(struct fdisk_context *cxt)
 569 {
 570         struct fdisk_partition *pa = NULL;
 571         int rc = 0;
 572         size_t i, nfields;
 573         int *fields = NULL;
 574         struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
 575
 576         if ((rc = fdisk_ask_partnum(cxt, &i, FALSE)))
 577                 return rc;
 578
 579         if ((rc = fdisk_get_partition(cxt, i, &pa))) {
 580                 fdisk_warnx(cxt, _("Partition %zu does not exist yet!"), i + 1);
 581                 return rc;
 582         }
 583
 584         if ((rc = fdisk_label_get_fields_ids_all(lb, cxt, &fields, &nfields)))
 585                 goto clean_data;
 586
 587         for (i = 0; i < nfields; ++i) {
 588                 int id = fields[i];
 589                 char *data = NULL;
 590                 const struct fdisk_field *fd = fdisk_label_get_field(lb, id);
 591
 592                 if (!fd)
 593                         continue;
 594
 595                 rc = fdisk_partition_to_string(pa, cxt, id, &data);
 596                 if (rc < 0)
 597                         goto clean_data;
 598                 if (!data || !*data)
 599                         continue;
 600                 fdisk_info(cxt, _("%15s: %s"), fdisk_field_get_name(fd), data);
 601                 free(data);
 602         }
 603
 604 clean_data:
 605         fdisk_unref_partition(pa);
 606         free(fields);
 607         return rc;
 608 }
 609
 610 static size_t skip_empty(const unsigned char *buf, size_t i, size_t sz)
 611 {
 612         size_t next;
 613         const unsigned char *p0 = buf + i;
 614
 615         for (next = i + 16; next < sz; next += 16) {
 616                 if (memcmp(p0, buf + next, 16) != 0)
 617                         break;
 618         }
 619
 620         return next == i + 16 ? i : next;
 621 }
 622
 623 static void dump_buffer(off_t base, unsigned char *buf, size_t sz, int all)
 624 {
 625         size_t i, l, next = 0;
 626
 627         if (!buf)
 628                 return;
 629         for (i = 0, l = 0; i < sz; i++, l++) {
 630                 if (l == 0) {
 631                         if (all == 0 && !next)
 632                                 next = skip_empty(buf, i, sz);
 633                         printf("%08jx ", base + i);
 634                 }
 635                 printf(" %02x", buf[i]);
 636                 if (l == 7)                             /* words separator */
 637                         fputs(" ", stdout);
 638                 else if (l == 15) {
 639                         fputc('\n', stdout);            /* next line */
 640                         l = -1;
 641                         if (next > i) {
 642                                 printf("*\n");
 643                                 i = next - 1;
 644                         }
 645                         next = 0;
 646                 }
 647         }
 648         if (l > 0)
 649                 printf("\n");
 650 }
 651
 652 static void dump_blkdev(struct fdisk_context *cxt, const char *name,
 653                         uint64_t offset, size_t size, int all)
 654 {
 655         int fd = fdisk_get_devfd(cxt);
 656
 657         fdisk_info(cxt, _("\n%s: offset = %ju, size = %zu bytes."),
 658                         name, offset, size);
 659
 660         assert(fd >= 0);
 661
 662         if (lseek(fd, (off_t) offset, SEEK_SET) == (off_t) -1)
 663                 fdisk_warn(cxt, _("cannot seek"));
 664         else {
 665                 unsigned char *buf = xmalloc(size);
 666
 667                 if (read_all(fd, (char *) buf, size) != (ssize_t) size)
 668                         fdisk_warn(cxt, _("cannot read"));
 669                 else
 670                         dump_buffer(offset, buf, size, all);
 671                 free(buf);
 672         }
 673 }
 674
 675 void dump_firstsector(struct fdisk_context *cxt)
 676 {
 677         int all = !isatty(STDOUT_FILENO);
 678
 679         assert(cxt);
 680
 681         dump_blkdev(cxt, _("First sector"), 0, fdisk_get_sector_size(cxt), all);
 682 }
 683
 684 void dump_disklabel(struct fdisk_context *cxt)
 685 {
 686         int all = !isatty(STDOUT_FILENO);
 687         int i = 0;
 688         const char *name = NULL;
 689         uint64_t offset = 0;
 690         size_t size = 0;
 691
 692         assert(cxt);
 693
 694         while (fdisk_locate_disklabel(cxt, i++, &name, &offset, &size) == 0 && size)
 695                 dump_blkdev(cxt, name, offset, size, all);
 696 }
 697
 698 static fdisk_sector_t get_dev_blocks(char *dev)
 699 {
 700         int fd, ret;
 701         fdisk_sector_t size;
 702
 703         if ((fd = open(dev, O_RDONLY)) < 0)
 704                 err(EXIT_FAILURE, _("cannot open %s"), dev);
 705         ret = blkdev_get_sectors(fd, (unsigned long long *) &size);
 706         close(fd);
 707         if (ret < 0)
 708                 err(EXIT_FAILURE, _("BLKGETSIZE ioctl failed on %s"), dev);
 709         return size/2;
 710 }
 711
 712 static void __attribute__ ((__noreturn__)) usage(FILE *out)
 713 {
 714         fputs(USAGE_HEADER, out);
 715
 716         fprintf(out,
 717               _(" %1$s [options] <disk>      change partition table\n"
 718                 " %1$s [options] -l [<disk>] list partition table(s)\n"),
 719                program_invocation_short_name);
 720
 721         fputs(USAGE_SEPARATOR, out);
 722         fputs(_("Display or manipulate a disk partition table.\n"), out);
 723
 724         fputs(USAGE_OPTIONS, out);
 725         fputs(_(" -b, --sector-size <size>      physical and logical sector size\n"), out);
 726         fputs(_(" -B, --protect-boot            don't erase bootbits when creat a new label\n"), out);
 727         fputs(_(" -c, --compatibility[=<mode>]  mode is 'dos' or 'nondos' (default)\n"), out);
 728         fputs(_(" -L, --color[=<when>]          colorize output (auto, always or never)\n"), out);
 729         fprintf(out,
 730                 "                                 %s\n", USAGE_COLORS_DEFAULT);
 731         fputs(_(" -l, --list                    display partitions end exit\n"), out);
 732         fputs(_(" -o, --output <list>           output columns\n"), out);
 733         fputs(_(" -t, --type <type>             recognize specified partition table type only\n"), out);
 734         fputs(_(" -u, --units[=<unit>]          display units: 'cylinders' or 'sectors' (default)\n"), out);
 735         fputs(_(" -s, --getsz                   display device size in 512-byte sectors [DEPRECATED]\n"), out);
 736         fputs(_("     --bytes                   print SIZE in bytes rather than in human readable format\n"), out);
 737
 738         fputs(USAGE_SEPARATOR, out);
 739         fputs(_(" -C, --cylinders <number>      specify the number of cylinders\n"), out);
 740         fputs(_(" -H, --heads <number>          specify the number of heads\n"), out);
 741         fputs(_(" -S, --sectors <number>        specify the number of sectors per track\n"), out);
 742
 743         fputs(USAGE_SEPARATOR, out);
 744         fputs(USAGE_HELP, out);
 745         fputs(USAGE_VERSION, out);
 746
 747         list_available_columns(out);
 748
 749         fprintf(out, USAGE_MAN_TAIL("fdisk(8)"));
 750         exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
 751 }
 752
 753
 754 enum {
 755         ACT_FDISK = 0,  /* default */
 756         ACT_LIST,
 757         ACT_SHOWSIZE
 758 };
 759
 760 int main(int argc, char **argv)
 761 {
 762         int rc, i, c, act = ACT_FDISK;
 763         int colormode = UL_COLORMODE_UNDEF;
 764         struct fdisk_context *cxt;
 765         char *outarg = NULL;
 766         enum {
 767                 OPT_BYTES       = CHAR_MAX + 1
 768         };
 769         static const struct option longopts[] = {
 770                 { "bytes",          no_argument,       NULL, OPT_BYTES },
 771                 { "color",          optional_argument, NULL, 'L' },
 772                 { "compatibility",  optional_argument, NULL, 'c' },
 773                 { "cylinders",      required_argument, NULL, 'C' },
 774                 { "heads",          required_argument, NULL, 'H' },
 775                 { "sectors",        required_argument, NULL, 'S' },
 776                 { "getsz",          no_argument,       NULL, 's' },
 777                 { "help",           no_argument,       NULL, 'h' },
 778                 { "list",           no_argument,       NULL, 'l' },
 779                 { "sector-size",    required_argument, NULL, 'b' },
 780                 { "type",           required_argument, NULL, 't' },
 781                 { "units",          optional_argument, NULL, 'u' },
 782                 { "version",        no_argument,       NULL, 'V' },
 783                 { "output",         no_argument,       NULL, 'o' },
 784                 { "protect-boot",   no_argument,       NULL, 'B' },
 785                 { NULL, 0, NULL, 0 }
 786         };
 787
 788         setlocale(LC_ALL, "");
 789         bindtextdomain(PACKAGE, LOCALEDIR);
 790         textdomain(PACKAGE);
 791         atexit(close_stdout);
 792
 793         fdisk_init_debug(0);
 794         scols_init_debug(0);
 795         fdiskprog_init_debug();
 796
 797         cxt = fdisk_new_context();
 798         if (!cxt)
 799                 err(EXIT_FAILURE, _("failed to allocate libfdisk context"));
 800
 801         fdisk_set_ask(cxt, ask_callback, NULL);
 802
 803         while ((c = getopt_long(argc, argv, "b:Bc::C:hH:lL::o:sS:t:u::vV",
 804                                 longopts, NULL)) != -1) {
 805                 switch (c) {
 806                 case 'b':
 807                 {
 808                         size_t sz = strtou32_or_err(optarg,
 809                                         _("invalid sector size argument"));
 810                         if (sz != 512 && sz != 1024 && sz != 2048 && sz != 4096)
 811                                 usage(stderr);
 812                         fdisk_save_user_sector_size(cxt, sz, sz);
 813                         break;
 814                 }
 815                 case 'B':
 816                         fdisk_enable_bootbits_protection(cxt, 1);
 817                         break;
 818                 case 'C':
 819                         fdisk_save_user_geometry(cxt,
 820                                 strtou32_or_err(optarg,
 821                                                 _("invalid cylinders argument")),
 822                                 0, 0);
 823                         break;
 824                 case 'c':
 825                         if (optarg) {
 826                                 /* this setting is independent on the current
 827                                  * actively used label
 828                                  */
 829                                 char *p = *optarg == '=' ? optarg + 1 : optarg;
 830                                 struct fdisk_label *lb = fdisk_get_label(cxt, "dos");
 831
 832                                 if (!lb)
 833                                         err(EXIT_FAILURE, _("not found DOS label driver"));
 834                                 if (strcmp(p, "dos") == 0)
 835                                         fdisk_dos_enable_compatible(lb, TRUE);
 836                                 else if (strcmp(p, "nondos") == 0)
 837                                         fdisk_dos_enable_compatible(lb, FALSE);
 838                                 else {
 839                                         warnx(_("unknown compatibility mode '%s'"), p);
 840                                         usage(stderr);
 841                                 }
 842                         }
 843                         /* use default if no optarg specified */
 844                         break;
 845                 case 'H':
 846                         fdisk_save_user_geometry(cxt, 0,
 847                                 strtou32_or_err(optarg,
 848                                                 _("invalid heads argument")),
 849                                 0);
 850                         break;
 851                 case 'S':
 852                         fdisk_save_user_geometry(cxt, 0, 0,
 853                                 strtou32_or_err(optarg,
 854                                         _("invalid sectors argument")));
 855                         break;
 856                 case 'l':
 857                         act = ACT_LIST;
 858                         break;
 859                 case 'L':
 860                         colormode = UL_COLORMODE_AUTO;
 861                         if (optarg)
 862                                 colormode = colormode_or_err(optarg,
 863                                                 _("unsupported color mode"));
 864                         break;
 865                 case 'o':
 866                         outarg = optarg;
 867                         break;
 868                 case 's':
 869                         act = ACT_SHOWSIZE;
 870                         break;
 871                 case 't':
 872                 {
 873                         struct fdisk_label *lb = NULL;
 874
 875                         while (fdisk_next_label(cxt, &lb) == 0)
 876                                 fdisk_label_set_disabled(lb, 1);
 877
 878                         lb = fdisk_get_label(cxt, optarg);
 879                         if (!lb)
 880                                 errx(EXIT_FAILURE, _("unsupported disklabel: %s"), optarg);
 881                         fdisk_label_set_disabled(lb, 0);
 882                         break;
 883                 }
 884                 case 'u':
 885                         if (optarg && *optarg == '=')
 886                                 optarg++;
 887                         if (fdisk_set_unit(cxt, optarg) != 0)
 888                                 usage(stderr);
 889                         break;
 890                 case 'V': /* preferred for util-linux */
 891                 case 'v': /* for backward compatibility only */
 892                         printf(UTIL_LINUX_VERSION);
 893                         return EXIT_SUCCESS;
 894                 case 'h':
 895                         usage(stdout);
 896                 case OPT_BYTES:
 897                         fdisk_set_size_unit(cxt, FDISK_SIZEUNIT_BYTES);
 898                         break;
 899                 default:
 900                         usage(stderr);
 901                 }
 902         }
 903
 904         if (argc-optind != 1 && fdisk_has_user_device_properties(cxt))
 905                 warnx(_("The device properties (sector size and geometry) should"
 906                         " be used with one specified device only."));
 907
 908         colors_init(colormode, "fdisk");
 909
 910         switch (act) {
 911         case ACT_LIST:
 912                 fdisk_enable_listonly(cxt, 1);
 913                 init_fields(cxt, outarg, NULL);
 914
 915                 if (argc > optind) {
 916                         int k;
 917                         for (k = optind; k < argc; k++)
 918                                 print_device_pt(cxt, argv[k], 1, 0);
 919                 } else
 920                         print_all_devices_pt(cxt, 0);
 921                 break;
 922
 923         case ACT_SHOWSIZE:
 924                 /* deprecated */
 925                 if (argc - optind <= 0)
 926                         usage(stderr);
 927
 928                 for (i = optind; i < argc; i++) {
 929                         uintmax_t blks = get_dev_blocks(argv[i]);
 930
 931                         if (argc - optind == 1)
 932                                 printf("%ju\n", blks);
 933                         else
 934                                 printf("%s: %ju\n", argv[i], blks);
 935                 }
 936                 break;
 937
 938         case ACT_FDISK:
 939                 if (argc-optind != 1)
 940                         usage(stderr);
 941
 942                 /* Here starts interactive mode, use fdisk_{warn,info,..} functions */
 943                 color_scheme_enable("welcome", UL_COLOR_GREEN);
 944                 fdisk_info(cxt, _("Welcome to fdisk (%s)."), PACKAGE_STRING);
 945                 color_disable();
 946                 fdisk_info(cxt, _("Changes will remain in memory only, until you decide to write them.\n"
 947                                   "Be careful before using the write command.\n"));
 948
 949                 rc = fdisk_assign_device(cxt, argv[optind], 0);
 950                 if (rc == -EACCES) {
 951                         rc = fdisk_assign_device(cxt, argv[optind], 1);
 952                         if (rc == 0)
 953                                 fdisk_warnx(cxt, _("Device is open in read-only mode."));
 954                 }
 955                 if (rc)
 956                         err(EXIT_FAILURE, _("cannot open %s"), argv[optind]);
 957
 958                 fflush(stdout);
 959
 960                 if (!fdisk_has_label(cxt)) {
 961                         fdisk_info(cxt, _("Device does not contain a recognized partition table."));
 962                         fdisk_create_disklabel(cxt, NULL);
 963
 964                 } else if (fdisk_is_label(cxt, GPT) && fdisk_gpt_is_hybrid(cxt))
 965                         fdisk_warnx(cxt, _(
 966                                   "A hybrid GPT was detected. You have to sync "
 967                                   "the hybrid MBR manually (expert command 'M')."));
 968
 969                 init_fields(cxt, outarg, NULL);         /* -o <columns> */
 970
 971                 while (1)
 972                         process_fdisk_menu(&cxt);
 973         }
 974
 975         fdisk_unref_context(cxt);
 976         return EXIT_SUCCESS;
 977 }