Fixing the bug of CGPT when primary entry table is invalid.

cgpt/cgpt_common.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.
  */
 
 #include "cgpt.h"
 
@@ skipping 462 matching lines @@
 }
 
 GptEntry *GetEntry(GptData *gpt, int secondary, uint32_t entry_index) {
   uint8_t *entries;
   uint32_t stride = GetSizeOfEntries(gpt);
   require(stride);
   require(entry_index < GetNumberOfEntries(gpt));
 
   if (secondary == PRIMARY) {
     entries = gpt->primary_entries;
-  } else {
+  } else if (secondary == SECONDARY) {
     entries = gpt->secondary_entries;
+  } else {  /* ANY_VALID */
+    require(ANY_VALID);

[Bill Richardson, 2010/11/17 18:06:24]

'require' is just 'assert' that doesn't compile away. You don't need to assert a
constant.

[Louis, 2010/11/18 01:51:29]

This is a typo. Should be "require(secondary==ANY_VALID);

Thank for the catch.
On 2010/11/17 18:06:24, Bill Richardson wrote:

+    if (gpt->valid_entries & MASK_PRIMARY) {
+      entries = gpt->primary_entries;
+    } else {
+      require(gpt->valid_entries & MASK_SECONDARY);
+      entries = gpt->secondary_entries;
+    }
   }
 
   return (GptEntry*)(&entries[stride * entry_index]);
 }
 
 void SetPriority(GptData *gpt, int secondary, uint32_t entry_index,
                  int priority) {
   GptEntry *entry;
   entry = GetEntry(gpt, secondary, entry_index);
   require(priority >= 0 && priority <= CGPT_ATTRIBUTE_MAX_PRIORITY);
@@ skipping 68 matching lines @@
     primary_header->entries_crc32 =
         Crc32(gpt->primary_entries, TOTAL_ENTRIES_SIZE);
   }
   if (gpt->modified & GPT_MODIFIED_ENTRIES2) {
     secondary_header->entries_crc32 =
         Crc32(gpt->secondary_entries, TOTAL_ENTRIES_SIZE);
   }
   if (gpt->modified & GPT_MODIFIED_HEADER1) {
     primary_header->header_crc32 = 0;
     primary_header->header_crc32 = Crc32(
-        (const uint8_t *)primary_header, primary_header->size);
+        (const uint8_t *)primary_header, sizeof(GptHeader));
   }
   if (gpt->modified & GPT_MODIFIED_HEADER2) {
     secondary_header->header_crc32 = 0;
     secondary_header->header_crc32 = Crc32(
-        (const uint8_t *)secondary_header, secondary_header->size);
+        (const uint8_t *)secondary_header, sizeof(GptHeader));
   }
 }
 /* Two headers are NOT bitwise identical. For example, my_lba pointers to header
  * itself so that my_lba in primary and secondary is definitely different.
  * Only the following fields should be identical.
  *
  *   first_usable_lba
  *   last_usable_lba
  *   number_of_entries
  *   size_of_entry
@@ skipping 66 matching lines @@
 
   primary_header = (GptHeader*)gpt->primary_header;
   secondary_header = (GptHeader*)gpt->secondary_header;
 
   if (valid_headers == MASK_BOTH) {
     if (!IsSynonymous(primary_header, secondary_header)) {
       CopySynonymousParts(secondary_header, primary_header);
       return GPT_MODIFIED_HEADER2;
     }
   } else if (valid_headers == MASK_PRIMARY) {
-    memcpy(secondary_header, primary_header, primary_header->size);
+    memcpy(secondary_header, primary_header, sizeof(GptHeader));
     secondary_header->my_lba = gpt->drive_sectors - 1;  /* the last sector */
     secondary_header->alternate_lba = primary_header->my_lba;
     secondary_header->entries_lba = secondary_header->my_lba -
         GPT_ENTRIES_SECTORS;
     return GPT_MODIFIED_HEADER2;
   } else if (valid_headers == MASK_SECONDARY) {
-    memcpy(primary_header, secondary_header, secondary_header->size);
+    memcpy(primary_header, secondary_header, sizeof(GptHeader));
     primary_header->my_lba = GPT_PMBR_SECTOR;  /* the second sector on drive */
     primary_header->alternate_lba = secondary_header->my_lba;
     primary_header->entries_lba = primary_header->my_lba + GPT_HEADER_SECTOR;
     return GPT_MODIFIED_HEADER1;
   }
 
   return 0;
 }
 
 
 int IsZero(const Guid *gp) {
   return (0 == memcmp(gp, &guid_unused, sizeof(Guid)));
 }
 
 void PMBRToStr(struct pmbr *pmbr, char *str, unsigned int buflen) {
   char buf[GUID_STRLEN];
   if (IsZero(&pmbr->boot_guid)) {
     require(snprintf(str, buflen, "PMBR") < buflen);
   } else {
     GuidToStr(&pmbr->boot_guid, buf, sizeof(buf));
     require(snprintf(str, buflen, "PMBR (Boot GUID: %s)", buf) < buflen);
   }
 }
-