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-2014 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.
PartType(void)32 PartType::PartType(void) : GUIDData() {
33    numInstances++;
34    if (numInstances == 1) {
35       AddAllTypes();
36    } // if
37 } // default constructor
38 
PartType(const PartType & orig)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 
PartType(const GUIDData & orig)46 PartType::PartType(const GUIDData & orig) : GUIDData(orig) {
47    numInstances++;
48    if (numInstances == 1) {
49       AddAllTypes();
50    } // if
51 } // PartType copy constructor
52 
~PartType(void)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.
AddAllTypes(void)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, most of which are hidden from the "L" listing
76    // (they're available mainly for MBR-to-GPT conversions).
77    AddType(0x0100, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-12
78    AddType(0x0400, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16 < 32M
79    AddType(0x0600, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16
80    AddType(0x0700, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 1); // NTFS (or HPFS)
81    AddType(0x0b00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-32
82    AddType(0x0c00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-32 LBA
83    AddType(0x0c01, "E3C9E316-0B5C-4DB8-817D-F92DF00215AE", "Microsoft reserved");
84    AddType(0x0e00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // FAT-16 LBA
85    AddType(0x1100, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-12
86    AddType(0x1400, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16 < 32M
87    AddType(0x1600, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16
88    AddType(0x1700, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden NTFS (or HPFS)
89    AddType(0x1b00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-32
90    AddType(0x1c00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-32 LBA
91    AddType(0x1e00, "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7", "Microsoft basic data", 0); // Hidden FAT-16 LBA
92    AddType(0x2700, "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC", "Windows RE");
93 
94    // Open Network Install Environment (ONIE) specific types.
95    // See http://www.onie.org/ and
96    // https://github.com/onie/onie/blob/master/rootconf/x86_64/sysroot-lib-onie/onie-blkdev-common
97    AddType(0x3000, "7412F7D5-A156-4B13-81DC-867174929325", "ONIE boot");
98    AddType(0x3001, "D4E6E2CD-4469-46F3-B5CB-1BFF57AFC149", "ONIE config");
99 
100    // PowerPC reference platform boot partition
101    AddType(0x4100, "9E1A2D38-C612-4316-AA26-8B49521E5A8B", "PowerPC PReP boot");
102 
103    // Windows LDM ("dynamic disk") types
104    AddType(0x4200, "AF9B60A0-1431-4F62-BC68-3311714A69AD", "Windows LDM data"); // Logical disk manager
105    AddType(0x4201, "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3", "Windows LDM metadata"); // Logical disk manager
106 
107    // An oddball IBM filesystem....
108    AddType(0x7501, "37AFFC90-EF7D-4E96-91C3-2D7AE055B174", "IBM GPFS"); // General Parallel File System (GPFS)
109 
110    // ChromeOS-specific partition types...
111    // Values taken from vboot_reference/firmware/lib/cgptlib/include/gpt.h in
112    // ChromeOS source code, retrieved 12/23/2010. They're also at
113    // http://www.chromium.org/chromium-os/chromiumos-design-docs/disk-format.
114    // These have no MBR equivalents, AFAIK, so I'm using 0x7Fxx values, since they're close
115    // to the Linux values.
116    AddType(0x7f00, "FE3A2A5D-4F32-41A7-B725-ACCC3285A309", "ChromeOS kernel");
117    AddType(0x7f01, "3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC", "ChromeOS root");
118    AddType(0x7f02, "2E0A753D-9E48-43B0-8337-B15192CB1B5E", "ChromeOS reserved");
119 
120    // Linux-specific partition types....
121    AddType(0x8200, "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F", "Linux swap"); // Linux swap (or Solaris on MBR)
122    AddType(0x8300, "0FC63DAF-8483-4772-8E79-3D69D8477DE4", "Linux filesystem"); // Linux native
123    AddType(0x8301, "8DA63339-0007-60C0-C436-083AC8230908", "Linux reserved");
124    // See http://www.freedesktop.org/software/systemd/man/systemd-gpt-auto-generator.html
125    // and http://www.freedesktop.org/wiki/Specifications/DiscoverablePartitionsSpec/
126    AddType(0x8302, "933AC7E1-2EB4-4F13-B844-0E14E2AEF915", "Linux /home"); // Linux /home (auto-mounted by systemd)
127    AddType(0x8303, "44479540-F297-41B2-9AF7-D131D5F0458A", "Linux x86 root (/)"); // Linux / on x86 (auto-mounted by systemd)
128    AddType(0x8304, "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709", "Linux x86-64 root (/)"); // Linux / on x86-64 (auto-mounted by systemd)
129    AddType(0x8305, "B921B045-1DF0-41C3-AF44-4C6F280D3FAE", "Linux ARM64 root (/)"); // Linux / on 64-bit ARM (auto-mounted by systemd)
130    AddType(0x8306, "3B8F8425-20E0-4F3B-907F-1A25A76F98E8", "Linux /srv"); // Linux /srv (auto-mounted by systemd)
131 
132    // Used by Intel Rapid Start technology
133    AddType(0x8400, "D3BFE2DE-3DAF-11DF-BA40-E3A556D89593", "Intel Rapid Start");
134 
135    // Another Linux type code....
136    AddType(0x8e00, "E6D6D379-F507-44C2-A23C-238F2A3DF928", "Linux LVM");
137 
138    // FreeBSD partition types....
139    // Note: Rather than extract FreeBSD disklabel data, convert FreeBSD
140    // partitions in-place, and let FreeBSD sort out the details....
141    AddType(0xa500, "516E7CB4-6ECF-11D6-8FF8-00022D09712B", "FreeBSD disklabel");
142    AddType(0xa501, "83BD6B9D-7F41-11DC-BE0B-001560B84F0F", "FreeBSD boot");
143    AddType(0xa502, "516E7CB5-6ECF-11D6-8FF8-00022D09712B", "FreeBSD swap");
144    AddType(0xa503, "516E7CB6-6ECF-11D6-8FF8-00022D09712B", "FreeBSD UFS");
145    AddType(0xa504, "516E7CBA-6ECF-11D6-8FF8-00022D09712B", "FreeBSD ZFS");
146    AddType(0xa505, "516E7CB8-6ECF-11D6-8FF8-00022D09712B", "FreeBSD Vinum/RAID");
147 
148    // Midnight BSD partition types....
149    AddType(0xa580, "85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD data");
150    AddType(0xa581, "85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD boot");
151    AddType(0xa582, "85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD swap");
152    AddType(0xa583, "0394Ef8B-237E-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD UFS");
153    AddType(0xa584, "85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD ZFS");
154    AddType(0xa585, "85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7", "Midnight BSD Vinum");
155 
156    // A MacOS partition type, separated from others by NetBSD partition types...
157    AddType(0xa800, "55465300-0000-11AA-AA11-00306543ECAC", "Apple UFS"); // Mac OS X
158 
159    // NetBSD partition types. Note that the main entry sets it up as a
160    // FreeBSD disklabel. I'm not 100% certain this is the correct behavior.
161    AddType(0xa900, "516E7CB4-6ECF-11D6-8FF8-00022D09712B", "FreeBSD disklabel", 0); // NetBSD disklabel
162    AddType(0xa901, "49F48D32-B10E-11DC-B99B-0019D1879648", "NetBSD swap");
163    AddType(0xa902, "49F48D5A-B10E-11DC-B99B-0019D1879648", "NetBSD FFS");
164    AddType(0xa903, "49F48D82-B10E-11DC-B99B-0019D1879648", "NetBSD LFS");
165    AddType(0xa904, "2DB519C4-B10F-11DC-B99B-0019D1879648", "NetBSD concatenated");
166    AddType(0xa905, "2DB519EC-B10F-11DC-B99B-0019D1879648", "NetBSD encrypted");
167    AddType(0xa906, "49F48DAA-B10E-11DC-B99B-0019D1879648", "NetBSD RAID");
168 
169    // Mac OS partition types (See also 0xa800, above)....
170    AddType(0xab00, "426F6F74-0000-11AA-AA11-00306543ECAC", "Apple boot");
171    AddType(0xaf00, "48465300-0000-11AA-AA11-00306543ECAC", "Apple HFS/HFS+");
172    AddType(0xaf01, "52414944-0000-11AA-AA11-00306543ECAC", "Apple RAID");
173    AddType(0xaf02, "52414944-5F4F-11AA-AA11-00306543ECAC", "Apple RAID offline");
174    AddType(0xaf03, "4C616265-6C00-11AA-AA11-00306543ECAC", "Apple label");
175    AddType(0xaf04, "5265636F-7665-11AA-AA11-00306543ECAC", "AppleTV recovery");
176    AddType(0xaf05, "53746F72-6167-11AA-AA11-00306543ECAC", "Apple Core Storage");
177 
178    // Solaris partition types (one of which is shared with MacOS)
179    AddType(0xbe00, "6A82CB45-1DD2-11B2-99A6-080020736631", "Solaris boot");
180    AddType(0xbf00, "6A85CF4D-1DD2-11B2-99A6-080020736631", "Solaris root");
181    AddType(0xbf01, "6A898CC3-1DD2-11B2-99A6-080020736631", "Solaris /usr & Mac ZFS"); // Solaris/MacOS
182    AddType(0xbf02, "6A87C46F-1DD2-11B2-99A6-080020736631", "Solaris swap");
183    AddType(0xbf03, "6A8B642B-1DD2-11B2-99A6-080020736631", "Solaris backup");
184    AddType(0xbf04, "6A8EF2E9-1DD2-11B2-99A6-080020736631", "Solaris /var");
185    AddType(0xbf05, "6A90BA39-1DD2-11B2-99A6-080020736631", "Solaris /home");
186    AddType(0xbf06, "6A9283A5-1DD2-11B2-99A6-080020736631", "Solaris alternate sector");
187    AddType(0xbf07, "6A945A3B-1DD2-11B2-99A6-080020736631", "Solaris Reserved 1");
188    AddType(0xbf08, "6A9630D1-1DD2-11B2-99A6-080020736631", "Solaris Reserved 2");
189    AddType(0xbf09, "6A980767-1DD2-11B2-99A6-080020736631", "Solaris Reserved 3");
190    AddType(0xbf0a, "6A96237F-1DD2-11B2-99A6-080020736631", "Solaris Reserved 4");
191    AddType(0xbf0b, "6A8D2AC7-1DD2-11B2-99A6-080020736631", "Solaris Reserved 5");
192 
193    // I can find no MBR equivalents for these, but they're on the
194    // Wikipedia page for GPT, so here we go....
195    AddType(0xc001, "75894C1E-3AEB-11D3-B7C1-7B03A0000000", "HP-UX data");
196    AddType(0xc002, "E2A1E728-32E3-11D6-A682-7B03A0000000", "HP-UX service");
197 
198    // See http://www.freedesktop.org/wiki/Specifications/BootLoaderSpec
199    AddType(0xea00, "BC13C2FF-59E6-4262-A352-B275FD6F7172", "Freedesktop $BOOT");
200 
201    // Type code for Haiku; uses BeOS MBR code as hex code base
202    AddType(0xeb00, "42465331-3BA3-10F1-802A-4861696B7521", "Haiku BFS");
203 
204    // Manufacturer-specific ESP-like partitions (in order in which they were added)
205    AddType(0xed00, "F4019732-066E-4E12-8273-346C5641494F", "Sony system partition");
206    AddType(0xed01, "BFBFAFE7-A34F-448A-9A5B-6213EB736C22", "Lenovo system partition");
207 
208    // EFI system and related partitions
209    AddType(0xef00, "C12A7328-F81F-11D2-BA4B-00A0C93EC93B", "EFI System"); // Parted identifies these as having the "boot flag" set
210    AddType(0xef01, "024DEE41-33E7-11D3-9D69-0008C781F39F", "MBR partition scheme"); // Used to nest MBR in GPT
211    AddType(0xef02, "21686148-6449-6E6F-744E-656564454649", "BIOS boot partition"); // Used by GRUB
212 
213    // Ceph type codes; see https://github.com/ceph/ceph/blob/9bcc42a3e6b08521694b5c0228b2c6ed7b3d312e/src/ceph-disk#L76-L81
214    AddType(0xf800, "4FBD7E29-9D25-41B8-AFD0-062C0CEFF05D", "Ceph OSD"); // Ceph Object Storage Daemon
215    AddType(0xf801, "4FBD7E29-9D25-41B8-AFD0-5EC00CEFF05D", "Ceph dm-crypt OSD"); // Ceph Object Storage Daemon (encrypted)
216    AddType(0xf802, "BFBFAFE7-A34F-448A-9A5B-6213EB736C22", "Ceph journal");
217    AddType(0xf803, "45B0969E-9B03-4F30-B4C6-5EC00CEFF106", "Ceph dm-crypt journal");
218    AddType(0xf804, "89C57F98-2FE5-4DC0-89C1-F3AD0CEFF2BE", "Ceph disk in creation");
219    AddType(0xf805, "89C57F98-2FE5-4DC0-89C1-5EC00CEFF2BE", "Ceph dm-crypt disk in creation");
220 
221    // VMWare ESX partition types codes
222    AddType(0xfb00, "AA31E02A-400F-11DB-9590-000C2911D1B8", "VMWare VMFS");
223    AddType(0xfb01, "9198EFFC-31C0-11DB-8F78-000C2911D1B8", "VMWare reserved");
224    AddType(0xfc00, "9D275380-40AD-11DB-BF97-000C2911D1B8", "VMWare kcore crash protection");
225 
226    // A straggler Linux partition type....
227    AddType(0xfd00, "A19D880F-05FC-4D3B-A006-743F0F84911E", "Linux RAID");
228 
229    // Note: DO NOT use the 0xffff code; that's reserved to indicate an
230    // unknown GUID type code.
231 } // PartType::AddAllTypes()
232 
233 // Add a single type to the linked list of types. Returns 1 if operation
234 // succeeds, 0 otherwise.
AddType(uint16_t mbrType,const char * guidData,const char * name,int toDisplay)235 int PartType::AddType(uint16_t mbrType, const char * guidData, const char * name,
236                       int toDisplay) {
237    AType* tempType;
238    int allOK = 1;
239 
240    tempType = new AType;
241    if (tempType != NULL) {
242       tempType->MBRType = mbrType;
243       tempType->GUIDType = guidData;
244       tempType->name = name;
245       tempType->display = toDisplay;
246       tempType->next = NULL;
247       if (allTypes == NULL) { // first entry
248          allTypes = tempType;
249       } else {
250          lastType->next = tempType;
251       } // if/else
252       lastType = tempType;
253    } else {
254       cerr << "Unable to allocate memory in PartType::AddType()! Partition type list will\n";
255       cerr << "be incomplete!\n";
256       allOK = 0;
257    } // if/else
258    return allOK;
259 } // GUID::AddType(const char* variant)
260 
261 // Assignment operator by string. If the original string is short,
262 // interpret it as a gdisk hex code; if it's longer, interpret it as
263 // a direct entry of a GUID value. If a short string isn't a hex
264 // number, do nothing.
operator =(const string & orig)265 PartType & PartType::operator=(const string & orig) {
266    uint32_t hexCode;
267 
268    if (orig.length() < 32) {
269       if (IsHex(orig)) {
270          sscanf(orig.c_str(), "%x", &hexCode);
271          *this = hexCode;
272       }
273    } else {
274       GUIDData::operator=(orig);
275    } // if/else hexCode or GUID
276    return *this;
277 } // PartType::operator=(const char * orig)
278 
279 // Assignment from C-style string; rely on C++ casting....
operator =(const char * orig)280 PartType & PartType::operator=(const char * orig) {
281    return operator=((string) orig);
282 } // PartType::operator=(const char * orig)
283 
284 // Assign a GUID based on my custom 2-byte (16-bit) MBR hex ID variant
operator =(uint16_t ID)285 PartType & PartType::operator=(uint16_t ID) {
286    AType* theItem = allTypes;
287    int found = 0;
288 
289    // Now search the type list for a match to the ID....
290    while ((theItem != NULL) && (!found)) {
291       if (theItem->MBRType == ID)  {
292          GUIDData::operator=(theItem->GUIDType);
293          found = 1;
294       } else {
295          theItem = theItem->next;
296       } // if/else
297    } // while
298    if (!found) {
299       // Assign a default value....
300       operator=(DEFAULT_GPT_TYPE);
301       cout.setf(ios::uppercase);
302       cout.fill('0');
303       cout << "Exact type match not found for type code ";
304       cout.width(4);
305       cout << hex << ID << "; assigning type code for\n'" << TypeName() << "'\n" << dec;
306       cout.fill(' ');
307    } // if (!found)
308    return *this;
309 } // PartType::operator=(uint16_t ID)
310 
311 // Return the English description of the partition type (e.g., "Linux filesystem")
TypeName(void) const312 string PartType::TypeName(void) const {
313    AType* theItem = allTypes;
314    int found = 0;
315    string typeName;
316 
317    while ((theItem != NULL) && (!found)) {
318       if (theItem->GUIDType == *this) { // found it!
319          typeName = theItem->name;
320          found = 1;
321       } else {
322          theItem = theItem->next;
323       } // if/else
324    } // while
325    if (!found) {
326       typeName = "Unknown";
327    } // if (!found)
328    return typeName;
329 } // PartType::TypeName()
330 
331 #ifdef USE_UTF16
332 // Return the Unicode description of the partition type (e.g., "Linux filesystem")
UTypeName(void) const333 UnicodeString PartType::UTypeName(void) const {
334    AType* theItem = allTypes;
335    int found = 0;
336    UnicodeString typeName;
337 
338    while ((theItem != NULL) && (!found)) {
339       if (theItem->GUIDType == *this) { // found it!
340          typeName = theItem->name.c_str();
341          found = 1;
342       } else {
343          theItem = theItem->next;
344       } // if/else
345    } // while
346    if (!found) {
347       typeName = "Unknown";
348    } // if (!found)
349    return typeName;
350 } // PartType::TypeName()
351 #endif
352 
353 // Return the custom GPT fdisk 2-byte (16-bit) hex code for this GUID partition type
354 // Note that this function ignores entries for which the display variable
355 // is set to 0. This enables control of which values get returned when
356 // there are multiple possibilities, but opens the algorithm up to the
357 // potential for problems should the data in the list be bad.
GetHexType() const358 uint16_t PartType::GetHexType() const {
359    AType* theItem = allTypes;
360    int found = 0;
361    uint16_t theID = 0xFFFF;
362 
363    while ((theItem != NULL) && (!found)) {
364       if ((theItem->GUIDType == *this) && (theItem->display == 1)) { // found it!
365          theID = theItem->MBRType;
366          found = 1;
367       } else {
368          theItem = theItem->next;
369       } // if/else
370    } // while
371    if (!found) {
372       theID = 0xFFFF;
373    } // if (!found)
374    return theID;
375 } // PartType::GetHex()
376 
377 // Displays the available types and my extended MBR codes for same....
378 // Note: This function assumes an 80-column display. On wider displays,
379 // it stops at under 80 columns; on narrower displays, lines will wrap
380 // in an ugly way. The maxLines value is the maximum number of lines
381 // to display before prompting to continue, or 0 (or a negative value)
382 // for no limit.
ShowAllTypes(int maxLines) const383 void PartType::ShowAllTypes(int maxLines) const {
384    int colCount = 1, lineCount = 1;
385    size_t i;
386    AType* thisType = allTypes;
387    string line;
388 
389    cout.unsetf(ios::uppercase);
390    while (thisType != NULL) {
391       if (thisType->display == 1) { // show it
392          cout.fill('0');
393          cout.width(4);
394          cout << hex << thisType->MBRType << " ";
395          cout << thisType->name.substr(0, 20);
396          for (i = 0; i < (20 - (thisType->name.substr(0, 20).length())); i++)
397             cout << " ";
398          if ((colCount % 3) == 0) {
399             if (thisType->next) {
400                cout << "\n";
401                if ((maxLines > 0) && (lineCount++ % maxLines) == 0) {
402                   cout << "Press the <Enter> key to see more codes: ";
403                   getline(cin, line);
404                } // if reached screen line limit
405             } // if there's another entry following this one
406          } else {
407             cout << "  ";
408          }
409          colCount++;
410       } // if
411       thisType = thisType->next;
412    } // while
413    cout.fill(' ');
414    cout << "\n" << dec;
415 } // PartType::ShowAllTypes(int maxLines)
416 
417 // Returns 1 if code is a valid extended MBR code, 0 if it's not
Valid(uint16_t code) const418 int PartType::Valid(uint16_t code) const {
419    AType* thisType = allTypes;
420    int found = 0;
421 
422    while ((thisType != NULL) && (!found)) {
423       if (thisType->MBRType == code) {
424          found = 1;
425       } // if
426       thisType = thisType->next;
427    } // while
428    return found;
429 } // PartType::Valid()
430