complete 'cgpt show' and refactor for incoming 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
+#include "endian.h"
+
+#define __USE_LARGEFILE64
+#define __USE_FILE_OFFSET64
+#define _LARGEFILE64_SOURCE
 #include "cgpt.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include "cgptlib_internal.h"
 #include "utility.h"
 
 /* For usage print */
 const char* progname;
 
 /* Lists all command here. */
 struct {
   const char *name;
   int (*fp)(int argc, char *argv[]);
   const char *comment;
@@ skipping 12 matching lines @@
   if (message) printf("%s\n", message);
   printf("Usage: %s COMMAND [OPTIONS]\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"
+ */
+void 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]);
+
+  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);
+}
+
+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]);
+}
+
+/* Convert UTF16 string to UTF8. Rewritten from gpt utility.
+ * Caller must prepare enough space for UTF8. The rough estimation is:
+ *
+ *   utf8 length = bytecount(utf16) * 1.5
+ */
+#define SIZEOF_GPTENTRY_NAME 36  /* sizeof(GptEntry.name[]) */
+void UTF16ToUTF8(const uint16_t *utf16, uint8_t *utf8)
+{
+  size_t s8idx, s16idx, s16len;
+  uint32_t utfchar;
+  unsigned int next_utf16;
+
+  for (s16len = 0; s16len < SIZEOF_GPTENTRY_NAME && utf16[s16len]; ++s16len);
+
+  *utf8 = s8idx = s16idx = 0;
+  while (s16idx < s16len) {
+    utfchar = le16toh(utf16[s16idx++]);
+    if ((utfchar & 0xf800) == 0xd800) {
+      next_utf16 = le16toh(utf16[s16idx]);
+      if ((utfchar & 0x400) != 0 || (next_utf16 & 0xfc00) != 0xdc00)
+        utfchar = 0xfffd;
+      else
+        s16idx++;
+    }
+    if (utfchar < 0x80) {
+      utf8[s8idx++] = utfchar;
+    } else if (utfchar < 0x800) {
+      utf8[s8idx++] = 0xc0 | (utfchar >> 6);
+      utf8[s8idx++] = 0x80 | (utfchar & 0x3f);
+    } else if (utfchar < 0x10000) {
+      utf8[s8idx++] = 0xe0 | (utfchar >> 12);
+      utf8[s8idx++] = 0x80 | ((utfchar >> 6) & 0x3f);
+      utf8[s8idx++] = 0x80 | (utfchar & 0x3f);
+    } else if (utfchar < 0x200000) {
+      utf8[s8idx++] = 0xf0 | (utfchar >> 18);
+      utf8[s8idx++] = 0x80 | ((utfchar >> 12) & 0x3f);
+      utf8[s8idx++] = 0x80 | ((utfchar >> 6) & 0x3f);
+      utf8[s8idx++] = 0x80 | (utfchar & 0x3f);
+    }
+  }
+}
+
+/* Convert UTF8 string to UTF16. Rewritten from gpt utility.
+ * Caller must prepare enough space for UTF16. The conservative estimation is:
+ *
+ *   utf16 bytecount = bytecount(utf8) / 3 * 4
+ */
+void UTF8ToUTF16(const uint8_t *utf8, uint16_t *utf16)
+{
+  size_t s16idx, s8idx, s8len;
+  uint32_t utfchar;
+  unsigned int c, utfbytes;
+
+  for (s8len = 0; utf8[s8len]; ++s8len);
+
+  s8idx = s16idx = 0;
+  utfbytes = 0;
+  do {
+    c = utf8[s8idx++];
+    if ((c & 0xc0) != 0x80) {
+      /* Initial characters. */
+      if (utfbytes != 0) {
+        /* Incomplete encoding. */
+        utf16[s16idx++] = 0xfffd;
+      }
+      if ((c & 0xf8) == 0xf0) {
+        utfchar = c & 0x07;
+        utfbytes = 3;
+      } else if ((c & 0xf0) == 0xe0) {
+        utfchar = c & 0x0f;
+        utfbytes = 2;
+      } else if ((c & 0xe0) == 0xc0) {
+        utfchar = c & 0x1f;
+        utfbytes = 1;
+      } else {
+        utfchar = c & 0x7f;
+        utfbytes = 0;
+      }
+    } else {
+      /* Followup characters. */
+      if (utfbytes > 0) {
+        utfchar = (utfchar << 6) + (c & 0x3f);
+        utfbytes--;
+      } else if (utfbytes == 0)
+        utfbytes = -1;
+        utfchar = 0xfffd;
+    }
+    if (utfbytes == 0) {
+      if (utfchar >= 0x10000) {
+        utf16[s16idx++] = htole16(0xd800 | ((utfchar>>10)-0x40));
+        if (s16idx >= SIZEOF_GPTENTRY_NAME) break;
+        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;
+}
+
 /* 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
  *
  * Returns CGPT_OK for successful. Aborts if any error occurs.
  */
 int Load(const int fd, uint8_t **buf,
          const uint64_t sector,
          const uint64_t sector_bytes,
          const uint64_t sector_count) {
   int count;  /* byte count to read */
   int nread;
 
   assert(buf);
   count = sector_bytes * sector_count;
   *buf = Malloc(count);
   assert(*buf);
 
-  if (-1 == lseek(fd, sector * sector_bytes, SEEK_SET))
+  if (-1 == lseek64(fd, sector * sector_bytes, SEEK_SET))
     goto error_free;
 
   nread = read(fd, *buf, count);
   if (nread < count)
     goto error_free;
 
   return CGPT_OK;
 
 error_free:
   Free(*buf);
@@ skipping 14 matching lines @@
 int Save(const int fd, const uint8_t *buf,
          const uint64_t sector,
          const uint64_t sector_bytes,
          const uint64_t sector_count) {
   int count;  /* byte count to write */
   int nwrote;
 
   assert(buf);
   count = sector_bytes * sector_count;
 
-  if (-1 == lseek(fd, sector * sector_bytes, SEEK_SET))
+  if (-1 == lseek64(fd, sector * sector_bytes, SEEK_SET))
     return CGPT_FAILED;
 
   nwrote = write(fd, buf, count);
   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");
+    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) {
   struct stat stat;
   int gpt_retval;
 
   assert(drive_path);
   assert(drive);
 
   Memset(drive, 0, sizeof(struct drive));
-  drive->fd = open(drive_path, O_RDWR);
+  drive->fd = open(drive_path, O_RDWR | O_LARGEFILE);
   if (drive->fd == -1) {
     printf("[ERROR] Cannot open drive file [%s]: %s\n",
            drive_path, strerror(errno));
     return CGPT_FAILED;
   }
 
   if (fstat(drive->fd, &stat) == -1) {
     goto error_close;
   }
   if ((stat.st_mode & S_IFMT) != S_IFREG) {
@@ skipping 26 matching lines @@
   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,
        drive->gpt.drive_sectors - GPT_HEADER_SECTOR - GPT_ENTRIES_SECTORS,
        drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS);
 
-  if (GPT_SUCCESS != (gpt_retval = GptInit(&drive->gpt))) {
-    printf("[ERROR] GptInit(): %s\n", GptError(gpt_retval));
+  if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive->gpt))) {
+    printf("[ERROR] GptSanityCheck(): %s\n", GptError(gpt_retval));
     goto error_close;
   }
 
   drive->inited = 1;
 
   return CGPT_OK;
 
 error_close:
   close(drive->fd);
   return CGPT_FAILED;
@@ skipping 45 matching lines @@
   progname = argv[0];
   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;
 }