Added files for 0.7.0
diff --git a/gptpartnotes.cc b/gptpartnotes.cc
deleted file mode 100644
index 2465385..0000000
--- a/gptpartnotes.cc
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- partnotes.cc -- Class that takes notes on GPT partitions for purpose of MBR conversion
- Copyright (C) 2010 Roderick W. Smith
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-*/
-
-#include <iostream>
-#include <stdio.h>
-#include "gptpartnotes.h"
-#include "gpt.h"
-
-using namespace std;
-
-GptPartNotes::GptPartNotes() {
- gptParts = NULL;
-} // GptPartNotes constructor
-
-GptPartNotes::GptPartNotes(GPTPart *parts, GPTData *gpt, int num, int s) {
- gptParts = NULL;
- PassPartitions(parts, gpt, num, s);
-} // GptPartNotes constructor passing partition information
-
-/* // Destructor. Note that we do NOT delete the gptParts array, since we just
-// store a pointer to an array that's allocated by the calling function.
-GptPartNotes::~GptPartNotes() {
-} // PartNotes destructor */
-
-/*************************************************************************
- * *
- * Begin functions that add data to the notes, either by whole notes *
- * or in smaller units. By and large these functions perform little *
- * or no error checking on the added data, so they can create completely *
- * bogus layouts if used carelessly. *
- * *
- *************************************************************************/
-
-// Creates the notes linked list with as many entries as there are
-// in-use GPT partitions. Note that the parts array must be pre-sorted!
-// If not, this function will reject the partition table.
-// Returns the number of partitions -- normally identical to num,
-// unless there were problems, in which case it returns 0.
-int GptPartNotes::PassPartitions(GPTPart *parts, GPTData *gpt, int num, int s) {
- int i;
- struct PartInfo *tempNote = NULL, *lastNote = NULL;
-
- if ((parts != NULL) && (num > 0)) {
- blockSize = s;
- gptParts = parts;
- origTableSize = num;
- if (notes != NULL)
- DeleteNotes();
- for (i = 0; i < num; i++) {
- if (gptParts[i].IsUsed()){
- tempNote = new struct PartInfo;
- tempNote->next = NULL;
- tempNote->firstLBA = gptParts[i].GetFirstLBA();
- tempNote->lastLBA = gptParts[i].GetLastLBA();
- if (gpt->IsFree(gptParts[i].GetFirstLBA() - 1)) {
- tempNote->spaceBefore = 1;
- tempNote->type = LOGICAL;
- } else {
- tempNote->spaceBefore = 0;
- tempNote->type = PRIMARY;
- } // if/else
- tempNote->origPartNum = i;
- tempNote->active = 0;
- if (lastNote == NULL) {
- lastNote = tempNote;
- notes = tempNote;
- } else {
- lastNote->next = tempNote;
- lastNote = tempNote;
- } // if/else
- } // if GPT partition in use
- } // for
- if (!IsSorted()) {
- DeleteNotes();
- gptParts = NULL;
- origTableSize = 0;
- cerr << "The partition table must be sorted before calling GptPartNotes::PassPartitions()!\n";
- } // if
- } else {
- notes = NULL;
- gptParts = NULL;
- origTableSize = 0;
- } // if/else
- return origTableSize;
-} // GptPartNotes::PassPartitions
-
-/***************************************************************************
- * *
- * The following functions retrieve data, either in whole PartInfo units *
- * or in smaller chunks. Some functions perform computations and *
- * comparisons that may require traversing the entire linked list, perhaps *
- * multiple times. *
- * *
- ***************************************************************************/
-
-// Returns 1 if the GPT partition table is sorted, 0 if not (or if the
-// pointer is NULL)
-int GptPartNotes::IsSorted(void) {
- int i, sorted = 1;
- uint64_t lastStartLBA = 0;
-
- if (gptParts == NULL) {
- sorted = 0;
- } else {
- for (i = 0; i < origTableSize; i++) {
- if (lastStartLBA > gptParts[i].GetFirstLBA())
- sorted = 0;
- } // for
- } // if/else
- return sorted;
-} // GptPartNotes::IsSorted()
-
-/*************************************************************************
- * *
- * Interact with users, presenting data and/or collecting responses. May *
- * change data with error detection and correction. *
- * *
- *************************************************************************/
-
-// Display summary information for the user
-void GptPartNotes::ShowSummary(void) {
- size_t j;
- string sizeInSI;
- struct PartInfo *theNote;
-
- if ((gptParts != NULL) && (notes != NULL)) {
- theNote = notes;
- cout << "Sorted GPT partitions and their current conversion status:\n";
- cout << " Can Be\n";
- cout << "Number Boot Size Status Logical Code GPT Name\n";
- while (theNote != NULL) {
- if (gptParts[theNote->origPartNum].IsUsed()) {
- cout.fill(' ');
- cout.width(4);
- cout << theNote->origPartNum + 1 << " ";
- if (theNote->active)
- cout << " * ";
- else
- cout << " ";
- sizeInSI = BytesToSI((gptParts[theNote->origPartNum].GetLastLBA() -
- gptParts[theNote->origPartNum].GetFirstLBA() + 1), blockSize);
- cout << " " << sizeInSI;
- for (j = 0; j < 12 - sizeInSI.length(); j++)
- cout << " ";
- switch (theNote->type) {
- case PRIMARY:
- cout << "primary ";
- break;
- case LOGICAL:
- cout << "logical ";
- break;
- case WILL_NOT_CONVERT:
- cout << "OMITTED ";
- break;
- default:
- cout << "**ERROR** ";
- break;
- } // switch
- if (theNote->spaceBefore)
- cout << "Y ";
- else
- cout << "- ";
- cout.fill('0');
- cout.width(2);
- cout.setf(ios::uppercase);
- cout << hex << (int) theNote->hexCode << " " << dec;
- cout.fill(' ');
- cout << gptParts[theNote->origPartNum].GetDescription().substr(0, 25) << "\n";
- } // if
- theNote = theNote->next;
- } // for
- } // if
-} // GptPartNotes::ShowSummary()
diff --git a/gptpartnotes.h b/gptpartnotes.h
deleted file mode 100644
index 9466bcd..0000000
--- a/gptpartnotes.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- gptpartnotes.h -- Class that takes notes on GPT partitions for purpose of MBR conversion
- Copyright (C) 2010-2011 Roderick W. Smith
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-*/
-
-#ifndef __GPTPARTNOTES_H
-#define __GPTPARTNOTES_H
-
-#include "gpt.h"
-#include "gptpart.h"
-#include "partnotes.h"
-
-using namespace std;
-
-class GptPartNotes : public PartNotes {
- protected:
- GPTPart *gptParts;
- public:
- GptPartNotes();
- GptPartNotes(GPTPart *parts, GPTData *gpt, int num, int blockSize);
-// ~GptPartNotes();
-
- // Add partition notes (little or no error checking)
- int PassPartitions(GPTPart *parts, GPTData *gpt, int num, int blockSize);
-
- // Retrieve data or metadata
- int IsSorted(void);
-
- // Interact with users, possibly changing data with error handling
- void ShowSummary(void);
- int ChangeType(int partNum, int newType);
-};
-
-#endif // __GPTPARTNOTES_H
diff --git a/mbrpart.cc b/mbrpart.cc
new file mode 100644
index 0000000..0214f48
--- /dev/null
+++ b/mbrpart.cc
@@ -0,0 +1,337 @@
+/*
+ MBRPart class, part of GPT fdisk program family.
+ Copyright (C) 2011 Roderick W. Smith
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#define __STDC_LIMIT_MACROS
+#define __STDC_CONSTANT_MACROS
+
+#include <stddef.h>
+#include <stdint.h>
+#include <iostream>
+#include "support.h"
+#include "mbrpart.h"
+
+using namespace std;
+
+uint32_t MBRPart::numHeads = MAX_HEADS;
+uint32_t MBRPart::numSecspTrack = MAX_SECSPERTRACK;
+uint64_t MBRPart::diskSize = 0;
+uint32_t MBRPart::blockSize = 512;
+int MBRPart::numInstances = 0;
+
+MBRPart::MBRPart() {
+ int i;
+
+ status = 0;
+ for (i = 0; i < 3; i++) {
+ firstSector[i] = 0;
+ lastSector[i] = 0;
+ } // for
+ partitionType = 0x00;
+ firstLBA = 0;
+ lengthLBA = 0;
+ includeAs = NONE;
+ canBePrimary = 0;
+ canBeLogical = 0;
+ if (numInstances == 0) {
+ numHeads = MAX_HEADS;
+ numSecspTrack = MAX_SECSPERTRACK;
+ diskSize = 0;
+ blockSize = 512;
+ } // if
+ numInstances++;
+}
+
+MBRPart::MBRPart(const MBRPart& orig) {
+ numInstances++;
+ operator=(orig);
+}
+
+MBRPart::~MBRPart() {
+ numInstances--;
+}
+
+MBRPart& MBRPart::operator=(const MBRPart& orig) {
+ int i;
+
+ status = orig.status;
+ for (i = 0; i < 3; i++) {
+ firstSector[i] = orig.firstSector[i];
+ lastSector[i] = orig.lastSector[i];
+ } // for
+ partitionType = orig.partitionType;
+ firstLBA = orig.firstLBA;
+ lengthLBA = orig.lengthLBA;
+ includeAs = orig.includeAs;
+ canBePrimary = orig.canBePrimary;
+ canBeLogical = orig.canBeLogical;
+ return *this;
+} // MBRPart::operator=(const MBRPart& orig)
+
+// Set partition data from packed MBRRecord structure.
+MBRPart& MBRPart::operator=(const struct MBRRecord& orig) {
+ int i;
+
+ status = orig.status;
+ for (i = 0; i < 3; i++) {
+ firstSector[i] = orig.firstSector[i];
+ lastSector[i] = orig.lastSector[i];
+ } // for
+ partitionType = orig.partitionType;
+ firstLBA = orig.firstLBA;
+ lengthLBA = orig.lengthLBA;
+ if (lengthLBA > 0)
+ includeAs = PRIMARY;
+ else
+ includeAs = NONE;
+ return *this;
+} // MBRPart::operator=(const struct MBRRecord& orig)
+
+/**************************************************
+ * *
+ * Set information on partitions or disks without *
+ * interacting with the user.... *
+ * *
+ **************************************************/
+
+void MBRPart::SetGeometry(uint32_t heads, uint32_t sectors, uint64_t diskSize,
+ uint32_t blockSize) {
+ numHeads = heads;
+ numSecspTrack = sectors;
+} // MBRPart::SetGeometry
+
+// Empty the partition (zero out all values).
+void MBRPart::Empty(void) {
+ status = UINT8_C(0);
+ firstSector[0] = UINT8_C(0);
+ firstSector[1] = UINT8_C(0);
+ firstSector[2] = UINT8_C(0);
+ partitionType = UINT8_C(0);
+ lastSector[0] = UINT8_C(0);
+ lastSector[1] = UINT8_C(0);
+ lastSector[2] = UINT8_C(0);
+ firstLBA = UINT32_C(0);
+ lengthLBA = UINT32_C(0);
+ includeAs = NONE;
+} // MBRPart::Empty()
+
+// Sets the type code, but silently refuses to change it to an extended type
+// code.
+// Returns 1 on success, 0 on failure (extended type code)
+int MBRPart::SetType(uint8_t typeCode, int isExtended) {
+ int allOK = 0;
+
+ if ((isExtended == 1) || ((typeCode != 0x05) && (typeCode != 0x0f) && (typeCode != 0x85))) {
+ partitionType = typeCode;
+ allOK = 1;
+ } // if
+ return allOK;
+} // MBRPart::SetType()
+
+void MBRPart::SetStartLBA(uint64_t start) {
+ if (start > UINT32_MAX)
+ cerr << "Partition start out of range! Continuing, but problems now likely!\n";
+ firstLBA = (uint32_t) start;
+ RecomputeCHS();
+} // MBRPart::SetStartLBA()
+
+void MBRPart::SetLengthLBA(uint64_t length) {
+ if (length > UINT32_MAX)
+ cerr << "Partition length out of range! Continuing, but problems now likely!\n";
+ lengthLBA = (uint32_t) length;
+ RecomputeCHS();
+} // MBRPart::SetLengthLBA()
+
+// Set the start point and length of the partition. This function takes LBA
+// values, sets them directly, and sets the CHS values based on the LBA
+// values and the current geometry settings.
+void MBRPart::SetLocation(uint64_t start, uint64_t length) {
+ if ((start > UINT32_MAX) || (length > UINT32_MAX)) {
+ cerr << "Partition values out of range in MBRPart::SetLocation()!\n"
+ << "Continuing, but strange problems are now likely!\n";
+ } // if
+ firstLBA = (uint32_t) start;
+ lengthLBA = (uint32_t) length;
+ RecomputeCHS();
+
+ // If this is a complete 0xEE protective MBR partition, max out its
+ // CHS last sector value, as per the GPT spec. (Set to 0xffffff,
+ // although the maximum legal MBR value is 0xfeffff, which is
+ // actually what GNU Parted and Apple's Disk Utility use, in
+ // violation of the GPT spec.)
+ if ((partitionType == 0xEE) && (firstLBA == 1) && (lengthLBA == diskSize - 2)) {
+ lastSector[0] = lastSector[1] = lastSector[2] = 0xFF;
+ } // if
+} // MBRPart::SetLocation()
+
+// Store the MBR data in the packed structure used for disk I/O...
+void MBRPart::StoreInStruct(MBRRecord* theStruct) {
+ int i;
+
+ theStruct->firstLBA = firstLBA;
+ theStruct->lengthLBA = lengthLBA;
+ theStruct->partitionType = partitionType;
+ theStruct->status = status;
+ for (i = 0; i < 3; i++) {
+ theStruct->firstSector[i] = firstSector[i];
+ theStruct->lastSector[i] = lastSector[i];
+ } // for
+} // MBRPart::StoreInStruct()
+
+/**********************************************
+* *
+* Get information on partitions or disks.... *
+* *
+**********************************************/
+
+// Returns the last LBA value. Note that this can theoretically be a 33-bit
+// value, so we return a 64-bit value. If lengthLBA == 0, returns 0, even if
+// firstLBA is non-0.
+uint64_t MBRPart::GetLastLBA(void) const {
+ if (lengthLBA > 0)
+ return (uint64_t) firstLBA + (uint64_t) lengthLBA - UINT64_C(1);
+ else
+ return 0;
+} // MBRPart::GetLastLBA()
+
+// Returns 1 if other overlaps with the current partition, 0 if they don't
+// overlap
+int MBRPart::DoTheyOverlap (const MBRPart& other) {
+ return lengthLBA && other.lengthLBA &&
+ (firstLBA <= other.GetLastLBA()) != (GetLastLBA() < other.firstLBA);
+} // MBRPart::DoTheyOverlap()
+
+/*************************************************
+ * *
+ * Adjust information on partitions or disks.... *
+ * *
+ *************************************************/
+
+void MBRPart::RecomputeCHS(void) {
+ if (lengthLBA > 0) {
+ LBAtoCHS(firstLBA, firstSector);
+ LBAtoCHS(firstLBA + lengthLBA - 1, lastSector);
+ } // if
+} // MBRPart::RecomputeCHS()
+
+// Converts 32-bit LBA value to MBR-style CHS value. Returns 1 if conversion
+// was within the range that can be expressed by CHS (including 0, for an
+// empty partition), 0 if the value is outside that range, and -1 if chs is
+// invalid.
+int MBRPart::LBAtoCHS(uint32_t lba, uint8_t * chs) {
+ uint64_t cylinder, head, sector; // all numbered from 0
+ uint64_t remainder;
+ int retval = 1;
+ int done = 0;
+
+ if (chs != NULL) {
+ // Special case: In case of 0 LBA value, zero out CHS values....
+ if (lba == 0) {
+ chs[0] = chs[1] = chs[2] = UINT8_C(0);
+ done = 1;
+ } // if
+ // If LBA value is too large for CHS, max out CHS values....
+ if ((!done) && (lba >= (numHeads * numSecspTrack * MAX_CYLINDERS))) {
+ chs[0] = 254;
+ chs[1] = chs[2] = 255;
+ done = 1;
+ retval = 0;
+ } // if
+ // If neither of the above applies, compute CHS values....
+ if (!done) {
+ cylinder = lba / (numHeads * numSecspTrack);
+ remainder = lba - (cylinder * numHeads * numSecspTrack);
+ head = remainder / numSecspTrack;
+ remainder -= head * numSecspTrack;
+ sector = remainder;
+ if (head < numHeads)
+ chs[0] = (uint8_t) head;
+ else
+ retval = 0;
+ if (sector < numSecspTrack) {
+ chs[1] = (uint8_t) ((sector + 1) + (cylinder >> 8) * 64);
+ chs[2] = (uint8_t) (cylinder & UINT32_C(0xFF));
+ } else {
+ retval = 0;
+ } // if/else
+ } // if value is expressible and non-0
+ } else { // Invalid (NULL) chs pointer
+ retval = -1;
+ } // if CHS pointer valid
+ return (retval);
+} // MBRPart::LBAtoCHS()
+
+// Reverses the byte order, but only if we're on a big-endian platform.
+// Note that most data come in 8-bit structures, so don't need reversing;
+// only the LBA data needs to be reversed....
+void MBRPart::ReverseByteOrder(void) {
+ if (IsLittleEndian() == 0) {
+ ReverseBytes(&firstLBA, 4);
+ ReverseBytes(&lengthLBA, 4);
+ } // if
+} // MBRPart::ReverseByteOrder()
+
+/**************************
+ * *
+ * User I/O functions.... *
+ * *
+ **************************/
+
+// Show MBR data. Should update canBeLogical flags before calling.
+// If isGpt == 1, omits the "can be logical" and "can be primary" columns.
+void MBRPart::ShowData(int isGpt) {
+ char bootCode = ' ';
+
+ if (status && 0x80) // it's bootable
+ bootCode = '*';
+ cout.fill(' ');
+ cout << bootCode << " ";
+ cout.width(13);
+ cout << firstLBA;
+ cout.width(13);
+ cout << GetLastLBA() << " ";
+ switch (includeAs) {
+ case PRIMARY:
+ cout << "primary";
+ break;
+ case LOGICAL:
+ cout << "logical";
+ break;
+ case NONE:
+ cout << "omitted";
+ break;
+ default:
+ cout << "error ";
+ break;
+ } // switch
+ cout.width(7);
+ if (!isGpt) {
+ if (canBeLogical)
+ cout << " Y ";
+ else
+ cout << " ";
+ if (canBePrimary)
+ cout << " Y ";
+ else
+ cout << " ";
+ } // if
+ cout << "0x";
+ cout.width(2);
+ cout.fill('0');
+ cout << hex << (int) partitionType << dec << "\n";
+} // MBRPart::ShowData()
\ No newline at end of file
diff --git a/mbrpart.h b/mbrpart.h
new file mode 100644
index 0000000..4d84e7a
--- /dev/null
+++ b/mbrpart.h
@@ -0,0 +1,111 @@
+/*
+ MBRPart class, part of GPT fdisk program family.
+ Copyright (C) 2011 Roderick W. Smith
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef MBRPART_H
+#define MBRPART_H
+
+#include <stdint.h>
+
+#define MAX_HEADS 255 /* numbered 0 - 254 */
+#define MAX_SECSPERTRACK 63 /* numbered 1 - 63 */
+#define MAX_CYLINDERS 1024 /* numbered 0 - 1023 */
+
+#define NONE 0 /* don't include partition when writing */
+#define PRIMARY 1 /* write partition as primary */
+#define LOGICAL 2 /* write partition as logical */
+#define EBR 4 /* sector is used as an EBR or MBR */
+#define INVALID 8 /* sector number is too large for disk */
+
+using namespace std;
+
+// Data for a single MBR partition record
+// Note that firstSector and lastSector are in CHS addressing, which
+// splits the bits up in a weird way.
+// On read or write of MBR entries, firstLBA is an absolute disk sector.
+// On read of logical entries, it's relative to the EBR record for that
+// partition. When writing EBR records, it's relative to the extended
+// partition's start.
+#pragma pack(1)
+struct MBRRecord {
+ uint8_t status;
+ uint8_t firstSector[3];
+ uint8_t partitionType;
+ uint8_t lastSector[3];
+ uint32_t firstLBA; // see above
+ uint32_t lengthLBA;
+}; // struct MBRRecord
+
+class MBRPart {
+protected:
+ uint8_t status;
+ uint8_t firstSector[3];
+ uint8_t partitionType;
+ uint8_t lastSector[3];
+ uint32_t firstLBA; // see above
+ uint32_t lengthLBA;
+ int includeAs; // PRIMARY, LOGICAL, or NONE
+ int canBeLogical;
+ int canBePrimary;
+ static uint32_t numHeads;
+ static uint32_t numSecspTrack;
+ static uint64_t diskSize;
+ static uint32_t blockSize;
+ static int numInstances;
+
+public:
+ MBRPart();
+ MBRPart(const MBRPart& other);
+ virtual ~MBRPart();
+ virtual MBRPart& operator=(const MBRPart& orig);
+ virtual MBRPart& operator=(const struct MBRRecord& orig);
+
+ // Set information on partitions or disks...
+ void SetGeometry(uint32_t heads, uint32_t sectors, uint64_t diskSize, uint32_t blockSize);
+ void Empty(void);
+ void SetStartLBA(uint64_t s);
+ void SetLengthLBA(uint64_t l);
+ void SetLocation(uint64_t start, uint64_t length);
+ int SetType(uint8_t typeCode, int isExtended = 0);
+ void SetStatus(uint8_t s) {status = s;}
+ void SetInclusion(int status = PRIMARY) {includeAs = status;}
+ void SetCanBeLogical(int c) {canBeLogical = c;}
+ void SetCanBePrimary(int c) {canBePrimary = c;}
+ void StoreInStruct(struct MBRRecord *theStruct);
+
+ // Get information on partitions or disk....
+ uint8_t GetType(void) {return partitionType;}
+ uint8_t GetStatus(void) {return status;}
+ uint64_t GetStartLBA(void) {return firstLBA;}
+ uint64_t GetLengthLBA(void) {return lengthLBA;}
+ uint64_t GetLastLBA(void) const;
+ uint8_t GetInclusion(void) {return includeAs;}
+ int CanBeLogical(void) {return canBeLogical;}
+ int CanBePrimary(void) {return canBePrimary;}
+ int DoTheyOverlap (const MBRPart& other);
+
+ // Adjust information on partitions or disks...
+ void RecomputeCHS(void);
+ int LBAtoCHS(uint32_t lba, uint8_t * chs);
+ void ReverseByteOrder(void);
+
+ // User I/O...
+ void ShowData(int isGpt);
+}; // MBRPart
+
+#endif // MBRPART_H
diff --git a/partnotes.cc b/partnotes.cc
deleted file mode 100644
index a35f9c7..0000000
--- a/partnotes.cc
+++ /dev/null
@@ -1,625 +0,0 @@
-/*
- partnotes.cc -- Class that takes notes on GPT partitions for purpose of MBR conversion
- Copyright (C) 2010 Roderick W. Smith
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-*/
-
-#include <iostream>
-#include <stdio.h>
-#include "partnotes.h"
-#include "gpt.h"
-
-using namespace std;
-
-PartNotes::PartNotes() {
- notes = NULL;
- currentNote = NULL;
- currentIndex = 0;
- origTableSize = 0;
- blockSize = 512;
- dummyNote.active = 0;
- dummyNote.origPartNum = MBR_EMPTY;
- dummyNote.hexCode = 0xEE;
- dummyNote.next = NULL;
- dummyNote.spaceBefore = 0;
- dummyNote.type = WILL_NOT_CONVERT;
-} // PartNotes constructor
-
-// Destructor. Note that we do NOT delete the gptParts array, since we just
-// store a pointer to an array that's allocated by the calling function.
-PartNotes::~PartNotes() {
- DeleteNotes();
-} // PartNotes destructor
-
-// Delete the partition notes....
-void PartNotes::DeleteNotes(void) {
- struct PartInfo *nextNote;
-
- while (notes != NULL) {
- nextNote = notes->next;
- delete notes;
- notes = nextNote;
- } // while
- notes = NULL;
-} // PartNotes::DeleteNotes()
-
-/*************************************************************************
- * *
- * Begin functions that add data to the notes, either by whole notes *
- * or in smaller units. By and large these functions perform little *
- * or no error checking on the added data, so they can create completely *
- * bogus layouts if used carelessly. *
- * *
- *************************************************************************/
-
-// Add a single partition to the end of the linked list.
-// Returns 1 on success, 0 on failures.
-int PartNotes::AddToEnd(struct PartInfo *newOne) {
- struct PartInfo *temp;
- int allOK = 1;
-
- if (newOne != NULL) {
- newOne->next = NULL;
- if (notes == NULL) {
- notes = newOne;
- } else {
- temp = notes;
- while (temp->next != NULL) {
- temp = temp->next;
- } // while
- temp->next = newOne;
- } // if/else
- } else allOK = 0;
- return allOK;
-} // PartNotes::AddToEnd()
-
-// Add a single partition to the start of the linked list.
-// Returns 1 on success, 0 on failures.
-int PartNotes::AddToStart(struct PartInfo *newOne) {
- int allOK = 1;
-
- if (newOne != NULL) {
- newOne->next = notes;
- notes = newOne;
- } else allOK = 0;
- return allOK;
-} // PartNotes::AddToStart()
-
-// Set the type of the partition to PRIMARY, LOGICAL, or WILL_NOT_CONVERT.
-// If partNum is <0, sets type on first partition; if partNum > number
-// of defined partitions, sets type on last partition; if notes list is
-// NULL, does nothing.
-void PartNotes::SetType(int partNum, int type) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- theNote->type = type;
- } // if
-} // PartNotes::SetType()
-
-// Set the MBR hex type to be used
-void PartNotes::SetMbrHexType(int partNum, uint8_t type) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if ((type != 0x0f) && (type != 0x05) && (type != 0x85)) {
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- theNote->hexCode = type;
- } // if
- } else {
- cout << "Refusing to set MBR hex code to one used for an extended partition!\n";
- } // if/else
-} // PartNotes::SetMBRHexType()
-
-void PartNotes::ToggleActiveStatus(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- if (theNote->active)
- theNote->active = 0;
- else
- theNote->active = 0x80;
- } // if
-} // PartNotes::ToggleActiveStatus
-
-
-/***************************************************************************
- * *
- * The following functions retrieve data, either in whole PartInfo units *
- * or in smaller chunks. Some functions perform computations and *
- * comparisons that may require traversing the entire linked list, perhaps *
- * multiple times. *
- * *
- ***************************************************************************/
-
-// Reset currentNotes pointer to the start of the linked list and adjust
-// currentIndex to 0. (Doesn't really retrieve data, but it should be
-// called before most loops that employ PartNotes::GetNextInfo().)
-void PartNotes::Rewind(void) {
- currentNote = notes;
- currentIndex = 0;
-} // PartNotes::Rewind()
-
-// Retrieve the PartInfo structure pointed to by the currentNote pointer,
-// then point currentNote to the next one in the linked list.
-// Returns the number of the returned structure (counting from 0),
-// or -1 if the end has been reached and it returns a dummy value
-int PartNotes::GetNextInfo(struct PartInfo* info) {
- if (currentNote != NULL) {
- *info = *currentNote;
- currentNote = currentNote->next;
- currentIndex++;
- return (currentIndex - 1);
- } else return -1;
-} // PartNotes::GetNextInfo
-
-// Count up the number of partitions that are flagged as either
-// primary or logical
-int PartNotes::GetNumParts() {
- int num = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- while (theNote != NULL) {
- if (((theNote->type == PRIMARY) || (theNote->type == LOGICAL)))
- num++;
- theNote = theNote->next;
- } // while()
- return num;
-} // PartNotes::GetNumParts()
-
-// Count up the number of partitions that are flagged as MBR primary
-// partitions and that have non-negative partition numbers. Note that
-// this value can be greater than 4.
-int PartNotes::GetNumPrimary() {
- int num = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- while (theNote != NULL) {
- if (theNote->type == PRIMARY)
- num++;
- theNote = theNote->next;
- } // while()
- return num;
-} // PartNotes::GetNumPrimary()
-
-// Return the number of extended partitions required to house the
-// partitions that are currently flagged as being logical. This
-// number should be 0 or 1 to make a legal configuration, but this
-// function will return higher values if the current configuration
-// is illegal because it requires more than one extended partition.
-int PartNotes::GetNumExtended() {
- int num = 0, lastWasLogical = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- while (theNote != NULL) {
- switch (theNote->type) {
- case PRIMARY:
- lastWasLogical = 0;
- break;
- case LOGICAL:
- if (!lastWasLogical)
- num++;
- lastWasLogical = 1;
- break;
- case WILL_NOT_CONVERT:
- break; // do nothing
- } // switch
- theNote = theNote->next;
- } // while
- return num;
-} // PartNotes::GetNumExtended()
-
-// Count up the number of partitions that are flagged as MBR logical
-// partitions. Note that these may be discontiguous, and so represent
-// an illegal configuration...
-int PartNotes::GetNumLogical() {
- int num = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- while (theNote != NULL) {
- if (theNote->type == LOGICAL)
- num++;
- theNote = theNote->next;
- } // while()
- return num;
-} // PartNotes::GetNumLogical()
-
-// Return the partition type (PRIMARY, LOGICAL, or WILL_NOT_CONVERT)
-// If partNum is <0, returns status of first partition; if partNum >
-// number of defined partitions, returns status of last partition;
-// if notes list is NULL, returns WILL_NOT_CONVERT.
-int PartNotes::GetType(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- return theNote->type;
- } else {
- return WILL_NOT_CONVERT;
- } // if/else
-} // PartNotes::GetType()
-
-// Return the scheduled MBR hex code
-uint8_t PartNotes::GetMbrHexType(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- return theNote->hexCode;
- } else {
- return 0x00;
- } // if/else
-} // PartNotes::GetMBRHexType()
-
-// Return the original partition number associated with this note, -1 if
-// the notes list is empty, or the original partition number of the last
-// partition if partNum is too high.
-int PartNotes::GetOrigNum(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- return theNote->origPartNum;
- } else {
- return -1;
- } // if/else
-} // PartNotes::GetOrigNum()
-
-// Return whether or not the partition is flagged as active (bootable)
-int PartNotes::GetActiveStatus(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- return theNote->active;
- } else {
- return 0;
- } // if/else
-} // PartNotes::GetActiveStatus()
-
-// Returns 1 if the partition can be a logical partition (ignoring whether this
-// will make the set as a whole illegal), 0 if it must be a primary
-int PartNotes::CanBeLogical(int partNum) {
- int count = 0;
- struct PartInfo *theNote;
-
- theNote = notes;
- if (theNote != NULL) {
- while ((count++ < partNum) && (theNote->next != NULL))
- theNote = theNote->next;
- return theNote->spaceBefore;
- } else {
- return 0;
- } // if/else
-} // PartNotes::CanBeLogical()
-
-// Find the logical partition that begins the first extended
-// partition, starting at start.
-// Returns the number of logicals in that partition, or 0 if nothing
-// is found. The start value is modified to point to the first
-// logical partition in the extended partition (it's called by
-// reference!).
-int PartNotes::FindExtended(int &start) {
- int length = 0, next = 0;
- struct PartInfo *theNote;
-
- if ((notes != NULL) && (start >= 0)) {
- theNote = notes;
- while ((theNote->next != NULL) && ((next < start) || (theNote->type != LOGICAL))) {
- theNote = theNote->next;
- next++;
- } // while()
- start = next;
- while ((theNote->next != NULL) && (theNote->type == LOGICAL)) {
- length ++;
- theNote = theNote->next;
- } // while
- } // if arrays exist
- return length;
-} // PartNotes::FindExtended()
-
-// Returns 1 if the set as a whole makes a legal MBR partition table
-// (possibly with logicals), 0 if not
-int PartNotes::IsLegal(void) {
- int p, e, legalLogicals = 1;
- struct PartInfo *theNote;
-
- p = GetNumPrimary();
- e = GetNumExtended();
- theNote = notes;
- while (theNote != NULL) {
- if ((!theNote->spaceBefore) && (theNote->type == LOGICAL))
- legalLogicals = 0;
- theNote = theNote->next;
- } // while
- return (((p+e) <= 4) && (e <= 1) && legalLogicals);
-} // PartNotes::IsLegal()
-
-/*************************************************************************
- * *
- * The following partitions manipulate the data in the quest to create a *
- * legal MBR layout. *
- * *
- *************************************************************************/
-
-// Remove duplicate partitions from the list.
-void PartNotes::RemoveDuplicates(void) {
- struct PartInfo *n1, *n2;
-
- n1 = notes;
- while (n1 != NULL) {
- n2 = n1->next;
- while (n2 != NULL) {
- if ((n1->firstLBA == n2->firstLBA) && (n1->lastLBA == n2->lastLBA)) {
- n1->next = n2->next;
- delete n2;
- n2 = n1->next;
- } else {
- n2 = n2->next;
- } // if/else
- } // while (n2 != NULL)
- n1 = n1->next;
- } // while (n1 != NULL)
-} // PartNotes::RemoveDuplicates()
-
-// Creates a legal mix of primaries and logicals, maximizing the number
-// of included partitions. Also removes duplicates.
-// Returns 1 if successful, 0 if not (if missing notes list, say)
-int PartNotes::MakeItLegal(void) {
- struct PartInfo *theNote, *lastPrimary, *firstPart;
-
- if (notes == NULL)
- return 0;
-
- RemoveDuplicates();
-
- if (!IsLegal()) {
- cout << "Isn't legal!\n";
- // Start by eliminating or converting excessive extended partitions...
- while (GetNumExtended() > 1)
- TrimSmallestExtended();
- // If that was insufficient, cut primary partitions...
- lastPrimary = notes;
- while (!IsLegal() && (lastPrimary != NULL)) {
- lastPrimary = NULL;
- theNote = notes;
- do {
- if (theNote->type == PRIMARY)
- lastPrimary = theNote;
- theNote = theNote->next;
- } while (theNote != NULL);
- if (lastPrimary != NULL)
- lastPrimary->type = WILL_NOT_CONVERT;
- } // if
- } // if
-
- // If four or fewer partitions were converted, make them all primaries
- if ((GetNumPrimary() + GetNumLogical()) <= 4) {
- theNote = notes;
- do {
- if (theNote->type == LOGICAL)
- theNote->type = PRIMARY;
- theNote = theNote->next;
- } while (theNote != NULL);
- } // if
-
- // Try to make the first partition a primary...
- if ((GetNumExtended() + GetNumPrimary()) < 4) {
- theNote = notes;
- firstPart = notes;
- while ((theNote != NULL) && (firstPart != NULL)) {
- if ((theNote->firstLBA < firstPart->firstLBA) && (theNote->type != WILL_NOT_CONVERT))
- firstPart = theNote;
- theNote = theNote->next;
- };
- if (firstPart->spaceBefore)
- firstPart->type = PRIMARY;
- } // if
-
- return IsLegal();
-} // PartNotes::MakeItLegal()
-
-// Change the type flag in the notes array for all the partitions associated
-// with the smallest extended partition to WILL_NOT_CONVERT or (if possible)
-// PRIMARY
-void PartNotes::TrimSmallestExtended() {
- struct ExtendedInfo *extendeds;
- int i, numExtended, shortestNum, shortestIndex = -1;
- struct PartInfo *theNote;
-
- if (notes != NULL) {
- numExtended = GetNumExtended();
- extendeds = new struct ExtendedInfo[numExtended];
-
- // Find the start and number of partitions in each extended partition....
- for (i = 0; i < numExtended; i++) {
- if (i == 0)
- extendeds[i].startNum = 0;
- else
- extendeds[i].startNum = extendeds[i - 1].startNum + extendeds[i - 1].numLogicals;
- extendeds[i].numLogicals = FindExtended(extendeds[i].startNum);
- } // for
-
- // Find the smallest extended partition....
- shortestNum = origTableSize + 1;
- for (i = 0; i < numExtended; i++) {
- if (extendeds[i].numLogicals < shortestNum) {
- shortestNum = extendeds[i].numLogicals;
- shortestIndex = extendeds[i].startNum;
- } // if
- } // for
-
- // Now flag its partitions as PRIMARY (if possible) or
- // WILL_NOT_CONVERT
- theNote = notes;
- i = 0;
- while ((i++ < shortestIndex) && (theNote->next != NULL))
- theNote = theNote->next;
- do {
- if (GetNumPrimary() < 3)
- theNote->type = PRIMARY;
- else
- theNote->type = WILL_NOT_CONVERT;
- theNote = theNote->next;
- } while ((i++ < shortestNum + shortestIndex) && (theNote != NULL));
-
- delete[] extendeds;
- } // if
-} // PartNotes::TrimSmallestExtended
-
-
-/*************************************************************************
- * *
- * Interact with users, presenting data and/or collecting responses. May *
- * change data with error detection and correction. *
- * *
- *************************************************************************/
-
-// Display summary information for the user
-void PartNotes::ShowSummary(void) {
- cerr << "Program is calling PartNotes::ShowSummary(); this is a virtual base function,\n"
- << "and should never be called.\n";
-} // PartNotes::ShowSummary()
-
-// Interact with the user to create a change in the specified
-// partition.
-// Returns 1 if successful, 0 if not. Note that aborting the
-// change counts as successful; 0 should be returned only in
-// case of dire bugs.
-int PartNotes::MakeChange(int partNum) {
- int allOK = 1;
- int type = 0;
- char line[255], command;
-
- if (notes != NULL) {
- cout << "What do you want to do?\n";
- cout << " a - toggle active flag\n";
- switch (GetType(partNum)) {
- case PRIMARY:
- cout << " d - drop partition from MBR\n";
- cout << " l - convert partition to logical\n";
- break;
- case LOGICAL:
- cout << " d - drop partition from MBR\n";
- cout << " p - convert partition to primary\n";
- break;
- case WILL_NOT_CONVERT:
- cout << " p - add partition as primary\n";
- cout << " l - add partition as logical\n";
- break;
- } // switch
- cout << " t - change MBR type code\n";
- cout << "Action: ";
- if (!fgets(line, 255, stdin)) {
- cerr << "Critical error! Failed fgets() in PartNotes::MakeChange()!\n";
- exit(1);
- } // if
- sscanf(line, "%c", &command);
- switch (command) {
- case 'a': case 'A':
- ToggleActiveStatus(partNum);
- break;
- case 'd': case 'D':
- allOK = ChangeType(partNum, WILL_NOT_CONVERT);
- break;
- case 'l': case 'L':
- allOK = ChangeType(partNum, LOGICAL);
- break;
- case 'p': case 'P':
- allOK = ChangeType(partNum, PRIMARY);
- break;
- case 't': case 'T':
- while (type == 0) {
- cout << "Enter a 2-byte hexadecimal MBR type code: ";
- if (!fgets(line, 255, stdin)) {
- cerr << "Critical error! Failed fgets() in PartNotes::MakeChange()\n";
- exit(1);
- } // if
- sscanf(line, "%x", &type);
- } // while
- SetMbrHexType(partNum, (uint8_t) type);
- break;
- default:
- cout << "Unrecognized command; making no change.\n";
- break;
- } // switch
- } else allOK = 0; // if
- return allOK;
-} // PartNotes::MakeChange()
-
-// Turn the partition into the specified type, if this is legal.
-// Returns 1 unless there's a dire bug.
-int PartNotes::ChangeType(int partNum, int newType) {
- int origType, allOK = 1;
- char line[255];
-
- if ((notes != NULL) && IsLegal()) {
- origType = GetType(partNum);
- SetType(partNum, newType);
- if (!IsLegal()) {
- cout << "The requested change is not possible.\n";
- if (newType == LOGICAL) {
- if (!CanBeLogical(partNum))
- cout << "At least one free sector must exist before each logical partition.\n";
- else
- cout << "All logical partitions must be contiguous.\n";
- } // if
- if ((newType == PRIMARY) && (GetNumPrimary() + GetNumExtended()) > 4)
- cout << "You can have only four primary partitions (all logical partitions "
- << "count as one\nprimary partition).\n";
- if ((newType == PRIMARY) && (GetNumExtended()) > 1)
- cout << "Logical partitions must form a single contiguous group.\n";
- cout << "\nYou may be able to achieve your desired goal by making changes in "
- << "another\norder, such as deleting partitions before changing others' "
- << "types.\n";
- cout << "\nReverting change.\nPress <Enter> to continue: ";
- if (!fgets(line, 255, stdin)) {
- cerr << "Critical error! Failed fgets() in PartNotes::ChangeType()\n";
- exit(1);
- } // if
- SetType(partNum, origType);
- } // if
- } else allOK = 0; // if
- return allOK;
-} // PartNotes::ChangeType()
diff --git a/partnotes.h b/partnotes.h
deleted file mode 100644
index 750b75f..0000000
--- a/partnotes.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- partnotes.h -- Class that takes notes on GPT partitions for purpose of MBR conversion
- Copyright (C) 2010-2011 Roderick W. Smith
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-*/
-
-#ifndef __PARTNOTES_H
-#define __PARTNOTES_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-using namespace std;
-
-#define WILL_NOT_CONVERT 0
-#define PRIMARY 1
-#define LOGICAL 2
-
-// Data structure used in GPT-to-MBR conversions; holds pointer to GPT
-// partition number, start and end sectors, and a few MBR-specific details
-struct PartInfo {
- int origPartNum;
- int spaceBefore; // boolean; if 1, can theoretically become a logical part.
- int active; // boolean
- int type; // WILL_NOT_CONVERT, PRIMARY, or LOGICAL
- uint64_t firstLBA;
- uint64_t lastLBA;
- unsigned int hexCode;
- struct PartInfo *next;
-};
-
-struct ExtendedInfo {
- int startNum;
- int numLogicals;
-};
-
-class PartNotes {
- protected:
- struct PartInfo dummyNote;
- struct PartInfo *notes;
- struct PartInfo *currentNote;
- int currentIndex;
- int blockSize;
- int origTableSize;
-
- void DeleteNotes(void);
-
- public:
- PartNotes();
- ~PartNotes();
-
- // Add partition notes (little or no error checking)
-// int PassPartitions(GPTPart *parts, GPTData *gpt, int num, int blockSize);
- int AddToEnd(struct PartInfo* newOne);
- int AddToStart(struct PartInfo* newOne);
- void SetType(int partNum, int type); // type is PRIMARY, LOGICAL, or WILL_NOT_CONVERT
- void SetMbrHexType(int partNum, uint8_t type);
- void ToggleActiveStatus(int partNum);
-
- // Retrieve data or metadata
- void Rewind(void);
- int GetNextInfo(struct PartInfo * info);
- int GetNumParts();
- int GetNumPrimary();
- int GetNumExtended();
- int GetNumLogical();
- int GetType(int partNum);
- uint8_t GetMbrHexType(int i);
- int GetOrigNum(int partNum);
- int GetActiveStatus(int partNum);
- int CanBeLogical(int partNum); // returns boolean
- int FindExtended(int &start);
- int IsLegal(void); // returns Boolean
-
- // Manipulate data or metadata
- void RemoveDuplicates(void);
- int MakeItLegal(void);
- void TrimSmallestExtended(void);
-
- // Interact with users, possibly changing data with error handling
- virtual void ShowSummary(void);
- int MakeChange(int partNum);
- int ChangeType(int partNum, int newType);
-};
-
-#endif // __PARTNOTES_H