Initial git repository creation, version 0.3.1 plus changes
diff --git a/gpt.cc b/gpt.cc
new file mode 100644
index 0000000..83bf046
--- /dev/null
+++ b/gpt.cc
@@ -0,0 +1,1660 @@
+/* gpt.cc -- Functions for loading, saving, and manipulating legacy MBR and GPT partition
+ data. */
+
+/* By Rod Smith, January to February, 2009 */
+
+#define __STDC_LIMIT_MACROS
+#define __STDC_CONSTANT_MACROS
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <string.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include "crc32.h"
+#include "gpt.h"
+#include "support.h"
+#include "parttypes.h"
+#include "attributes.h"
+
+using namespace std;
+
+/****************************************
+ * *
+ * GPTData class and related structures *
+ * *
+ ****************************************/
+
+GPTData::GPTData(void) {
+ blockSize = SECTOR_SIZE; // set a default
+ diskSize = 0;
+ partitions = NULL;
+ state = gpt_valid;
+ strcpy(device, "");
+ mainCrcOk = 0;
+ secondCrcOk = 0;
+ mainPartsCrcOk = 0;
+ secondPartsCrcOk = 0;
+ srand((unsigned int) time(NULL));
+ SetGPTSize(NUM_GPT_ENTRIES);
+} // GPTData default constructor
+
+// The following constructor loads GPT data from a device file
+GPTData::GPTData(char* filename) {
+ blockSize = SECTOR_SIZE; // set a default
+ diskSize = 0;
+ partitions = NULL;
+ state = gpt_invalid;
+ strcpy(device, "");
+ mainCrcOk = 0;
+ secondCrcOk = 0;
+ mainPartsCrcOk = 0;
+ secondPartsCrcOk = 0;
+ srand((unsigned int) time(NULL));
+ LoadPartitions(filename);
+} // GPTData(char* filename) constructor
+
+GPTData::~GPTData(void) {
+ free(partitions);
+} // GPTData destructor
+
+// Resizes GPT to specified number of entries. Creates a new table if
+// necessary, copies data if it already exists.
+int GPTData::SetGPTSize(uint32_t numEntries) {
+ struct GPTPartition* newParts;
+ struct GPTPartition* trash;
+ uint32_t i, high, copyNum;
+ int allOK = 1;
+
+ // First, adjust numEntries upward, if necessary, to get a number
+ // that fills the allocated sectors
+ i = blockSize / GPT_SIZE;
+ if ((numEntries % i) != 0) {
+ printf("Adjusting GPT size from %lu ", (unsigned long) numEntries);
+ numEntries = ((numEntries / i) + 1) * i;
+ printf("to %lu to fill the sector\n", (unsigned long) numEntries);
+ } // if
+
+ newParts = (struct GPTPartition*) calloc(numEntries, sizeof (struct GPTPartition));
+ if (newParts != NULL) {
+ if (partitions != NULL) { // existing partitions; copy them over
+ GetPartRange(&i, &high);
+ if (numEntries < (high + 1)) { // Highest entry too high for new #
+ printf("The highest-numbered partition is %lu, which is greater than the requested\n"
+ "partition table size of %d; cannot resize. Perhaps sorting will help.\n",
+ (unsigned long) (high + 1), numEntries);
+ allOK = 0;
+ } else { // go ahead with copy
+ if (numEntries < mainHeader.numParts)
+ copyNum = numEntries;
+ else
+ copyNum = mainHeader.numParts;
+ for (i = 0; i < copyNum; i++) {
+ newParts[i] = partitions[i];
+ } // for
+ trash = partitions;
+ partitions = newParts;
+ free(trash);
+ } // if
+ } else { // No existing partition table; just create it
+ partitions = newParts;
+ } // if/else existing partitions
+ mainHeader.numParts = numEntries;
+ secondHeader.numParts = numEntries;
+ mainHeader.firstUsableLBA = ((numEntries * GPT_SIZE) / blockSize) + 2 ;
+ secondHeader.firstUsableLBA = mainHeader.firstUsableLBA;
+ mainHeader.lastUsableLBA = diskSize - mainHeader.firstUsableLBA;
+ secondHeader.lastUsableLBA = mainHeader.lastUsableLBA;
+ secondHeader.partitionEntriesLBA = secondHeader.lastUsableLBA + UINT64_C(1);
+ if (diskSize > 0)
+ CheckGPTSize();
+ } else { // Bad memory allocation
+ fprintf(stderr, "Error allocating memory for partition table!\n");
+ allOK = 0;
+ } // if/else
+ return (allOK);
+} // GPTData::SetGPTSize()
+
+// Checks to see if the GPT tables overrun existing partitions; if they
+// do, issues a warning but takes no action. Returns 1 if all is OK, 0
+// if problems were detected.
+int GPTData::CheckGPTSize(void) {
+ uint64_t overlap, firstUsedBlock, lastUsedBlock;
+ uint32_t i;
+ int allOK = 1;
+
+ // first, locate the first & last used blocks
+ firstUsedBlock = UINT64_MAX;
+ lastUsedBlock = 0;
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((partitions[i].firstLBA < firstUsedBlock) &&
+ (partitions[i].firstLBA != 0))
+ firstUsedBlock = partitions[i].firstLBA;
+ if (partitions[i].lastLBA > lastUsedBlock)
+ lastUsedBlock = partitions[i].lastLBA;
+ } // for
+
+ // If the disk size is 0 (the default), then it means that various
+ // variables aren't yet set, so the below tests will be useless;
+ // therefore we should skip everything
+ if (diskSize != 0) {
+ if (mainHeader.firstUsableLBA > firstUsedBlock) {
+ overlap = mainHeader.firstUsableLBA - firstUsedBlock;
+ printf("Warning! Main partition table overlaps the first partition by %lu\n"
+ "blocks! Try reducing the partition table size by %lu entries.\n",
+ (unsigned long) overlap, (unsigned long) (overlap * 4));
+ printf("(Use the 's' item on the experts' menu.)\n");
+ allOK = 0;
+ } // Problem at start of disk
+ if (mainHeader.lastUsableLBA < lastUsedBlock) {
+ overlap = lastUsedBlock - mainHeader.lastUsableLBA;
+ printf("Warning! Secondary partition table overlaps the last partition by %lu\n"
+ "blocks! Try reducing the partition table size by %lu entries.\n",
+ (unsigned long) overlap, (unsigned long) (overlap * 4));
+ printf("(Use the 's' item on the experts' menu.)\n");
+ allOK = 0;
+ } // Problem at end of disk
+ } // if (diskSize != 0)
+ return allOK;
+} // GPTData::CheckGPTSize()
+
+// Read GPT data from a disk.
+int GPTData::LoadPartitions(char* deviceFilename) {
+ int fd, err;
+ int allOK = 1, i;
+ uint64_t firstBlock, lastBlock;
+
+ if ((fd = open(deviceFilename, O_RDONLY)) != -1) {
+ // store disk information....
+ diskSize = disksize(fd, &err);
+ blockSize = (uint32_t) GetBlockSize(fd);
+ strcpy(device, deviceFilename);
+
+ // Read the MBR
+ protectiveMBR.ReadMBRData(fd);
+
+ // Load the GPT data, whether or not it's valid
+ ForceLoadGPTData(fd);
+
+ switch (UseWhichPartitions()) {
+ case use_mbr:
+// printf("In LoadPartitions(), using MBR\n");
+ XFormPartitions(&protectiveMBR);
+ break;
+ case use_gpt:
+ break;
+ case use_new:
+// printf("In LoadPartitions(), making new\n");
+ ClearGPTData();
+ protectiveMBR.MakeProtectiveMBR();
+ break;
+ } // switch
+
+ // Now find the first and last sectors used by partitions...
+ if (allOK) {
+ firstBlock = mainHeader.backupLBA; // start high
+ lastBlock = 0; // start low
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((partitions[i].firstLBA < firstBlock) &&
+ (partitions[i].firstLBA > 0))
+ firstBlock = partitions[i].firstLBA;
+ if (partitions[i].lastLBA > lastBlock)
+ lastBlock = partitions[i].lastLBA;
+ } // for
+ } // if
+ CheckGPTSize();
+ } else {
+ allOK = 0;
+ fprintf(stderr, "Problem opening %s for reading!\n",
+ deviceFilename);
+ } // if/else
+ return (allOK);
+} // GPTData::LoadPartitions()
+
+// Loads the GPT, as much as possible. Returns 1 if this seems to have
+// succeeded, 0 if there are obvious problems....
+int GPTData::ForceLoadGPTData(int fd) {
+ int allOK = 1, validHeaders;
+ off_t seekTo;
+ char* storage;
+ uint32_t newCRC, sizeOfParts;
+
+ // Seek to and read the main GPT header
+ lseek64(fd, 512, SEEK_SET);
+ read(fd, &mainHeader, 512); // read main GPT header
+ mainCrcOk = CheckHeaderCRC(&mainHeader);
+
+ // Load backup header, check its CRC, and store the results of
+ // the check for future reference
+ seekTo = (diskSize * blockSize) - UINT64_C(512);
+ if (lseek64(fd, seekTo, SEEK_SET) != (off_t) -1) {
+ read(fd, &secondHeader, 512); // read secondary GPT header
+ secondCrcOk = CheckHeaderCRC(&secondHeader);
+ } else {
+ allOK = 0;
+ state = gpt_invalid;
+ fprintf(stderr, "Unable to seek to secondary GPT at sector %llu!\n",
+ diskSize - (UINT64_C(1)));
+ } // if/else lseek
+
+ // Return valid headers code: 0 = both headers bad; 1 = main header
+ // good, backup bad; 2 = backup header good, main header bad;
+ // 3 = both headers good. Note these codes refer to valid GPT
+ // signatures and version numbers; more subtle problems will elude
+ // this check!
+ validHeaders = CheckHeaderValidity();
+
+ // Read partitions (from primary array)
+ if (validHeaders > 0) { // if at least one header is OK....
+ // GPT appears to be valid....
+ state = gpt_valid;
+
+ // We're calling the GPT valid, but there's a possibility that one
+ // of the two headers is corrupt. If so, use the one that seems to
+ // be in better shape to regenerate the bad one
+ if (validHeaders == 2) { // valid backup header, invalid main header
+ printf("Caution: invalid main GPT header, but valid backup; regenerating main header\n"
+ "from backup!\n");
+ RebuildMainHeader();
+ mainCrcOk = secondCrcOk; // Since copied, use CRC validity of backup
+ } else if (validHeaders == 1) { // valid main header, invalid backup
+ printf("Caution: invalid backup GPT header, but valid main header; regenerating\n"
+ "backup header from main header.\n");
+ RebuildSecondHeader();
+ secondCrcOk = mainCrcOk; // Since regenerated, use CRC validity of main
+ } // if/else/if
+
+ // Load the main partition table, including storing results of its
+ // CRC check
+ if (LoadMainTable() == 0)
+ allOK = 0;
+
+ // Load backup partition table into temporary storage to check
+ // its CRC and store the results, then discard this temporary
+ // storage, since we don't use it in any but recovery operations
+ seekTo = secondHeader.partitionEntriesLBA * (off_t) blockSize;
+ if ((lseek64(fd, seekTo, SEEK_SET) != (off_t) -1) && (secondCrcOk)) {
+ sizeOfParts = secondHeader.numParts * secondHeader.sizeOfPartitionEntries;
+ storage = (char*) malloc(sizeOfParts);
+ read(fd, storage, sizeOfParts);
+ newCRC = chksum_crc32((unsigned char*) storage, sizeOfParts);
+ free(storage);
+ secondPartsCrcOk = (newCRC == secondHeader.partitionEntriesCRC);
+ } // if
+
+ // Check for valid CRCs and warn if there are problems
+ if ((mainCrcOk == 0) || (secondCrcOk == 0) || (mainPartsCrcOk == 0) ||
+ (secondPartsCrcOk == 0)) {
+ printf("Warning! One or more CRCs don't match. You should repair the disk!\n");
+ state = gpt_corrupt;
+ } // if
+ } else {
+ state = gpt_invalid;
+ } // if/else
+ return allOK;
+} // GPTData::ForceLoadGPTData()
+
+// Loads the partition tables pointed to by the main GPT header. The
+// main GPT header in memory MUST be valid for this call to do anything
+// sensible!
+int GPTData::LoadMainTable(void) {
+ int fd, retval = 0;
+ uint32_t newCRC, sizeOfParts;
+
+ if ((fd = open(device, O_RDONLY)) != -1) {
+ // Set internal data structures for number of partitions on the disk
+ SetGPTSize(mainHeader.numParts);
+
+ // Load main partition table, and record whether its CRC
+ // matches the stored value
+ lseek64(fd, mainHeader.partitionEntriesLBA * blockSize, SEEK_SET);
+ sizeOfParts = mainHeader.numParts * mainHeader.sizeOfPartitionEntries;
+ read(fd, partitions, sizeOfParts);
+ newCRC = chksum_crc32((unsigned char*) partitions, sizeOfParts);
+ mainPartsCrcOk = (newCRC == mainHeader.partitionEntriesCRC);
+ retval = 1;
+ } // if
+ return retval;
+} // GPTData::LoadMainTable()
+
+// Examines the MBR & GPT data, and perhaps asks the user questions, to
+// determine which set of data to use: the MBR (use_mbr), the GPT (use_gpt),
+// or create a new set of partitions (use_new)
+WhichToUse GPTData::UseWhichPartitions(void) {
+ WhichToUse which = use_new;
+ MBRValidity mbrState;
+ int answer;
+
+ mbrState = protectiveMBR.GetValidity();
+
+ if ((state == gpt_invalid) && (mbrState == mbr)) {
+ printf("\n\a***************************************************************\n"
+ "Found invalid GPT and valid MBR; converting MBR to GPT format.\n"
+ "THIS OPERATON IS POTENTIALLY DESTRUCTIVE! Exit by typing 'q' if\n"
+ "you don't want to convert your MBR partitions to GPT format!\n"
+ "***************************************************************\n\n");
+ which = use_mbr;
+ } // if
+ if ((state == gpt_valid) && (mbrState == gpt)) {
+ printf("Found valid GPT with protective MBR; using GPT.\n");
+ which = use_gpt;
+ } // if
+ if ((state == gpt_valid) && (mbrState == invalid)) {
+ printf("\aFound valid GPT with corrupt MBR; using GPT and will create new\nprotective MBR on save.\n");
+ which = use_gpt;
+ protectiveMBR.MakeProtectiveMBR();
+ } // if
+ if ((state == gpt_valid) && (mbrState == mbr)) {
+ printf("Found valid MBR and GPT. Which do you want to use?\n");
+ answer = GetNumber(1, 3, 2, (char*) " 1 - MBR\n 2 - GPT\n 3 - Create blank GPT\n\nYour answer: ");
+ if (answer == 1) {
+ which = use_mbr;
+ } else if (answer == 2) {
+ which = use_gpt;
+ protectiveMBR.MakeProtectiveMBR();
+ printf("Using GPT and creating fresh protective MBR.\n");
+ } else which = use_new;
+ } // if
+
+ // Nasty decisions here -- GPT is present, but corrupt (bad CRCs or other
+ // problems)
+ if (state == gpt_corrupt) {
+ if (mbrState == mbr) {
+ printf("Found valid MBR and corrupt GPT. Which do you want to use? (Using the\n"
+ "GPT MAY permit recovery of GPT data.)\n");
+ answer = GetNumber(1, 3, 2, (char*) " 1 - MBR\n 2 - GPT\n 3 - Create blank GPT\n\nYour answer: ");
+ if (answer == 1) {
+ which = use_mbr;
+// protectiveMBR.MakeProtectiveMBR();
+ } else if (answer == 2) {
+ which = use_gpt;
+ } else which = use_new;
+ } else if (mbrState == invalid) {
+ printf("Found invalid MBR and corrupt GPT. What do you want to do? (Using the\n"
+ "GPT MAY permit recovery of GPT data.)\n");
+ answer = GetNumber(1, 2, 1, (char*) " 1 - GPT\n 2 - Create blank GPT\n\nYour answer: ");
+ if (answer == 1) {
+ which = use_gpt;
+ } else which = use_new;
+ } else {
+ printf("\a\a****************************************************************************\n"
+ "Caution: Found protective or hybrid MBR and corrupt GPT. Using GPT, but disk\n"
+ "verification and recovery are STRONGLY recommended.\n"
+ "****************************************************************************\n");
+ } // if
+ } // if
+
+ if (which == use_new)
+ printf("Creating new GPT entries.\n");
+
+ return which;
+} // UseWhichPartitions()
+
+void GPTData::ResizePartitionTable(void) {
+ int newSize;
+ char prompt[255];
+ uint32_t curLow, curHigh;
+
+ printf("Current partition table size is %lu.\n",
+ (unsigned long) mainHeader.numParts);
+ GetPartRange(&curLow, &curHigh);
+ curHigh++; // since GetPartRange() returns numbers starting from 0...
+ // There's no point in having fewer than four partitions....
+ if (curHigh < 4)
+ curHigh = 4;
+ sprintf(prompt, "Enter new size (%d up, default %d): ", (int) curHigh,
+ (int) NUM_GPT_ENTRIES);
+ newSize = GetNumber(4, 65535, 128, prompt);
+ if (newSize < 128) {
+ printf("Caution: The partition table size should officially be 16KB or larger,\n"
+ "which works out to 128 entries. In practice, smaller tables seem to\n"
+ "work with most OSes, but this practice is risky. I'm proceeding with\n"
+ "the resize, but you may want to reconsider this action and undo it.\n\n");
+ } // if
+ SetGPTSize(newSize);
+} // GPTData::ResizePartitionTable()
+
+// Find the low and high used partition numbers (numbered from 0).
+// Return value is the number of partitions found. Note that the
+// *low and *high values are both set to 0 when no partitions
+// are found, as well as when a single partition in the first
+// position exists. Thus, the return value is the only way to
+// tell when no partitions exist.
+int GPTData::GetPartRange(uint32_t *low, uint32_t *high) {
+ uint32_t i;
+ int numFound = 0;
+
+ *low = mainHeader.numParts + 1; // code for "not found"
+ *high = 0;
+ if (mainHeader.numParts > 0) { // only try if partition table exists...
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if (partitions[i].firstLBA != UINT64_C(0)) { // it exists
+ *high = i; // since we're counting up, set the high value
+ // Set the low value only if it's not yet found...
+ if (*low == (mainHeader.numParts + 1)) *low = i;
+ numFound++;
+ } // if
+ } // for
+ } // if
+
+ // Above will leave *low pointing to its "not found" value if no partitions
+ // are defined, so reset to 0 if this is the case....
+ if (*low == (mainHeader.numParts + 1))
+ *low = 0;
+ return numFound;
+} // GPTData::GetPartRange()
+
+// Display the basic GPT data
+void GPTData::DisplayGPTData(void) {
+ int i, j;
+ char sizeInSI[255]; // String to hold size of disk in SI units
+ char tempStr[255];
+ uint64_t temp, totalFree;
+
+ BytesToSI(diskSize * blockSize, sizeInSI);
+ printf("Disk %s: %lu sectors, %s\n", device,
+ (unsigned long) diskSize, sizeInSI);
+ printf("Disk identifier (GUID): %s\n", GUIDToStr(mainHeader.diskGUID, tempStr));
+ printf("Partition table holds up to %lu entries\n", (unsigned long) mainHeader.numParts);
+ printf("First usable sector is %lu, last usable sector is %lu\n",
+ (unsigned long) mainHeader.firstUsableLBA,
+ (unsigned long) mainHeader.lastUsableLBA);
+ totalFree = FindFreeBlocks(&i, &temp);
+ printf("Total free space is %llu sectors (%s)\n", totalFree,
+ BytesToSI(totalFree * (uint64_t) blockSize, sizeInSI));
+ printf("\nNumber Start (block) End (block) Size Code Name\n");
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if (partitions[i].firstLBA != 0) {
+ BytesToSI(blockSize * (partitions[i].lastLBA - partitions[i].firstLBA + 1),
+ sizeInSI);
+ printf("%4d %14lu %14lu ", i + 1, (unsigned long) partitions[i].firstLBA,
+ (unsigned long) partitions[i].lastLBA);
+ printf(" %-10s %04X ", sizeInSI,
+ typeHelper.GUIDToID(partitions[i].partitionType));
+ j = 0;
+ while ((partitions[i].name[j] != '\0') && (j < 44)) {
+ printf("%c", partitions[i].name[j]);
+ j += 2;
+ } // while
+ printf("\n");
+ } // if
+ } // for
+} // GPTData::DisplayGPTData()
+
+// Get partition number from user and then call ShowPartDetails(partNum)
+// to show its detailed information
+void GPTData::ShowDetails(void) {
+ int partNum;
+ uint32_t low, high;
+
+ if (GetPartRange(&low, &high) > 0) {
+ partNum = GetPartNum();
+ ShowPartDetails(partNum);
+ } else {
+ printf("No partitions\n");
+ } // if/else
+} // GPTData::ShowDetails()
+
+// Show detailed information on the specified partition
+void GPTData::ShowPartDetails(uint32_t partNum) {
+ char temp[255];
+ int i;
+ uint64_t size;
+
+ if (partitions[partNum].firstLBA != 0) {
+ printf("Partition GUID code: %s ", GUIDToStr(partitions[partNum].partitionType, temp));
+ printf("(%s)\n", typeHelper.GUIDToName(partitions[partNum].partitionType, temp));
+ printf("Partition unique GUID: %s\n", GUIDToStr(partitions[partNum].uniqueGUID, temp));
+
+ printf("First sector: %llu (at %s)\n", (unsigned long long)
+ partitions[partNum].firstLBA,
+ BytesToSI(partitions[partNum].firstLBA * blockSize, temp));
+ printf("Last sector: %llu (at %s)\n", (unsigned long long)
+ partitions[partNum].lastLBA,
+ BytesToSI(partitions[partNum].lastLBA * blockSize, temp));
+ size = (partitions[partNum].lastLBA - partitions[partNum].firstLBA + 1);
+ printf("Partition size: %llu sectprs (%s)\n", (unsigned long long)
+ size, BytesToSI(size * ((uint64_t) blockSize), temp));
+ printf("Attribute flags: %016llx\n", (unsigned long long)
+ partitions[partNum].attributes);
+ printf("Partition name: ");
+ i = 0;
+ while ((partitions[partNum].name[i] != '\0') && (i < NAME_SIZE)) {
+ printf("%c", partitions[partNum].name[i]);
+ i += 2;
+ } // while
+ printf("\n");
+ } else {
+ printf("Partition #%d does not exist.", (int) (partNum + 1));
+ } // if
+} // GPTData::ShowPartDetails()
+
+// Interactively create a partition
+void GPTData::CreatePartition(void) {
+ uint64_t firstBlock, lastBlock, sector;
+ char prompt[255];
+ int partNum, firstFreePart = 0;
+
+ // Find first free partition...
+ while (partitions[firstFreePart].firstLBA != 0) {
+ firstFreePart++;
+ } // while
+
+ if (((firstBlock = FindFirstAvailable()) != 0) &&
+ (firstFreePart < mainHeader.numParts)) {
+ lastBlock = FindLastAvailable(firstBlock);
+
+ // Get partition number....
+ do {
+ sprintf(prompt, "Partition number (%d-%d, default %d): ", firstFreePart + 1,
+ mainHeader.numParts, firstFreePart + 1);
+ partNum = GetNumber(firstFreePart + 1, mainHeader.numParts,
+ firstFreePart + 1, prompt) - 1;
+ if (partitions[partNum].firstLBA != 0)
+ printf("partition %d is in use.\n", partNum + 1);
+ } while (partitions[partNum].firstLBA != 0);
+
+ // Get first block for new partition...
+ sprintf(prompt, "First sector (%llu-%llu, default = %llu): ", firstBlock,
+ lastBlock, firstBlock);
+ do {
+ sector = GetNumber(firstBlock, lastBlock, firstBlock, prompt);
+ } while (IsFree(sector) == 0);
+ firstBlock = sector;
+
+ // Get last block for new partitions...
+ lastBlock = FindLastInFree(firstBlock);
+ sprintf(prompt, "Last sector or +size or +sizeM or +sizeK (%llu-%llu, default = %d): ",
+ firstBlock, lastBlock, lastBlock);
+ do {
+ sector = GetLastSector(firstBlock, lastBlock, prompt);
+ } while (IsFree(sector) == 0);
+ lastBlock = sector;
+
+ partitions[partNum].firstLBA = firstBlock;
+ partitions[partNum].lastLBA = lastBlock;
+
+ // rand() is only 32 bits on 32-bit systems, so multiply together to
+ // fill a 64-bit value.
+ partitions[partNum].uniqueGUID.data1 = (uint64_t) rand() * (uint64_t) rand();
+ partitions[partNum].uniqueGUID.data2 = (uint64_t) rand() * (uint64_t) rand();
+ ChangeGPTType(&partitions[partNum]);
+ } else {
+ printf("No free sectors available\n");
+ } // if/else
+} // GPTData::CreatePartition()
+
+// Interactively delete a partition (duh!)
+void GPTData::DeletePartition(void) {
+ int partNum;
+ uint32_t low, high;
+ char prompt[255];
+
+ if (GetPartRange(&low, &high) > 0) {
+ sprintf(prompt, "Partition number (%d-%d): ", low + 1, high + 1);
+ partNum = GetNumber(low + 1, high + 1, low, prompt);
+ BlankPartition(&partitions[partNum - 1]);
+ } else {
+ printf("No partitions\n");
+ } // if/else
+} // GPTData::DeletePartition
+
+// Find the first available block after the starting point; returns 0 if
+// there are no available blocks left
+uint64_t GPTData::FindFirstAvailable(uint64_t start) {
+ uint64_t first;
+ uint32_t i;
+ int firstMoved = 0;
+
+ // Begin from the specified starting point or from the first usable
+ // LBA, whichever is greater...
+ if (start < mainHeader.firstUsableLBA)
+ first = mainHeader.firstUsableLBA;
+ else
+ first = start;
+
+ // ...now search through all partitions; if first is within an
+ // existing partition, move it to the next sector after that
+ // partition and repeat. If first was moved, set firstMoved
+ // flag; repeat until firstMoved is not set, so as to catch
+ // cases where partitions are out of sequential order....
+ do {
+ firstMoved = 0;
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((first >= partitions[i].firstLBA) &&
+ (first <= partitions[i].lastLBA)) { // in existing part.
+ first = partitions[i].lastLBA + 1;
+ firstMoved = 1;
+ } // if
+ } // for
+ } while (firstMoved == 1);
+ if (first > mainHeader.lastUsableLBA)
+ first = 0;
+ return (first);
+} // GPTData::FindFirstAvailable()
+
+// Find the last available block on the disk at or after the start
+// block. Returns 0 if there are no available partitions after
+// (or including) start.
+uint64_t GPTData::FindLastAvailable(uint64_t start) {
+ uint64_t last;
+ uint32_t i;
+ int lastMoved = 0;
+
+ // Start by assuming the last usable LBA is available....
+ last = mainHeader.lastUsableLBA;
+
+ // ...now, similar to algorithm in FindFirstAvailable(), search
+ // through all partitions, moving last when it's in an existing
+ // partition. Set the lastMoved flag so we repeat to catch cases
+ // where partitions are out of logical order.
+ do {
+ lastMoved = 0;
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((last >= partitions[i].firstLBA) &&
+ (last <= partitions[i].lastLBA)) { // in existing part.
+ last = partitions[i].firstLBA - 1;
+ lastMoved = 1;
+ } // if
+ } // for
+ } while (lastMoved == 1);
+ if (last < mainHeader.firstUsableLBA)
+ last = 0;
+ return (last);
+} // GPTData::FindLastAvailable()
+
+// Find the last available block in the free space pointed to by start.
+uint64_t GPTData::FindLastInFree(uint64_t start) {
+ uint64_t nearestStart;
+ uint32_t i;
+
+ nearestStart = mainHeader.lastUsableLBA;
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((nearestStart > partitions[i].firstLBA) &&
+ (partitions[i].firstLBA > start)) {
+ nearestStart = partitions[i].firstLBA - 1;
+ } // if
+ } // for
+ return (nearestStart);
+} // GPTData::FindLastInFree()
+
+// Returns 1 if sector is unallocated, 0 if it's allocated to a partition
+int GPTData::IsFree(uint64_t sector) {
+ int isFree = 1;
+ uint32_t i;
+
+ for (i = 0; i < mainHeader.numParts; i++) {
+ if ((sector >= partitions[i].firstLBA) &&
+ (sector <= partitions[i].lastLBA)) {
+ isFree = 0;
+ } // if
+ } // for
+ if ((sector < mainHeader.firstUsableLBA) ||
+ (sector > mainHeader.lastUsableLBA)) {
+ isFree = 0;
+ } // if
+ return (isFree);
+} // GPTData::IsFree()
+
+int GPTData::XFormPartitions(MBRData* origParts) {
+ int i, j;
+ int numToConvert;
+ uint8_t origType;
+
+ // Clear out old data & prepare basics....
+ ClearGPTData();
+
+ // Convert the smaller of the # of GPT or MBR partitions
+ if (mainHeader.numParts > (NUM_LOGICALS + 4))
+ numToConvert = NUM_LOGICALS + 4;
+ else
+ numToConvert = mainHeader.numParts;
+
+// printf("In XFormPartitions(), numToConvert = %d\n", numToConvert);
+
+ for (i = 0; i < numToConvert; i++) {
+ origType = origParts->GetType(i);
+// printf("Converting partition of type 0x%02X\n", (int) origType);
+
+ // don't convert extended partitions or null (non-existent) partitions
+ if ((origType != 0x05) && (origType != 0x0f) && (origType != 0x00)) {
+ partitions[i].firstLBA = (uint64_t) origParts->GetFirstSector(i);
+ partitions[i].lastLBA = partitions[i].firstLBA + (uint64_t)
+ origParts->GetLength(i) - 1;
+ partitions[i].partitionType = typeHelper.IDToGUID(((uint16_t) origType) * 0x0100);
+
+ // Create random unique GUIDs for the partitions
+ // rand() is only 32 bits, so multiply together to fill a 64-bit value
+ partitions[i].uniqueGUID.data1 = (uint64_t) rand() * (uint64_t) rand();
+ partitions[i].uniqueGUID.data2 = (uint64_t) rand() * (uint64_t) rand();
+ partitions[i].attributes = 0;
+ for (j = 0; j < NAME_SIZE; j++)
+ partitions[i].name[j] = '\0';
+ } // if
+ } // for
+
+ // Convert MBR into protective MBR
+ protectiveMBR.MakeProtectiveMBR();
+
+ // Record that all original CRCs were OK so as not to raise flags
+ // when doing a disk verification
+ mainCrcOk = secondCrcOk = mainPartsCrcOk = secondPartsCrcOk = 1;
+
+ return (1);
+} // XFormPartitions()
+
+// Sort the GPT entries, eliminating gaps and making for a logical
+// ordering. Relies on QuickSortGPT() for the bulk of the work
+void GPTData::SortGPT(void) {
+ int i, lastPart = 0;
+ struct GPTPartition temp;
+
+ // First, find the last partition with data, so as not to
+ // spend needless time sorting empty entries....
+ for (i = 0; i < GPT_SIZE; i++) {
+ if (partitions[i].firstLBA > 0)
+ lastPart = i;
+ } // for
+
+ // Now swap empties with the last partitions, to simplify the logic
+ // in the Quicksort function....
+ i = 0;
+ while (i < lastPart) {
+ if (partitions[i].firstLBA == 0) {
+ temp = partitions[i];
+ partitions[i] = partitions[lastPart];
+ partitions[lastPart] = temp;
+ lastPart--;
+ } // if
+ i++;
+ } // while
+
+ // Now call the recursive quick sort routine to do the real work....
+ QuickSortGPT(partitions, 0, lastPart);
+} // GPTData::SortGPT()
+
+// Recursive quick sort algorithm for GPT partitions. Note that if there
+// are any empties in the specified range, they'll be sorted to the
+// start, resulting in a sorted set of partitions that begins with
+// partition 2, 3, or higher.
+void QuickSortGPT(struct GPTPartition* partitions, int start, int finish) {
+ uint64_t starterValue; // starting location of median partition
+ int left, right;
+ struct GPTPartition temp;
+
+ left = start;
+ right = finish;
+ starterValue = partitions[(start + finish) / 2].firstLBA;
+ do {
+ while (partitions[left].firstLBA < starterValue)
+ left++;
+ while (partitions[right].firstLBA > starterValue)
+ right--;
+ if (left <= right) {
+ temp = partitions[left];
+ partitions[left] = partitions[right];
+ partitions[right] = temp;
+ left++;
+ right--;
+ } // if
+ } while (left <= right);
+ if (start < right) QuickSortGPT(partitions, start, right);
+ if (finish > left) QuickSortGPT(partitions, left, finish);
+} // QuickSortGPT()
+
+// Blank (delete) a single partition
+void BlankPartition(struct GPTPartition* partition) {
+ int j;
+
+ partition->uniqueGUID.data1 = 0;
+ partition->uniqueGUID.data2 = 0;
+ partition->partitionType.data1 = 0;
+ partition->partitionType.data2 = 0;
+ partition->firstLBA = 0;
+ partition->lastLBA = 0;
+ partition->attributes = 0;
+ for (j = 0; j < NAME_SIZE; j++)
+ partition->name[j] = '\0';
+} // BlankPartition
+
+// Blank the partition array
+void GPTData::BlankPartitions(void) {
+ uint32_t i;
+
+ for (i = 0; i < mainHeader.numParts; i++) {
+ BlankPartition(&partitions[i]);
+ } // for
+} // GPTData::BlankPartitions()
+
+// Set up data structures for entirely new set of partitions on the
+// specified device. Returns 1 if OK, 0 if there were problems.
+int GPTData::ClearGPTData(void) {
+ int goOn, i;
+
+ // Set up the partition table....
+ free(partitions);
+ partitions = NULL;
+ SetGPTSize(NUM_GPT_ENTRIES);
+
+ // Now initialize a bunch of stuff that's static....
+ mainHeader.signature = GPT_SIGNATURE;
+ mainHeader.revision = 0x00010000;
+ mainHeader.headerSize = (uint32_t) HEADER_SIZE;
+ mainHeader.reserved = 0;
+ mainHeader.currentLBA = UINT64_C(1);
+ mainHeader.partitionEntriesLBA = (uint64_t) 2;
+ mainHeader.sizeOfPartitionEntries = GPT_SIZE;
+ for (i = 0; i < GPT_RESERVED; i++) {
+ mainHeader.reserved2[i] = '\0';
+ } // for
+
+ // Now some semi-static items (computed based on end of disk)
+ mainHeader.backupLBA = diskSize - UINT64_C(1);
+ mainHeader.lastUsableLBA = diskSize - mainHeader.firstUsableLBA;
+
+ // Set a unique GUID for the disk, based on random numbers
+ // rand() is only 32 bits, so multiply together to fill a 64-bit value
+ mainHeader.diskGUID.data1 = (uint64_t) rand() * (uint64_t) rand();
+ mainHeader.diskGUID.data2 = (uint64_t) rand() * (uint64_t) rand();
+
+ // Copy main header to backup header
+ RebuildSecondHeader();
+
+ // Blank out the partitions array....
+ BlankPartitions();
+ return (goOn);
+} // GPTData::ClearGPTData()
+
+// Returns 1 if the two partitions overlap, 0 if they don't
+int TheyOverlap(struct GPTPartition* first, struct GPTPartition* second) {
+ int theyDo = 0;
+
+ // Don't bother checking unless these are defined (both start and end points
+ // are 0 for undefined partitions, so just check the start points)
+ if ((first->firstLBA != 0) && (second->firstLBA != 0)) {
+ if ((first->firstLBA < second->lastLBA) && (first->lastLBA >= second->firstLBA))
+ theyDo = 1;
+ if ((second->firstLBA < first->lastLBA) && (second->lastLBA >= first->firstLBA))
+ theyDo = 1;
+ } // if
+ return (theyDo);
+} // Overlap()
+
+// Change the type code on the specified partition.
+// Note: The GPT CRCs must be recomputed after calling this function!
+void ChangeGPTType(struct GPTPartition* part) {
+ char typeName[255], line[255];
+ uint16_t typeNum = 0xFFFF;
+ PartTypes typeHelper;
+ GUIDData newType;
+
+ printf("Current type is '%s'\n", typeHelper.GUIDToName(part->partitionType, typeName));
+ while ((!typeHelper.Valid(typeNum)) && (typeNum != 0)) {
+ printf("Hex code (L to show codes, 0 to enter raw code): ");
+ fgets(line, 255, stdin);
+ sscanf(line, "%x", &typeNum);
+ if (line[0] == 'L')
+ typeHelper.ShowTypes();
+ } // while
+ if (typeNum != 0) // user entered a code, so convert it
+ newType = typeHelper.IDToGUID(typeNum);
+ else // user wants to enter the GUID directly, so do that
+ newType = GetGUID();
+ part->partitionType = newType;
+ printf("Changed system type of partition to '%s'\n",
+ typeHelper.GUIDToName(part->partitionType, typeName));
+} // ChangeGPTType()
+
+// Prompt user for a partition number, then change its type code
+// using ChangeGPTType(struct GPTPartition*) function.
+void GPTData::ChangePartType(void) {
+ int partNum;
+ uint32_t low, high;
+
+ if (GetPartRange(&low, &high) > 0) {
+ partNum = GetPartNum();
+ ChangeGPTType(&partitions[partNum]);
+ } else {
+ printf("No partitions\n");
+ } // if/else
+} // GPTData::ChangePartType()
+
+// Prompts user for partition number and returns the result.
+uint32_t GPTData::GetPartNum(void) {
+ uint32_t partNum;
+ uint32_t low, high;
+ char prompt[255];
+
+ if (GetPartRange(&low, &high) > 0) {
+ sprintf(prompt, "Partition number (%d-%d): ", low + 1, high + 1);
+ partNum = GetNumber(low + 1, high + 1, low, prompt);
+ } else partNum = 1;
+ return (partNum - 1);
+} // GPTData::GetPartNum()
+
+// Prompt user for attributes to change on the specified partition
+// and change them.
+void GPTData::SetAttributes(uint32_t partNum) {
+ Attributes theAttr;
+
+ theAttr.SetAttributes(partitions[partNum].attributes);
+ theAttr.DisplayAttributes();
+ theAttr.ChangeAttributes();
+ partitions[partNum].attributes = theAttr.GetAttributes();
+} // GPTData::SetAttributes()
+
+// Set the name for a partition to theName, or prompt for a name if
+// theName is a NULL pointer. Note that theName is a standard C-style
+// string, although the GUID partition definition requires a UTF-16LE
+// string. This function creates a simple-minded copy for this.
+void GPTData::SetName(uint32_t partNum, char* theName) {
+ char newName[NAME_SIZE]; // New name
+ int i;
+
+ // Blank out new name string, just to be on the safe side....
+ for (i = 0; i < NAME_SIZE; i++)
+ newName[i] = '\0';
+
+ if (theName == NULL) { // No name specified, so get one from the user
+ printf("Enter name: ");
+ fgets(newName, NAME_SIZE / 2, stdin);
+
+ // Input is likely to include a newline, so remove it....
+ i = strlen(newName);
+ if (newName[i - 1] == '\n')
+ newName[i - 1] = '\0';
+ } else {
+ strcpy(newName, theName);
+ } // if
+
+ // Copy the C-style ASCII string from newName into a form that the GPT
+ // table will accept....
+ for (i = 0; i < NAME_SIZE; i++) {
+ if ((i % 2) == 0) {
+ partitions[partNum].name[i] = newName[(i / 2)];
+ } else {
+ partitions[partNum].name[i] = '\0';
+ } // if/else
+ } // for
+} // GPTData::SetName()
+
+// Set the disk GUID to the specified value. Note that the header CRCs must
+// be recomputed after calling this function.
+void GPTData::SetDiskGUID(GUIDData newGUID) {
+ mainHeader.diskGUID = newGUID;
+ secondHeader.diskGUID = newGUID;
+} // SetDiskGUID()
+
+// Set the unique GUID of the specified partition. Returns 1 on
+// successful completion, 0 if there were problems (invalid
+// partition number).
+int GPTData::SetPartitionGUID(uint32_t pn, GUIDData theGUID) {
+ int retval = 0;
+
+ if (pn < mainHeader.numParts) {
+ if (partitions[pn].firstLBA != UINT64_C(0)) {
+ partitions[pn].uniqueGUID = theGUID;
+ retval = 1;
+ } // if
+ } // if
+ return retval;
+} // GPTData::SetPartitionGUID()
+
+// Check the validity of the GPT header. Returns 1 if the main header
+// is valid, 2 if the backup header is valid, 3 if both are valid, and
+// 0 if neither is valid. Note that this function just checks the GPT
+// signature and revision numbers, not CRCs or other data.
+int GPTData::CheckHeaderValidity(void) {
+ int valid = 3;
+
+ if (mainHeader.signature != GPT_SIGNATURE) {
+ valid -= 1;
+ printf("Main GPT signature invalid; read 0x%016llX, should be\n0x%016llX\n",
+ (unsigned long long) mainHeader.signature, (unsigned long long) GPT_SIGNATURE);
+ } else if ((mainHeader.revision != 0x00010000) && valid) {
+ valid -= 1;
+ printf("Unsupported GPT version in main header; read 0x%08lX, should be\n0x%08lX\n",
+ (unsigned long) mainHeader.revision, UINT32_C(0x00010000));
+ } // if/else/if
+
+ if (secondHeader.signature != GPT_SIGNATURE) {
+ valid -= 2;
+ printf("Secondary GPT signature invalid; read 0x%016llX, should be\n0x%016llX\n",
+ (unsigned long long) secondHeader.signature, (unsigned long long) GPT_SIGNATURE);
+ } else if ((secondHeader.revision != 0x00010000) && valid) {
+ valid -= 2;
+ printf("Unsupported GPT version in backup header; read 0x%08lX, should be\n0x%08lX\n",
+ (unsigned long) mainHeader.revision, UINT32_C(0x00010000));
+ } // if/else/if
+
+ return valid;
+} // GPTData::CheckHeaderValidity()
+
+// Check the header CRC to see if it's OK...
+int GPTData::CheckHeaderCRC(struct GPTHeader* header) {
+ uint32_t oldCRC, newCRC;
+
+ // Back up old header and then blank it, since it must be 0 for
+ // computation to be valid
+ oldCRC = header->headerCRC;
+ header->headerCRC = UINT32_C(0);
+
+ // Initialize CRC functions...
+ chksum_crc32gentab();
+
+ // Compute CRC, restore original, and return result of comparison
+ newCRC = chksum_crc32((unsigned char*) header, HEADER_SIZE);
+ mainHeader.headerCRC = oldCRC;
+ return (oldCRC == newCRC);
+} // GPTData::CheckHeaderCRC()
+
+// Recompute all the CRCs. Must be called before saving if any changes
+// have been made.
+void GPTData::RecomputeCRCs(void) {
+ uint32_t crc;
+
+ // Initialize CRC functions...
+ chksum_crc32gentab();
+
+ // Compute CRC of partition tables & store in main and secondary headers
+ crc = chksum_crc32((unsigned char*) partitions, mainHeader.numParts * GPT_SIZE);
+ mainHeader.partitionEntriesCRC = crc;
+ secondHeader.partitionEntriesCRC = crc;
+
+ // Zero out GPT tables' own CRCs (required for correct computation)
+ mainHeader.headerCRC = 0;
+ secondHeader.headerCRC = 0;
+
+ // Compute & store CRCs of main & secondary headers...
+ crc = chksum_crc32((unsigned char*) &mainHeader, HEADER_SIZE);
+ mainHeader.headerCRC = crc;
+ crc = chksum_crc32((unsigned char*) &secondHeader, HEADER_SIZE);
+ secondHeader.headerCRC = crc;
+} // GPTData::RecomputeCRCs()
+
+// Perform detailed verification, reporting on any problems found, but
+// do *NOT* recover from these problems. Returns the total number of
+// problems identified.
+int GPTData::Verify(void) {
+ int problems = 0, numSegments, i, j;
+ uint64_t totalFree, largestSegment;
+ char tempStr[255], siTotal[255], siLargest[255];
+
+ // First, check for CRC errors in the GPT data....
+ if (!mainCrcOk) {
+ problems++;
+ printf("\nProblem: The CRC for the main GPT header is invalid. The main GPT header may\n"
+ "be corrupt. Consider loading the backup GPT header to rebuild the main GPT\n"
+ "header\n");
+ } // if
+ if (!mainPartsCrcOk) {
+ problems++;
+ printf("\nProblem: The CRC for the main partition table is invalid. This table may be\n"
+ "corrupt. Consider loading the backup partition table.\n");
+ } // if
+ if (!secondCrcOk) {
+ problems++;
+ printf("\nProblem: The CRC for the backup GPT header is invalid. The backup GPT header\n"
+ "may be corrupt. Consider using the main GPT header to rebuild the backup GPT\n"
+ "header.\n");
+ } // if
+ if (!secondPartsCrcOk) {
+ problems++;
+ printf("\nCaution: The CRC for the backup partition table is invalid. This table may\n"
+ "be corrupt. This program will automatically create a new backup partition\n"
+ "table when you save your partitions.\n");
+ } // if
+
+ // Now check that critical main and backup GPT entries match
+ if (mainHeader.currentLBA != secondHeader.backupLBA) {
+ problems++;
+ printf("\nProblem: main GPT header's current LBA pointer (%llu) doesn't\n"
+ "match the backup GPT header's LBA pointer(%llu)\n",
+ (unsigned long long) mainHeader.currentLBA,
+ (unsigned long long) secondHeader.backupLBA);
+ } // if
+ if (mainHeader.backupLBA != secondHeader.currentLBA) {
+ problems++;
+ printf("\nProblem: main GPT header's backup LBA pointer (%llu) doesn't\n"
+ "match the backup GPT header's current LBA pointer (%llu)\n",
+ (unsigned long long) mainHeader.backupLBA,
+ (unsigned long long) secondHeader.currentLBA);
+ } // if
+ if (mainHeader.firstUsableLBA != secondHeader.firstUsableLBA) {
+ problems++;
+ printf("\nProblem: main GPT header's first usable LBA pointer (%llu) doesn't\n"
+ "match the backup GPT header's first usable LBA pointer (%llu)\n",
+ (unsigned long long) mainHeader.firstUsableLBA,
+ (unsigned long long) secondHeader.firstUsableLBA);
+ } // if
+ if (mainHeader.lastUsableLBA != secondHeader.lastUsableLBA) {
+ problems++;
+ printf("\nProblem: main GPT header's last usable LBA pointer (%llu) doesn't\n"
+ "match the backup GPT header's last usable LBA pointer (%llu)\n",
+ (unsigned long long) mainHeader.lastUsableLBA,
+ (unsigned long long) secondHeader.lastUsableLBA);
+ } // if
+ if ((mainHeader.diskGUID.data1 != secondHeader.diskGUID.data1) ||
+ (mainHeader.diskGUID.data2 != secondHeader.diskGUID.data2)) {
+ problems++;
+ printf("\nProblem: main header's disk GUID (%s) doesn't\n",
+ GUIDToStr(mainHeader.diskGUID, tempStr));
+ printf("match the backup GPT header's disk GUID (%s)\n",
+ GUIDToStr(secondHeader.diskGUID, tempStr));
+ } // if
+ if (mainHeader.numParts != secondHeader.numParts) {
+ problems++;
+ printf("\nProblem: main GPT header's number of partitions (%lu) doesn't\n"
+ "match the backup GPT header's number of partitions (%lu)\n",
+ (unsigned long) mainHeader.numParts,
+ (unsigned long) secondHeader.numParts);
+ } // if
+ if (mainHeader.sizeOfPartitionEntries != secondHeader.sizeOfPartitionEntries) {
+ problems++;
+ printf("\nProblem: main GPT header's size of partition entries (%lu) doesn't\n"
+ "match the backup GPT header's size of partition entries (%lu)\n",
+ (unsigned long) mainHeader.sizeOfPartitionEntries,
+ (unsigned long) secondHeader.sizeOfPartitionEntries);
+ } // if
+
+ // Now check for a few other miscellaneous problems...
+ // Check that the disk size will hold the data...
+ if (mainHeader.backupLBA > diskSize) {
+ problems++;
+ printf("\nProblem: Disk is too small to hold all the data!\n");
+ printf("(Disk size is %llu sectors, needs to be %llu sectors.)\n",
+ (unsigned long long) diskSize,
+ (unsigned long long) mainHeader.backupLBA);
+ } // if
+
+ // Check for overlapping partitions....
+ for (i = 1; i < mainHeader.numParts; i++) {
+ for (j = 0; j < i; j++) {
+ if (TheyOverlap(&partitions[i], &partitions[j])) {
+ problems++;
+ printf("\nProblem: partitions %d and %d overlap:\n", i + 1, j + 1);
+ printf(" Partition %d: %llu to %llu\n", i,
+ (unsigned long long) partitions[i].firstLBA,
+ (unsigned long long) partitions[i].lastLBA);
+ printf(" Partition %d: %llu to %llu\n", j,
+ (unsigned long long) partitions[j].firstLBA,
+ (unsigned long long) partitions[j].lastLBA);
+ } // if
+ } // for j...
+ } // for i...
+
+ // Now compute available space, but only if no problems found, since
+ // problems could affect the results
+ if (problems == 0) {
+ totalFree = FindFreeBlocks(&numSegments, &largestSegment);
+ BytesToSI(totalFree * (uint64_t) blockSize, siTotal);
+ BytesToSI(largestSegment * (uint64_t) blockSize, siLargest);
+ printf("No problems found. %llu free sectors (%s) available in %u\n"
+ "segments, the largest of which is %llu sectors (%s) in size\n",
+ (unsigned long long) totalFree,
+ siTotal, numSegments, (unsigned long long) largestSegment,
+ siLargest);
+ } else {
+ printf("\nIdentified %d problems!\n", problems);
+ } // if/else
+
+ return (problems);
+} // GPTData::Verify()
+
+// Rebuild the main GPT header, using the secondary header as a model.
+// Typically called when the main header has been found to be corrupt.
+void GPTData::RebuildMainHeader(void) {
+ int i;
+
+ mainHeader.signature = GPT_SIGNATURE;
+ mainHeader.revision = secondHeader.revision;
+ mainHeader.headerSize = HEADER_SIZE;
+ mainHeader.headerCRC = UINT32_C(0);
+ mainHeader.reserved = secondHeader.reserved;
+ mainHeader.currentLBA = secondHeader.backupLBA;
+ mainHeader.backupLBA = secondHeader.currentLBA;
+ mainHeader.firstUsableLBA = secondHeader.firstUsableLBA;
+ mainHeader.lastUsableLBA = secondHeader.lastUsableLBA;
+ mainHeader.diskGUID.data1 = secondHeader.diskGUID.data1;
+ mainHeader.diskGUID.data2 = secondHeader.diskGUID.data2;
+ mainHeader.partitionEntriesLBA = UINT64_C(2);
+ mainHeader.numParts = secondHeader.numParts;
+ mainHeader.sizeOfPartitionEntries = secondHeader.sizeOfPartitionEntries;
+ mainHeader.partitionEntriesCRC = secondHeader.partitionEntriesCRC;
+ for (i = 0 ; i < GPT_RESERVED; i++)
+ mainHeader.reserved2[i] = secondHeader.reserved2[i];
+} // GPTData::RebuildMainHeader()
+
+// Rebuild the secondary GPT header, using the main header as a model.
+void GPTData::RebuildSecondHeader(void) {
+ int i;
+
+ secondHeader.signature = GPT_SIGNATURE;
+ secondHeader.revision = mainHeader.revision;
+ secondHeader.headerSize = HEADER_SIZE;
+ secondHeader.headerCRC = UINT32_C(0);
+ secondHeader.reserved = mainHeader.reserved;
+ secondHeader.currentLBA = mainHeader.backupLBA;
+ secondHeader.backupLBA = mainHeader.currentLBA;
+ secondHeader.firstUsableLBA = mainHeader.firstUsableLBA;
+ secondHeader.lastUsableLBA = mainHeader.lastUsableLBA;
+ secondHeader.diskGUID.data1 = mainHeader.diskGUID.data1;
+ secondHeader.diskGUID.data2 = mainHeader.diskGUID.data2;
+ secondHeader.partitionEntriesLBA = secondHeader.lastUsableLBA + UINT64_C(1);
+ secondHeader.numParts = mainHeader.numParts;
+ secondHeader.sizeOfPartitionEntries = mainHeader.sizeOfPartitionEntries;
+ secondHeader.partitionEntriesCRC = mainHeader.partitionEntriesCRC;
+ for (i = 0 ; i < GPT_RESERVED; i++)
+ secondHeader.reserved2[i] = mainHeader.reserved2[i];
+} // RebuildSecondHeader()
+
+// Load the second (backup) partition table as the primary partition
+// table. Used in repair functions
+void GPTData::LoadSecondTableAsMain(void) {
+ int fd;
+ off_t seekTo;
+ uint32_t sizeOfParts, newCRC;
+
+ if ((fd = open(device, O_RDONLY)) != -1) {
+ seekTo = secondHeader.partitionEntriesLBA * (off_t) blockSize;
+ if (lseek64(fd, seekTo, SEEK_SET) != (off_t) -1) {
+ SetGPTSize(secondHeader.numParts);
+ sizeOfParts = secondHeader.numParts * secondHeader.sizeOfPartitionEntries;
+ read(fd, partitions, sizeOfParts);
+ newCRC = chksum_crc32((unsigned char*) partitions, sizeOfParts);
+ secondPartsCrcOk = (newCRC == secondHeader.partitionEntriesCRC);
+ mainPartsCrcOk = secondPartsCrcOk;
+ if (!secondPartsCrcOk) {
+ printf("Error! After loading backup partitions, the CRC still doesn't check out!\n");
+ } // if
+ } else {
+ printf("Error! Couldn't seek to backup partition table!\n");
+ } // if/else
+ } else {
+ printf("Error! Couldn't open device %s when recovering backup partition table!\n");
+ } // if/else
+} // GPTData::LoadSecondTableAsMain()
+
+// Finds the total number of free blocks, the number of segments in which
+// they reside, and the size of the largest of those segments
+uint64_t GPTData::FindFreeBlocks(int *numSegments, uint64_t *largestSegment) {
+ uint64_t start = UINT64_C(0); // starting point for each search
+ uint64_t totalFound = UINT64_C(0); // running total
+ uint64_t firstBlock; // first block in a segment
+ uint64_t lastBlock; // last block in a segment
+ uint64_t segmentSize; // size of segment in blocks
+ int num = 0;
+
+ *largestSegment = UINT64_C(0);
+ do {
+ firstBlock = FindFirstAvailable(start);
+ if (firstBlock != UINT64_C(0)) { // something's free...
+ lastBlock = FindLastInFree(firstBlock);
+ segmentSize = lastBlock - firstBlock + UINT64_C(1);
+ if (segmentSize > *largestSegment) {
+ *largestSegment = segmentSize;
+ } // if
+ totalFound += segmentSize;
+ num++;
+ start = lastBlock + 1;
+ } // if
+ } while (firstBlock != 0);
+ *numSegments = num;
+ return totalFound;
+} // GPTData::FindFreeBlocks()
+
+/*
+// Create a hybrid MBR -- an ugly, funky thing that helps GPT work with
+// OSes that don't understand GPT.
+void GPTData::MakeHybrid(void) {
+ uint32_t partNums[3];
+ char line[255];
+ int numParts, i, j, typeCode, bootable;
+ uint64_t length;
+
+ // First, rebuild the protective MBR...
+ protectiveMBR.MakeProtectiveMBR();
+
+ // Now get the numbers of up to three partitions to add to the
+ // hybrid MBR....
+ printf("Type from one to three partition numbers to be added to the hybrid MBR, in\n"
+ "sequence: ");
+ fgets(line, 255, stdin);
+ numParts = sscanf(line, "%d %d %d", &partNums[0], &partNums[1], &partNums[2]);
+ for (i = 0; i < numParts; i++) {
+ j = partNums[i] - 1;
+ printf("Creating entry for partition #%d\n", j + 1);
+ if ((j >= 0) && (j < mainHeader.numParts)) {
+ if (partitions[j].lastLBA < UINT32_MAX) {
+ printf("Enter an MBR hex code (suggested %02X): ",
+ typeHelper.GUIDToID(partitions[j].partitionType) / 256);
+ fgets(line, 255, stdin);
+ sscanf(line, "%x", &typeCode);
+ printf("Set the bootable flag? ");
+ bootable = (GetYN() == 'Y');
+ length = partitions[j].lastLBA - partitions[j].firstLBA + UINT64_C(1);
+ protectiveMBR.MakePart(i + 1, (uint32_t) partitions[j].firstLBA,
+ (uint32_t) length, typeCode, bootable);
+ } else { // partition out of range
+ printf("Partition %d ends beyond the 2TiB limit of MBR partitions; omitting it.\n",
+ j + 1);
+ } // if/else
+ } else {
+ printf("Partition %d is out of range; omitting it.\n", j + 1);
+ } // if/else
+ } // for
+} // GPTData::MakeHybrid()
+*/
+
+// Writes GPT (and protective MBR) to disk. Returns 1 on successful
+// write, 0 if there was a problem.
+int GPTData::SaveGPTData(void) {
+ int allOK = 1, i, j;
+ char answer, line[256];
+ int fd;
+ uint64_t secondTable;
+ off_t offset;
+
+ if (strlen(device) == 0) {
+ printf("Device not defined.\n");
+ } // if
+
+ // First do some final sanity checks....
+ // Is there enough space to hold the GPT headers and partition tables,
+ // given the partition sizes?
+ if (CheckGPTSize() == 0) {
+ allOK = 0;
+ } // if
+
+ // Check that disk is really big enough to handle this...
+ if (mainHeader.backupLBA > diskSize) {
+ fprintf(stderr, "Error! Disk is too small -- either the original MBR is corrupt or you're\n");
+ fprintf(stderr, "working from an MBR copied to a file! Aborting!\n");
+ printf("(Disk size is %ld sectors, needs to be %ld sectors.)\n", diskSize,
+ mainHeader.backupLBA);
+ allOK = 0;
+ } // if
+
+ // Check for overlapping partitions....
+ for (i = 1; i < mainHeader.numParts; i++) {
+ for (j = 0; j < i; j++) {
+ if (TheyOverlap(&partitions[i], &partitions[j])) {
+ fprintf(stderr, "\Error: partitions %d and %d overlap:\n", i + 1, j + 1);
+ fprintf(stderr, " Partition %d: %llu to %llu\n", i,
+ (unsigned long long) partitions[i].firstLBA,
+ (unsigned long long) partitions[i].lastLBA);
+ fprintf(stderr, " Partition %d: %llu to %llu\n", j,
+ (unsigned long long) partitions[j].firstLBA,
+ (unsigned long long) partitions[j].lastLBA);
+ fprintf(stderr, "Aborting write operation!\n");
+ allOK = 0;
+ } // if
+ } // for j...
+ } // for i...
+
+ RecomputeCRCs();
+
+ if (allOK) {
+ printf("\nFinal checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING\n");
+ printf("MBR PARTITIONS!! THIS PROGRAM IS BETA QUALITY AT BEST. IF YOU LOSE ALL YOUR\n");
+ printf("DATA, YOU HAVE ONLY YOURSELF TO BLAME IF YOU ANSWER 'Y' BELOW!\n\n");
+ printf("Do you want to proceed, possibly destroying your data? (Y/N) ");
+ fgets(line, 255, stdin);
+ sscanf(line, "%c", &answer);
+ if ((answer == 'Y') || (answer == 'y')) {
+ printf("OK; writing new GPT partition table.\n");
+ } else {
+ allOK = 0;
+ } // if/else
+ } // if
+
+ // Do it!
+ if (allOK) {
+ fd = open(device, O_WRONLY); // try to open the device; may fail....
+#ifdef __APPLE__
+ // MacOS X requires a shared lock under some circumstances....
+ if (fd < 0) {
+ fd = open(device, O_WRONLY|O_SHLOCK);
+ } // if
+#endif
+ if (fd != -1) {
+ // First, write the protective MBR...
+ protectiveMBR.WriteMBRData(fd);
+
+ // Now write the main GPT header...
+ if (allOK)
+ if (write(fd, &mainHeader, 512) == -1)
+ allOK = 0;
+
+ // Now write the main partition tables...
+ if (allOK) {
+ if (write(fd, partitions, GPT_SIZE * mainHeader.numParts) == -1)
+ allOK = 0;
+ } // if
+
+ // Now seek to near the end to write the secondary GPT....
+ if (allOK) {
+ secondTable = secondHeader.partitionEntriesLBA;
+ offset = (off_t) secondTable * (off_t) (blockSize);
+ if (lseek64(fd, offset, SEEK_SET) == (off_t) - 1) {
+ allOK = 0;
+ printf("Unable to seek to end of disk!\n");
+ } // if
+ } // if
+
+ // Now write the secondary partition tables....
+ if (allOK)
+ if (write(fd, partitions, GPT_SIZE * mainHeader.numParts) == -1)
+ allOK = 0;
+
+ // Now write the secondary GPT header...
+ if (allOK)
+ if (write(fd, &secondHeader, 512) == -1)
+ allOK = 0;
+
+ // re-read the partition table
+ if (allOK) {
+ sync();
+#ifdef __APPLE__
+ printf("Warning: The kernel may continue to use old or deleted partitions.\n"
+ "You should reboot or remove the drive.\n");
+ /* don't know if this helps
+ * it definitely will get things on disk though:
+ * http://topiks.org/mac-os-x/0321278542/ch12lev1sec8.html */
+ i = ioctl(fd, DKIOCSYNCHRONIZECACHE);
+#else
+ sleep(2);
+ i = ioctl(fd, BLKRRPART);
+ if (i)
+ printf("Warning: The kernel is still using the old partition table.\n"
+ "The new table will be used at the next reboot.\n");
+#endif
+ } // if
+
+ if (allOK) { // writes completed OK
+ printf("The operation has completed successfully.\n");
+ } else {
+ printf("Warning! An error was reported when writing the partition table! This error\n");
+ printf("MIGHT be harmless, but you may have trashed the disk! Use parted and, if\n");
+ printf("necessary, restore your original partition table.\n");
+ } // if/else
+ close(fd);
+ } else {
+ fprintf(stderr, "Unable to open device %s for writing! Errno is %d! Aborting!\n", device, errno);
+ allOK = 0;
+ } // if/else
+ } else {
+ printf("Aborting write of new partition table.\n");
+ } // if
+
+ return (allOK);
+} // GPTData::SaveGPTData()
+
+// Save GPT data to a backup file. This function does much less error
+// checking than SaveGPTData(). It can therefore preserve many types of
+// corruption for later analysis; however, it preserves only the MBR,
+// the main GPT header, the backup GPT header, and the main partition
+// table; it discards the backup partition table, since it should be
+// identical to the main partition table on healthy disks.
+int GPTData::SaveGPTBackup(char* filename) {
+ int fd, allOK = 1;;
+
+ if ((fd = open(filename, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH)) != -1) {
+ // First, write the protective MBR...
+ protectiveMBR.WriteMBRData(fd);
+
+ // Now write the main GPT header...
+ if (allOK)
+ if (write(fd, &mainHeader, 512) == -1)
+ allOK = 0;
+
+ // Now write the secondary GPT header...
+ if (allOK)
+ if (write(fd, &secondHeader, 512) == -1)
+ allOK = 0;
+
+ // Now write the main partition tables...
+ if (allOK) {
+ if (write(fd, partitions, GPT_SIZE * mainHeader.numParts) == -1)
+ allOK = 0;
+ } // if
+
+ if (allOK) { // writes completed OK
+ printf("The operation has completed successfully.\n");
+ } else {
+ printf("Warning! An error was reported when writing the backup file.\n");
+ printf("It may not be useable!\n");
+ } // if/else
+ close(fd);
+ } else {
+ fprintf(stderr, "Unable to open file %s for writing! Aborting!\n", filename);
+ allOK = 0;
+ } // if/else
+ return allOK;
+} // GPTData::SaveGPTBackup()
+
+// Load GPT data from a backup file created by SaveGPTBackup(). This function
+// does minimal error checking. It returns 1 if it completed successfully,
+// 0 if there was a problem. In the latter case, it creates a new empty
+// set of partitions.
+int GPTData::LoadGPTBackup(char* filename) {
+ int fd, allOK = 1, val;
+ uint32_t numParts, sizeOfEntries, sizeOfParts, newCRC;
+
+ if ((fd = open(filename, O_RDONLY)) != -1) {
+ // Let the MBRData class load the saved MBR...
+ protectiveMBR.ReadMBRData(fd);
+
+ // Load the main GPT header, check its vaility, and set the GPT
+ // size based on the data
+ read(fd, &mainHeader, 512);
+ mainCrcOk = CheckHeaderCRC(&mainHeader);
+
+ // Load the backup GPT header in much the same way as the main
+ // GPT header....
+ read(fd, &secondHeader, 512);
+ secondCrcOk = CheckHeaderCRC(&secondHeader);
+
+ // Return valid headers code: 0 = both headers bad; 1 = main header
+ // good, backup bad; 2 = backup header good, main header bad;
+ // 3 = both headers good. Note these codes refer to valid GPT
+ // signatures and version numbers; more subtle problems will elude
+ // this check!
+ if ((val = CheckHeaderValidity()) > 0) {
+ if (val == 2) { // only backup header seems to be good
+ numParts = secondHeader.numParts;
+ sizeOfEntries = secondHeader.sizeOfPartitionEntries;
+ } else { // main header is OK
+ numParts = mainHeader.numParts;
+ sizeOfEntries = mainHeader.sizeOfPartitionEntries;
+ } // if/else
+
+ SetGPTSize(numParts);
+
+ // If current disk size doesn't match that of backup....
+ if (secondHeader.currentLBA != diskSize - UINT64_C(1)) {
+ printf("Warning! Current disk size doesn't match that of the backup!\n"
+ "Adjusting sizes to match, but subsequent problems are possible!\n");
+ secondHeader.currentLBA = mainHeader.backupLBA = diskSize - UINT64_C(1);
+ mainHeader.lastUsableLBA = diskSize - mainHeader.firstUsableLBA;
+ secondHeader.lastUsableLBA = mainHeader.lastUsableLBA;
+ secondHeader.partitionEntriesLBA = secondHeader.lastUsableLBA + UINT64_C(1);
+ } // if
+
+ // Load main partition table, and record whether its CRC
+ // matches the stored value
+ sizeOfParts = numParts * sizeOfEntries;
+ read(fd, partitions, sizeOfParts);
+
+ newCRC = chksum_crc32((unsigned char*) partitions, sizeOfParts);
+ mainPartsCrcOk = (newCRC == mainHeader.partitionEntriesCRC);
+ secondPartsCrcOk = (newCRC == secondHeader.partitionEntriesCRC);
+ } else {
+ allOK = 0;
+ } // if/else
+ } else {
+ allOK = 0;
+ fprintf(stderr, "Unable to open file %s for reading! Aborting!\n", filename);
+ } // if/else
+
+ // Something went badly wrong, so blank out partitions
+ if (allOK == 0) {
+ ClearGPTData();
+ protectiveMBR.MakeProtectiveMBR();
+ } // if
+ return allOK;
+} // GPTData::LoadGPTBackup()
+
+// Check to be sure that data type sizes are correct. The basic types (uint*_t) should
+// never fail these tests, but the struct types may fail depending on compile options.
+// Specifically, the -fpack-struct option to gcc may be required to ensure proper structure
+// sizes.
+int SizesOK(void) {
+ int allOK = 1;
+ union {
+ uint32_t num;
+ unsigned char uc[sizeof(uint32_t)];
+ } endian;
+
+ if (sizeof(uint8_t) != 1) {
+ fprintf(stderr, "uint8_t is %d bytes, should be 1 byte; aborting!\n", sizeof(uint8_t));
+ allOK = 0;
+ } // if
+ if (sizeof(uint16_t) != 2) {
+ fprintf(stderr, "uint16_t is %d bytes, should be 2 bytes; aborting!\n", sizeof(uint16_t));
+ allOK = 0;
+ } // if
+ if (sizeof(uint32_t) != 4) {
+ fprintf(stderr, "uint32_t is %d bytes, should be 4 bytes; aborting!\n", sizeof(uint32_t));
+ allOK = 0;
+ } // if
+ if (sizeof(uint64_t) != 8) {
+ fprintf(stderr, "uint64_t is %d bytes, should be 8 bytes; aborting!\n", sizeof(uint64_t));
+ allOK = 0;
+ } // if
+ if (sizeof(struct MBRRecord) != 16) {
+ fprintf(stderr, "MBRRecord is %d bytes, should be 16 bytes; aborting!\n", sizeof(uint32_t));
+ allOK = 0;
+ } // if
+ if (sizeof(struct EBRRecord) != 512) {
+ fprintf(stderr, "EBRRecord is %d bytes, should be 512 bytes; aborting!\n", sizeof(uint32_t));
+ allOK = 0;
+ } // if
+ if (sizeof(struct GPTHeader) != 512) {
+ fprintf(stderr, "GPTHeader is %d bytes, should be 512 bytes; aborting!\n", sizeof(uint32_t));
+ allOK = 0;
+ } // if
+ // Determine endianness; set allOK = 0 if running on big-endian hardware
+ endian.num = 1;
+ if (endian.uc[0] != (unsigned char) 1) {
+ fprintf(stderr, "Running on big-endian hardware, but this program only works on little-endian\n"
+ "systems; aborting!\n");
+ allOK = 0;
+ } // if
+ return (allOK);
+} // SizesOK()
+