parttypes.cc

   1 // parttypes.cc
   2 // Class to manage partition type codes -- a slight variant on MBR type
   3 // codes, GUID type codes, and associated names.
   4
   5 /* This program is copyright (c) 2009-2011 by Roderick W. Smith. It is distributed
   6   under the terms of the GNU GPL version 2, as detailed in the COPYING file. */
   7
   8 #define __STDC_LIMIT_MACROS
   9 #define __STDC_CONSTANT_MACROS
  10
  11 #include <string.h>
  12 #include <stdint.h>
  13 #include <stdio.h>
  14 #include <iostream>
  15 #include "parttypes.h"
  16
  17 using namespace std;
  18
  19 int PartType::numInstances = 0;
  20 AType* PartType::allTypes = NULL;
  21 AType* PartType::lastType = NULL;
  22
  23 // Constructor. Its main task is to initialize the data list, but only
  24 // if this is the first instance, since it's a static linked list.
  25 // Partition type codes are MBR type codes multiplied by 0x0100, with
  26 // additional related codes taking on following numbers. For instance,
  27 // the FreeBSD disklabel code in MBR is 0xa5; here, it's 0xa500, with
  28 // additional FreeBSD codes being 0xa501, 0xa502, and so on. This gives
  29 // related codes similar numbers and (given appropriate entry positions
  30 // in the linked list) keeps them together in the listings generated
  31 // by typing "L" at the main gdisk menu.
  32 PartType::PartType(void) : GUIDData() {
  33    numInstances++;
  34    if (numInstances == 1) {
  35       AddAllTypes();
  36    } // if
  37 } // default constructor
  38
  39 PartType::PartType(const PartType & orig) : GUIDData(orig) {
  40    numInstances++;
  41    if (numInstances == 1) { // should never happen; just being paranoid
  42       AddAllTypes();
  43    } // if
  44 } // PartType copy constructor
  45
  46 PartType::PartType(const GUIDData & orig) : GUIDData(orig) {
  47    numInstances++;
  48    if (numInstances == 1) {
  49       AddAllTypes();
  50    } // if
  51 } // PartType copy constructor
  52
  53 PartType::~PartType(void) {
  54    AType* tempType;
  55
  56    numInstances--;
  57    if (numInstances == 0) {
  58       while (allTypes != NULL) {
  59          tempType = allTypes;
  60          allTypes = allTypes->next;
  61          delete tempType;
  62       } // while
  63    } // if
  64 } // destructor
  65
  66 // Add all partition type codes to the internal linked-list structure.
  67 // Used by constructors.
  68 // See http://www.win.tue.nl/~aeb/partitions/partition_types-1.html
  69 // for a list of MBR partition type codes.
  70 void PartType::AddAllTypes(void) {
  71    // Start with the "unused entry," which should normally appear only
  72    // on empty partition table entries....
  73    AddType(0x0000, "00000000-0000-0000-0000-000000000000", "Unused entry", 0);
  74
  75    // DOS/Windows partition types, which confusingly Linux also uses in GPT
  76    AddType(0x0100, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-12
  77    AddType(0x0400, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16 < 32M
  78    AddType(0x0600, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16
  79    AddType(0x0700, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 1); // NTFS (or HPFS)
  80    AddType(0x0b00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-32
  81    AddType(0x0c00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-32 LBA
  82    AddType(0x0c01, "E3C9E316-0B5C-4DB8-817D-F92DF00215AE", "Microsoft reserved");
  83    AddType(0x0e00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16 LBA
  84    AddType(0x1100, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-12
  85    AddType(0x1400, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16 < 32M
  86    AddType(0x1600, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16
  87    AddType(0x1700, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden NTFS (or HPFS)
  88    AddType(0x1b00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-32
  89    AddType(0x1c00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-32 LBA
  90    AddType(0x1e00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16 LBA
  91    AddType(0x2700, "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC", "Windows RE");
  92    AddType(0x4200, "AF9B60A0-1431-4F62-BC68-3311714A69AD", "Windows LDM data"); // Logical disk manager
  93    AddType(0x4201, "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3", "Windows LDM metadata"); // Logical disk manager
  94
  95    // An oddball IBM filesystem....
  96    AddType(0x7501, "37AFFC90-EF7D-4E96-91C3-2D7AE055B174", "IBM GPFS"); // General Parallel File System (GPFS)
  97
  98    // ChromeOS-specific partition types...
  99    // Values taken from vboot_reference/firmware/lib/cgptlib/include/gpt.h in
 100    // ChromeOS source code, retrieved 12/23/2010. They're also at
 101    // http://www.chromium.org/chromium-os/chromiumos-design-docs/disk-format.
 102    // These have no MBR equivalents, AFAIK, so I'm using 0x7Fxx values, since they're close
 103    // to the Linux values.
 104    AddType(0x7f00, "FE3A2A5D-4F32-41A7-B725-ACCC3285A309", "ChromeOS kernel");
 105    AddType(0x7f01, "3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC", "ChromeOS root");
 106    AddType(0x7f02, "2E0A753D-9E48-43B0-8337-B15192CB1B5E", "ChromeOS reserved");
 107
 108    // Linux-specific partition types....
 109    AddType(0x8200, "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F", "Linux swap"); // Linux swap (or Solaris)
 110    AddType(0x8300, "0FC63DAF-8483-4772-8E79-3D69D8477DE4", "Linux filesystem"); // Linux native
 111    AddType(0x8301, "8DA63339-0007-60C0-C436-083AC8230908", "Linux reserved");
 112    AddType(0x8e00, "E6D6D379-F507-44C2-A23C-238F2A3DF928", "Linux LVM");
 113
 114    // FreeBSD partition types....
 115    // Note: Rather than extract FreeBSD disklabel data, convert FreeBSD
 116    // partitions in-place, and let FreeBSD sort out the details....
 117    AddType(0xa500, "516E7CB4-6ECF-11D6-8FF8-00022D09712B", "FreeBSD disklabel");
 118    AddType(0xa501, "83BD6B9D-7F41-11DC-BE0B-001560B84F0F", "FreeBSD boot");
 119    AddType(0xa502, "516E7CB5-6ECF-11D6-8FF8-00022D09712B", "FreeBSD swap");
 120    AddType(0xa503, "516E7CB6-6ECF-11D6-8FF8-00022D09712B", "FreeBSD UFS");
 121    AddType(0xa504, "516E7CBA-6ECF-11D6-8FF8-00022D09712B", "FreeBSD ZFS");
 122    AddType(0xa505, "516E7CB8-6ECF-11D6-8FF8-00022D09712B", "FreeBSD Vinum/RAID");
 123
 124    // Midnight BSD partition types....
 125    AddType(0xa580, "85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD data");
 126    AddType(0xa581, "85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD boot");
 127    AddType(0xa582, "85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD swap");
 128    AddType(0xa583, "0394Ef8B-237E-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD UFS");
 129    AddType(0xa584, "85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD ZFS");
 130    AddType(0xa585, "85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD Vinum");
 131
 132    // A MacOS partition type, separated from others by NetBSD partition types...
 133    AddType(0xa800, "55465300-0000-11AA-AA11-00306543ECAC", "Apple UFS"); // Mac OS X
 134
 135    // NetBSD partition types. Note that the main entry sets it up as a
 136    // FreeBSD disklabel. I'm not 100% certain this is the correct behavior.
 137    AddType(0xa900, "516E7CB4-6ECF-11D6-8FF8-00022D09712B", "FreeBSD disklabel", 0); // NetBSD disklabel
 138    AddType(0xa901, "49F48D32-B10E-11DC-B99B-0019D1879648", "NetBSD swap");
 139    AddType(0xa902, "49F48D5A-B10E-11DC-B99B-0019D1879648", "NetBSD FFS");
 140    AddType(0xa903, "49F48D82-B10E-11DC-B99B-0019D1879648", "NetBSD LFS");
 141    AddType(0xa904, "2DB519C4-B10F-11DC-B99B-0019D1879648", "NetBSD concatenated");
 142    AddType(0xa905, "2DB519EC-B10F-11DC-B99B-0019D1879648", "NetBSD encrypted");
 143    AddType(0xa906, "49F48DAA-B10E-11DC-B99B-0019D1879648", "NetBSD RAID");
 144
 145    // Mac OS partition types (See also 0xa800, above)....
 146    AddType(0xab00, "426F6F74-0000-11AA-AA11-00306543ECAC", "Apple boot");
 147    AddType(0xaf00, "48465300-0000-11AA-AA11-00306543ECAC", "Apple HFS/HFS+");
 148    AddType(0xaf01, "52414944-0000-11AA-AA11-00306543ECAC", "Apple RAID");
 149    AddType(0xaf02, "52414944-5F4F-11AA-AA11-00306543ECAC", "Apple RAID offline");
 150    AddType(0xaf03, "4C616265-6C00-11AA-AA11-00306543ECAC", "Apple label");
 151    AddType(0xaf04, "5265636F-7665-11AA-AA11-00306543ECAC", "AppleTV recovery");
 152    AddType(0xaf05, "53746F72-6167-11AA-AA11-00306543ECAC", "Apple Core Storage");
 153
 154    // Solaris partition types (one of which is shared with MacOS)
 155    AddType(0xbe00, "6A82CB45-1DD2-11B2-99A6-080020736631", "Solaris boot");
 156    AddType(0xbf00, "6A85CF4D-1DD2-11B2-99A6-080020736631", "Solaris root");
 157    AddType(0xbf01, "6A898CC3-1DD2-11B2-99A6-080020736631", "Solaris /usr & Mac ZFS"); // Solaris/MacOS
 158    AddType(0xbf02, "6A87C46F-1DD2-11B2-99A6-080020736631", "Solaris swap");
 159    AddType(0xbf03, "6A8B642B-1DD2-11B2-99A6-080020736631", "Solaris backup");
 160    AddType(0xbf04, "6A8EF2E9-1DD2-11B2-99A6-080020736631", "Solaris /var");
 161    AddType(0xbf05, "6A90BA39-1DD2-11B2-99A6-080020736631", "Solaris /home");
 162    AddType(0xbf06, "6A9283A5-1DD2-11B2-99A6-080020736631", "Solaris alternate sector");
 163    AddType(0xbf07, "6A945A3B-1DD2-11B2-99A6-080020736631", "Solaris Reserved 1");
 164    AddType(0xbf08, "6A9630D1-1DD2-11B2-99A6-080020736631", "Solaris Reserved 2");
 165    AddType(0xbf09, "6A980767-1DD2-11B2-99A6-080020736631", "Solaris Reserved 3");
 166    AddType(0xbf0a, "6A96237F-1DD2-11B2-99A6-080020736631", "Solaris Reserved 4");
 167    AddType(0xbf0b, "6A8D2AC7-1DD2-11B2-99A6-080020736631", "Solaris Reserved 5");
 168
 169    // I can find no MBR equivalents for these, but they're on the
 170    // Wikipedia page for GPT, so here we go....
 171    AddType(0xc001, "75894C1E-3AEB-11D3-B7C1-7B03A0000000", "HP-UX data");
 172    AddType(0xc002, "E2A1E728-32E3-11D6-A682-7B03A0000000", "HP-UX service");
 173
 174    // EFI system and related partitions
 175    AddType(0xef00, "C12A7328-F81F-11D2-BA4B-00A0C93EC93B", "EFI System"); // Parted identifies these as having the "boot flag" set
 176    AddType(0xef01, "024DEE41-33E7-11D3-9D69-0008C781F39F", "MBR partition scheme"); // Used to nest MBR in GPT
 177    AddType(0xef02, "21686148-6449-6E6F-744E-656564454649", "BIOS boot partition"); // Boot loader
 178
 179    // A straggler Linux partition type....
 180    AddType(0xfd00, "A19D880F-05FC-4D3B-A006-743F0F84911E", "Linux RAID");
 181
 182    // Note: DO NOT use the 0xffff code; that's reserved to indicate an
 183    // unknown GUID type code.
 184 } // PartType::AddAllTypes()
 185
 186 // Add a single type to the linked list of types. Returns 1 if operation
 187 // succeeds, 0 otherwise.
 188 int PartType::AddType(uint16_t mbrType, const char * guidData, const char * name,
 189                       int toDisplay) {
 190    AType* tempType;
 191    int allOK = 1;
 192
 193    tempType = new AType;
 194    if (tempType != NULL) {
 195       tempType->MBRType = mbrType;
 196       tempType->GUIDType = guidData;
 197       tempType->name = name;
 198       tempType->display = toDisplay;
 199       tempType->next = NULL;
 200       if (allTypes == NULL) { // first entry
 201          allTypes = tempType;
 202       } else {
 203          lastType->next = tempType;
 204       } // if/else
 205       lastType = tempType;
 206    } else {
 207       cerr << "Unable to allocate memory in PartType::AddType()! Partition type list will\n";
 208       cerr << "be incomplete!\n";
 209       allOK = 0;
 210    } // if/else
 211    return allOK;
 212 } // GUID::AddType(const char* variant)
 213
 214 // Assignment operator by string. If the original string is short,
 215 // interpret it as a gdisk hex code; if it's longer, interpret it as
 216 // a direct entry of a GUID value. If a short string isn't a hex
 217 // number, do nothing.
 218 PartType & PartType::operator=(const string & orig) {
 219    uint32_t hexCode;
 220
 221    if (orig.length() < 32) {
 222       if (IsHex(orig)) {
 223          sscanf(orig.c_str(), "%x", &hexCode);
 224          *this = hexCode;
 225       }
 226    } else {
 227       GUIDData::operator=(orig);
 228    } // if/else hexCode or GUID
 229    return *this;
 230 } // PartType::operator=(const char * orig)
 231
 232 // Assignment from C-style string; rely on C++ casting....
 233 PartType & PartType::operator=(const char * orig) {
 234    return operator=((string) orig);
 235 } // PartType::operator=(const char * orig)
 236
 237 // Assign a GUID based on my custom 2-byte (16-bit) MBR hex ID variant
 238 PartType & PartType::operator=(uint16_t ID) {
 239    AType* theItem = allTypes;
 240    int found = 0;
 241
 242    // Now search the type list for a match to the ID....
 243    while ((theItem != NULL) && (!found)) {
 244       if (theItem->MBRType == ID)  {
 245          GUIDData::operator=(theItem->GUIDType);
 246          found = 1;
 247       } else {
 248          theItem = theItem->next;
 249       } // if/else
 250    } // while
 251    if (!found) {
 252       // Assign a default value....
 253       operator=(DEFAULT_TYPE);
 254       cout.setf(ios::uppercase);
 255       cout.fill('0');
 256       cout << "Exact type match not found for type code ";
 257       cout.width(4);
 258       cout << hex << ID << "; assigning type code for\n'" << TypeName() << "'\n" << dec;
 259       cout.fill(' ');
 260    } // if (!found)
 261    return *this;
 262 } // PartType::operator=(uint16_t ID)
 263
 264 // Return the English description of the partition type (e.g., "Linux filesystem")
 265 string PartType::TypeName(void) const {
 266    AType* theItem = allTypes;
 267    int found = 0;
 268    string typeName;
 269
 270    while ((theItem != NULL) && (!found)) {
 271       if (theItem->GUIDType == *this) { // found it!
 272          typeName = theItem->name;
 273          found = 1;
 274       } else {
 275          theItem = theItem->next;
 276       } // if/else
 277    } // while
 278    if (!found) {
 279       typeName = "Unknown";
 280    } // if (!found)
 281    return typeName;
 282 } // PartType::TypeName()
 283
 284 // Return the Unicode description of the partition type (e.g., "Linux filesystem")
 285 UnicodeString PartType::UTypeName(void) const {
 286    AType* theItem = allTypes;
 287    int found = 0;
 288    UnicodeString typeName;
 289
 290    while ((theItem != NULL) && (!found)) {
 291       if (theItem->GUIDType == *this) { // found it!
 292          typeName = theItem->name.c_str();
 293          found = 1;
 294       } else {
 295          theItem = theItem->next;
 296       } // if/else
 297    } // while
 298    if (!found) {
 299       typeName = "Unknown";
 300    } // if (!found)
 301    return typeName;
 302 } // PartType::TypeName()
 303
 304 // Return the custom GPT fdisk 2-byte (16-bit) hex code for this GUID partition type
 305 // Note that this function ignores entries for which the display variable
 306 // is set to 0. This enables control of which values get returned when
 307 // there are multiple possibilities, but opens the algorithm up to the
 308 // potential for problems should the data in the list be bad.
 309 uint16_t PartType::GetHexType() const {
 310    AType* theItem = allTypes;
 311    int found = 0;
 312    uint16_t theID = 0xFFFF;
 313
 314    while ((theItem != NULL) && (!found)) {
 315       if ((theItem->GUIDType == *this) && (theItem->display == 1)) { // found it!
 316          theID = theItem->MBRType;
 317          found = 1;
 318       } else {
 319          theItem = theItem->next;
 320       } // if/else
 321    } // while
 322    if (!found) {
 323       theID = 0xFFFF;
 324    } // if (!found)
 325    return theID;
 326 } // PartType::GetHex()
 327
 328 // Displays the available types and my extended MBR codes for same....
 329 // Note: This function assumes an 80-column display. On wider displays,
 330 // it stops at under 80 columns; on narrower displays, lines will wrap
 331 // in an ugly way.
 332 void PartType::ShowAllTypes(void) const {
 333    int colCount = 1; // column count
 334    size_t i;
 335    AType* thisType = allTypes;
 336
 337    cout.unsetf(ios::uppercase);
 338    while (thisType != NULL) {
 339       if (thisType->display == 1) { // show it
 340          cout.fill('0');
 341          cout.width(4);
 342          cout << hex << thisType->MBRType << " ";
 343          cout << thisType->name.substr(0, 20);
 344          for (i = 0; i < (20 - (thisType->name.substr(0, 20).length())); i++)
 345             cout << " ";
 346          if ((colCount % 3) == 0)
 347             cout << "\n";
 348          else
 349             cout << "  ";
 350          colCount++;
 351       } // if
 352       thisType = thisType->next;
 353    } // while
 354    cout.fill(' ');
 355    cout << "\n" << dec;
 356 } // PartType::ShowTypes()
 357
 358 // Returns 1 if code is a valid extended MBR code, 0 if it's not
 359 int PartType::Valid(uint16_t code) const {
 360    AType* thisType = allTypes;
 361    int found = 0;
 362
 363    while ((thisType != NULL) && (!found)) {
 364       if (thisType->MBRType == code) {
 365          found = 1;
 366       } // if
 367       thisType = thisType->next;
 368    } // while
 369    return found;
 370 } // PartType::Valid()