cgpt supports dev and add/delete/modify commands.

src/platform/vboot_reference/utility/cgpt/cgpt.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Utility for ChromeOS-specific GPT partitions, Please see corresponding .c
  * files for more details.
  */
 /* To compile on host without compatility to BSD, we include
  * endian.h under chroot. */
 #define _BSD_SOURCE
@@ skipping 20 matching lines @@
 
 /* For usage print */
 const char* progname;
 
 /* Lists all command here. */
 struct {
   const char *name;
   int (*fp)(int argc, char *argv[]);
   const char *comment;
 } cmds[] = {
+  {"add", CgptAdm, "Add a partition to drive"},
+  {"delete", CgptAdm, "Delete a partition on drive"},
+  {"modify", CgptAdm, "Modify the partition on drive"},
   {"attribute", CgptAttribute, "Update GPT attribute bits "
                                "(for ChromeOS kernel entry only)"},
+  {"dev", CgptDev, "Developper mode"},
   {"repair", CgptRepair, "Repair primary and secondary headers and tables"},
   {"show", CgptShow, "Show partition details"},
 };
 
 /* Shows main menu. If 'message' is non-NULL, shows it as header. Then, this
  * traverses cmds[] and shows supported commands and their comments. */
 void Usage(const char *message) {
   int i;
 
   if (message) printf("%s\n", message);
   printf("Usage: %s COMMAND [OPTIONS]\n\n"
-         "Supported commands:\n\n",
+         "Supported COMMANDs:\n\n",
          progname);
   for (i = 0; i < sizeof(cmds)/sizeof(cmds[0]); ++i) {
     printf("    %-10s  %s\n", cmds[i].name, cmds[i].comment);
   }
   printf("\nFor more detailed usage, use %s COMMAND --help.\n\n", progname);
 }
 
 /* GUID conversion functions. Accepted format:
  *
  *   "C12A7328-F81F-11D2-BA4B-00A0C93EC93B"
+ *
+ * Returns CGPT_OK if parsing is successful; otherwise CGPT_FAILED.
  */
-void StrToGuid(const char *str, Guid *guid) {
+int StrToGuid(const char *str, Guid *guid) {
   uint32_t time_low, time_mid, time_high_and_version;
 
-  sscanf(str, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
-         &time_low,
-         (unsigned int *)&time_mid,
-         (unsigned int *)&time_high_and_version,
-         (unsigned int *)&guid->u.Uuid.clock_seq_high_and_reserved,
-         (unsigned int *)&guid->u.Uuid.clock_seq_low,
-         (unsigned int *)&guid->u.Uuid.node[0],
-         (unsigned int *)&guid->u.Uuid.node[1],
-         (unsigned int *)&guid->u.Uuid.node[2],
-         (unsigned int *)&guid->u.Uuid.node[3],
-         (unsigned int *)&guid->u.Uuid.node[4],
-         (unsigned int *)&guid->u.Uuid.node[5]);
+  if (11 > sscanf(str, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
+                  &time_low,
+                  (unsigned int *)&time_mid,
+                  (unsigned int *)&time_high_and_version,
+                  (unsigned int *)&guid->u.Uuid.clock_seq_high_and_reserved,
+                  (unsigned int *)&guid->u.Uuid.clock_seq_low,
+                  (unsigned int *)&guid->u.Uuid.node[0],
+                  (unsigned int *)&guid->u.Uuid.node[1],
+                  (unsigned int *)&guid->u.Uuid.node[2],
+                  (unsigned int *)&guid->u.Uuid.node[3],
+                  (unsigned int *)&guid->u.Uuid.node[4],
+                  (unsigned int *)&guid->u.Uuid.node[5])) return CGPT_FAILED;
 
   guid->u.Uuid.time_low = htole32(time_low);
   guid->u.Uuid.time_mid = htole16(time_mid);
   guid->u.Uuid.time_high_and_version = htole16(time_high_and_version);
+
+  return CGPT_OK;
 }
 
 void GuidToStr(const Guid *guid, char *str) {
   sprintf(str, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
           le32toh(guid->u.Uuid.time_low), le16toh(guid->u.Uuid.time_mid),
           le16toh(guid->u.Uuid.time_high_and_version),
           guid->u.Uuid.clock_seq_high_and_reserved, guid->u.Uuid.clock_seq_low,
           guid->u.Uuid.node[0], guid->u.Uuid.node[1], guid->u.Uuid.node[2],
           guid->u.Uuid.node[3], guid->u.Uuid.node[4], guid->u.Uuid.node[5]);
 }
@@ skipping 92 matching lines @@
         utf16[s16idx++] = htole16(0xdc00 | (utfchar & 0x3ff));
       } else {
         utf16[s16idx++] = htole16(utfchar);
       }
     }
   } while (c != 0 && s16idx < SIZEOF_GPTENTRY_NAME);
   if (s16idx < SIZEOF_GPTENTRY_NAME)
     utf16[s16idx++] = 0;
 }
 
