srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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 | |
srs5694 | 64cbd17 | 2011-03-01 22:03:54 -0500 | [diff] [blame] | 5 | /* This program is copyright (c) 2009-2011 by Roderick W. Smith. It is distributed |
srs5694 | 221e087 | 2009-08-29 15:00:31 -0400 | [diff] [blame] | 6 | under the terms of the GNU GPL version 2, as detailed in the COPYING file. */ |
| 7 | |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 8 | #define __STDC_LIMIT_MACROS |
| 9 | #define __STDC_CONSTANT_MACROS |
| 10 | |
| 11 | #include <string.h> |
| 12 | #include <stdint.h> |
| 13 | #include <stdio.h> |
srs5694 | fed16d0 | 2010-01-27 23:03:40 -0500 | [diff] [blame] | 14 | #include <iostream> |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 15 | #include "parttypes.h" |
| 16 | |
| 17 | using namespace std; |
| 18 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 19 | int PartType::numInstances = 0; |
| 20 | AType* PartType::allTypes = NULL; |
| 21 | AType* PartType::lastType = NULL; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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. |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 32 | PartType::PartType(void) : GUIDData() { |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 33 | numInstances++; |
| 34 | if (numInstances == 1) { |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 35 | AddAllTypes(); |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 36 | } // if |
| 37 | } // default constructor |
| 38 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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) { |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 66 | // Add all partition type codes to the internal linked-list structure. |
| 67 | // Used by constructors. |
srs5694 | 55d9261 | 2010-03-07 22:16:07 -0500 | [diff] [blame] | 68 | // See http://www.win.tue.nl/~aeb/partitions/partition_types-1.html |
| 69 | // for a list of MBR partition type codes. |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 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 |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 82 | AddType(0x0c01, "E3C9E316-0B5C-4DB8-817D-F92DF00215AE", "Microsoft reserved"); |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 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 |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 | |
srs5694 | df9d363 | 2011-01-08 18:33:24 -0500 | [diff] [blame] | 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 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 108 | // Linux-specific partition types.... |
| 109 | AddType(0x8200, "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F", "Linux swap"); // Linux swap (or Solaris) |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 110 | AddType(0x8300, "0FC63DAF-8483-4772-8E79-3D69D8477DE4", "Linux filesystem"); // Linux native |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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.... |
srs5694 | cb76c67 | 2010-02-11 22:22:22 -0500 | [diff] [blame] | 117 | AddType(0xa500, "516E7CB4-6ECF-11D6-8FF8-00022D09712B", "FreeBSD disklabel"); |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 | |
srs5694 | fa3868e | 2012-03-28 01:45:57 -0400 | [diff] [blame] | 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 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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"); |
srs5694 | a17fe69 | 2011-09-10 20:30:20 -0400 | [diff] [blame] | 152 | AddType(0xaf05, "53746F72-6167-11AA-AA11-00306543ECAC", "Apple Core Storage"); |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 |
srs5694 | 64cbd17 | 2011-03-01 22:03:54 -0500 | [diff] [blame] | 175 | AddType(0xef00, "C12A7328-F81F-11D2-BA4B-00A0C93EC93B", "EFI System"); // Parted identifies these as having the "boot flag" set |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 |
srs5694 | 55d9261 | 2010-03-07 22:16:07 -0500 | [diff] [blame] | 183 | // unknown GUID type code. |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 184 | } // PartType::AddAllTypes() |
| 185 | |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 186 | // Add a single type to the linked list of types. Returns 1 if operation |
srs5694 | e321d44 | 2010-01-29 17:44:04 -0500 | [diff] [blame] | 187 | // succeeds, 0 otherwise. |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 188 | int PartType::AddType(uint16_t mbrType, const char * guidData, const char * name, |
| 189 | int toDisplay) { |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 190 | AType* tempType; |
| 191 | int allOK = 1; |
| 192 | |
| 193 | tempType = new AType; |
| 194 | if (tempType != NULL) { |
| 195 | tempType->MBRType = mbrType; |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 196 | tempType->GUIDType = guidData; |
| 197 | tempType->name = name; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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 { |
srs5694 | 6aae2a9 | 2011-06-10 01:16:51 -0400 | [diff] [blame] | 207 | cerr << "Unable to allocate memory in PartType::AddType()! Partition type list will\n"; |
| 208 | cerr << "be incomplete!\n"; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 209 | allOK = 0; |
| 210 | } // if/else |
| 211 | return allOK; |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 212 | } // GUID::AddType(const char* variant) |
| 213 | |
srs5694 | 82f3f0b | 2010-09-22 10:50:24 -0400 | [diff] [blame] | 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 |
srs5694 | 0873e9d | 2010-10-07 13:00:45 -0400 | [diff] [blame] | 216 | // a direct entry of a GUID value. If a short string isn't a hex |
| 217 | // number, do nothing. |
srs5694 | 82f3f0b | 2010-09-22 10:50:24 -0400 | [diff] [blame] | 218 | PartType & PartType::operator=(const string & orig) { |
| 219 | uint32_t hexCode; |
| 220 | |
| 221 | if (orig.length() < 32) { |
srs5694 | 0873e9d | 2010-10-07 13:00:45 -0400 | [diff] [blame] | 222 | if (IsHex(orig)) { |
| 223 | sscanf(orig.c_str(), "%x", &hexCode); |
| 224 | *this = hexCode; |
srs5694 | a17fe69 | 2011-09-10 20:30:20 -0400 | [diff] [blame] | 225 | } |
srs5694 | 82f3f0b | 2010-09-22 10:50:24 -0400 | [diff] [blame] | 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 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 237 | // Assign a GUID based on my custom 2-byte (16-bit) MBR hex ID variant |
srs5694 | cb76c67 | 2010-02-11 22:22:22 -0500 | [diff] [blame] | 238 | PartType & PartType::operator=(uint16_t ID) { |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 239 | AType* theItem = allTypes; |
| 240 | int found = 0; |
| 241 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 242 | // Now search the type list for a match to the ID.... |
| 243 | while ((theItem != NULL) && (!found)) { |
srs5694 | 55d9261 | 2010-03-07 22:16:07 -0500 | [diff] [blame] | 244 | if (theItem->MBRType == ID) { |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 245 | GUIDData::operator=(theItem->GUIDType); |
| 246 | found = 1; |
| 247 | } else { |
| 248 | theItem = theItem->next; |
| 249 | } // if/else |
| 250 | } // while |
| 251 | if (!found) { |
srs5694 | 55d9261 | 2010-03-07 22:16:07 -0500 | [diff] [blame] | 252 | // Assign a default value.... |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 253 | operator=(DEFAULT_TYPE); |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 254 | cout.setf(ios::uppercase); |
| 255 | cout.fill('0'); |
| 256 | cout << "Exact type match not found for type code "; |
| 257 | cout.width(4); |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 258 | cout << hex << ID << "; assigning type code for\n'" << TypeName() << "'\n" << dec; |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 259 | cout.fill(' '); |
| 260 | } // if (!found) |
| 261 | return *this; |
| 262 | } // PartType::operator=(uint16_t ID) |
| 263 | |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 264 | // Return the English description of the partition type (e.g., "Linux filesystem") |
srs5694 | 5a08175 | 2010-09-24 20:39:41 -0400 | [diff] [blame] | 265 | string PartType::TypeName(void) const { |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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 | |
srs5694 | 00b6d7a | 2011-06-26 22:40:06 -0400 | [diff] [blame] | 284 | // Return the Unicode description of the partition type (e.g., "Linux filesystem") |
srs5694 | 5a60853 | 2011-03-17 13:53:01 -0400 | [diff] [blame] | 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 | |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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. |
srs5694 | 5a08175 | 2010-09-24 20:39:41 -0400 | [diff] [blame] | 309 | uint16_t PartType::GetHexType() const { |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 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() |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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. |
srs5694 | 5a08175 | 2010-09-24 20:39:41 -0400 | [diff] [blame] | 332 | void PartType::ShowAllTypes(void) const { |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 333 | int colCount = 1; // column count |
srs5694 | e321d44 | 2010-01-29 17:44:04 -0500 | [diff] [blame] | 334 | size_t i; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 335 | AType* thisType = allTypes; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 336 | |
srs5694 | fed16d0 | 2010-01-27 23:03:40 -0500 | [diff] [blame] | 337 | cout.unsetf(ios::uppercase); |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 338 | while (thisType != NULL) { |
| 339 | if (thisType->display == 1) { // show it |
srs5694 | fed16d0 | 2010-01-27 23:03:40 -0500 | [diff] [blame] | 340 | cout.fill('0'); |
| 341 | cout.width(4); |
| 342 | cout << hex << thisType->MBRType << " "; |
srs5694 | e321d44 | 2010-01-29 17:44:04 -0500 | [diff] [blame] | 343 | cout << thisType->name.substr(0, 20); |
srs5694 | 55d9261 | 2010-03-07 22:16:07 -0500 | [diff] [blame] | 344 | for (i = 0; i < (20 - (thisType->name.substr(0, 20).length())); i++) |
| 345 | cout << " "; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 346 | if ((colCount % 3) == 0) |
srs5694 | fed16d0 | 2010-01-27 23:03:40 -0500 | [diff] [blame] | 347 | cout << "\n"; |
srs5694 | e321d44 | 2010-01-29 17:44:04 -0500 | [diff] [blame] | 348 | else |
| 349 | cout << " "; |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 350 | colCount++; |
| 351 | } // if |
| 352 | thisType = thisType->next; |
| 353 | } // while |
srs5694 | 0a69731 | 2010-01-28 21:10:52 -0500 | [diff] [blame] | 354 | cout.fill(' '); |
| 355 | cout << "\n" << dec; |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 356 | } // PartType::ShowTypes() |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 357 | |
| 358 | // Returns 1 if code is a valid extended MBR code, 0 if it's not |
srs5694 | 5a08175 | 2010-09-24 20:39:41 -0400 | [diff] [blame] | 359 | int PartType::Valid(uint16_t code) const { |
srs5694 | e7b4ff9 | 2009-08-18 13:16:10 -0400 | [diff] [blame] | 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; |
srs5694 | 6699b01 | 2010-02-04 00:55:30 -0500 | [diff] [blame] | 370 | } // PartType::Valid() |