+struct {
+  Guid type;
+  char *name;
+  char *description;
+} supported_types[] = {
+ {GPT_ENT_TYPE_UNUSED, "unused", "Unused partition"},
+ {GPT_ENT_TYPE_EFI, "efi", "EFI partition"},
+ {GPT_ENT_TYPE_CHROMEOS_KERNEL, "croskern", "ChromeOS kernel"},
+ {GPT_ENT_TYPE_CHROMEOS_ROOTFS, "crosroot", "ChromeOS rootfs"},
+ {GPT_ENT_TYPE_CHROMEOS_RESERVED, "crosresv", "ChromeOS reserved"},
+};
+
+/* Resolves human-readable GPT type.
+ * Returns CGPT_OK if found.
+ * Returns CGPT_FAILED if no known type found. */
+int ResolveType(const Guid *type, char *buf) {
+  int i;
+  for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
+    if (!Memcmp(type, &supported_types[i].type, sizeof(Guid))) {
+      strcpy(buf, supported_types[i].description);
+      return CGPT_OK;
+    }
+  }
+  return CGPT_FAILED;
+}
+
+int SupportedType(const char *name, Guid *type) {
+  int i;
+  for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
+    if (!strcmp(name, supported_types[i].name)) {
+      Memcpy(type, &supported_types[i].type, sizeof(Guid));
+      return CGPT_OK;
+    }
+  }
+  return CGPT_FAILED;
+}
+
+void PrintTypes(void) {
+  int i;
+  printf("\n* For --type option, you can use the following alias, "
+         "instead of hex values:\n");
+  for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
+    printf("  %-10s %s\n", supported_types[i].name,
+                          supported_types[i].description);
+  }
+  printf("\n");
+}
+
 /* Loads sectors from 'fd'.
  * *buf is pointed to an allocated memory when returned, and should be
  * freed by cgpt_close().
  *
  *   fd -- file descriptot.
  *   buf -- pointer to buffer pointer
  *   sector -- offset of starting sector (in sectors)
  *   sector_bytes -- bytes per sector
  *   sector_count -- number of sectors to load
  *
@@ skipping 53 matching lines @@
   if (nwrote < count)
     return CGPT_FAILED;
 
   return CGPT_OK;
 }
 
 int CheckValid(const struct drive *drive) {
   if ((drive->gpt.valid_headers != MASK_BOTH) ||
       (drive->gpt.valid_entries != MASK_BOTH)) {
     printf("\n[ERROR] any of GPT header/entries is invalid, "
-           "please run --repair first\n");
+           "please run '%s repair' first\n", progname);
     return CGPT_FAILED;
   }
   return CGPT_OK;
 }
 
 /* Opens a block device (a regular file works well too).
  *
  * Returns CGPT_FAILED if any error happens.
  * Returns CGPT_OK if success and information are stored in 'drive'. */
 int DriveOpen(const char *drive_path, struct drive *drive) {
@@ skipping 28 matching lines @@
   } else {
     drive->gpt.sector_bytes = 512;  /* bytes */
     drive->size = stat.st_size;
   }
   if (drive->size % drive->gpt.sector_bytes) {
     printf("[ERROR] Media size (%llu) is not the multiple of sector size(%d)\n",
            (long long unsigned int)drive->size, drive->gpt.sector_bytes);
     goto error_close;
   }
   drive->gpt.drive_sectors = drive->size / drive->gpt.sector_bytes;
-  debug("drive: size:%llu sector_size:%d num_sector:%llu\n",
-        (long long unsigned int)drive->size, drive->gpt.sector_bytes,
-        (long long unsigned int)drive->gpt.drive_sectors);
 
   Load(drive->fd, &drive->gpt.primary_header, GPT_PMBR_SECTOR,
        drive->gpt.sector_bytes, GPT_HEADER_SECTOR);
   Load(drive->fd, &drive->gpt.secondary_header,
        drive->gpt.drive_sectors - GPT_PMBR_SECTOR,
        drive->gpt.sector_bytes, GPT_HEADER_SECTOR);
   Load(drive->fd, &drive->gpt.primary_entries,
        GPT_PMBR_SECTOR + GPT_HEADER_SECTOR,
        drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS);
   Load(drive->fd, &drive->gpt.secondary_entries,
@@ skipping 51 matching lines @@
 
   drive->inited = 0;
   return CGPT_OK;
 }
 
 int main(int argc, char *argv[]) {
   char *cmd;
   int i;
 
   progname = argv[0];
+  printf("Copyright (c) 2010 The Chromium OS Authors. All rights reserved.\n");
   cmd = argv[optind++];
   for (i = 0; i < sizeof(cmds)/sizeof(cmds[0]); ++i) {
     if (cmd && !strcmp(cmds[i].name, cmd))
       return cmds[i].fp(argc, argv);
   }
 
   Usage(0);
   return CGPT_FAILED;
 }