blob: 2d609d65bea7d8172c8640ce3dd01802180a1249 [file] [log] [blame]
srs5694a0eb11a2009-08-29 15:00:08 -04001//
2// C++ Implementation: gptpart
3//
4// Description: Class to implement a SINGLE GPT partition
5//
6//
Roderick W. Smithe3ee7332013-09-24 12:56:11 -04007// Author: Rod Smith <rodsmith@rodsbooks.com>, (C) 2009-2013
srs5694a0eb11a2009-08-29 15:00:08 -04008//
9// Copyright: See COPYING file that comes with this distribution
10//
11//
srs5694978041c2009-09-21 20:51:47 -040012// This program is copyright (c) 2009 by Roderick W. Smith. It is distributed
13// under the terms of the GNU GPL version 2, as detailed in the COPYING file.
srs5694a0eb11a2009-08-29 15:00:08 -040014
15#define __STDC_LIMIT_MACROS
16#define __STDC_CONSTANT_MACROS
17
srs569400b6d7a2011-06-26 22:40:06 -040018#ifdef USE_UTF16
srs5694699941e2011-03-21 21:33:57 -040019#include <unicode/ustdio.h>
20#else
21#define UnicodeString string
22#endif
23
srs5694a0eb11a2009-08-29 15:00:08 -040024#include <string.h>
srs5694fed16d02010-01-27 23:03:40 -050025#include <stdio.h>
26#include <iostream>
srs5694a0eb11a2009-08-29 15:00:08 -040027#include "gptpart.h"
28#include "attributes.h"
29
30using namespace std;
31
srs5694a0eb11a2009-08-29 15:00:08 -040032GPTPart::GPTPart(void) {
srs569455d92612010-03-07 22:16:07 -050033 partitionType.Zero();
34 uniqueGUID.Zero();
35 firstLBA = 0;
36 lastLBA = 0;
37 attributes = 0;
srs569464cbd172011-03-01 22:03:54 -050038 memset(name, 0, NAME_SIZE);
srs5694a0eb11a2009-08-29 15:00:08 -040039} // Default constructor
40
41GPTPart::~GPTPart(void) {
42} // destructor
43
srs5694a0eb11a2009-08-29 15:00:08 -040044// Return the gdisk-specific two-byte hex code for the partition
srs5694bf8950c2011-03-12 01:23:12 -050045uint16_t GPTPart::GetHexType(void) const {
srs56946699b012010-02-04 00:55:30 -050046 return partitionType.GetHexType();
srs5694a0eb11a2009-08-29 15:00:08 -040047} // GPTPart::GetHexType()
48
49// Return a plain-text description of the partition type (e.g., "Linux/Windows
50// data" or "Linux swap").
srs56946699b012010-02-04 00:55:30 -050051string GPTPart::GetTypeName(void) {
52 return partitionType.TypeName();
srs5694a0eb11a2009-08-29 15:00:08 -040053} // GPTPart::GetNameType()
54
srs56945a608532011-03-17 13:53:01 -040055// Return a Unicode description of the partition type (e.g., "Linux/Windows
56// data" or "Linux swap").
57UnicodeString GPTPart::GetUTypeName(void) {
58 return partitionType.UTypeName();
srs56945a608532011-03-17 13:53:01 -040059} // GPTPart::GetNameType()
60
srs5694a0eb11a2009-08-29 15:00:08 -040061// Compute and return the partition's length (or 0 if the end is incorrectly
62// set before the beginning).
srs5694bf8950c2011-03-12 01:23:12 -050063uint64_t GPTPart::GetLengthLBA(void) const {
srs5694a0eb11a2009-08-29 15:00:08 -040064 uint64_t length = 0;
srs569455d92612010-03-07 22:16:07 -050065
srs5694a0eb11a2009-08-29 15:00:08 -040066 if (firstLBA <= lastLBA)
67 length = lastLBA - firstLBA + UINT64_C(1);
68 return length;
69} // GPTPart::GetLengthLBA()
70
srs569400b6d7a2011-06-26 22:40:06 -040071#ifdef USE_UTF16
srs5694699941e2011-03-21 21:33:57 -040072// Return partition's name field, converted to a Unicode string
73UnicodeString GPTPart::GetDescription(void) {
74 return (UChar*) name;
75} // GPTPart::GetDescription()
76#else
77// Return partition's name field, converted to a C++ ASCII string
srs56946699b012010-02-04 00:55:30 -050078string GPTPart::GetDescription(void) {
srs56940a697312010-01-28 21:10:52 -050079 string theName;
srs569400b6d7a2011-06-26 22:40:06 -040080 int i = 0;
srs5694a0eb11a2009-08-29 15:00:08 -040081
srs56940a697312010-01-28 21:10:52 -050082 theName = "";
srs569400b6d7a2011-06-26 22:40:06 -040083 while ((i < NAME_SIZE) && (name[i] != '\0')) {
84 theName += name[i];
85 i+=2;
86 } // while
srs56940a697312010-01-28 21:10:52 -050087 return theName;
srs5694699941e2011-03-21 21:33:57 -040088} // GPTPart::GetDescription() (Windows version)
89#endif
srs56940a697312010-01-28 21:10:52 -050090
srs569408bb0da2010-02-19 17:19:55 -050091// Return 1 if the partition is in use
92int GPTPart::IsUsed(void) {
srs5694e69e6802012-01-20 22:37:12 -050093 return (partitionType != GUIDData("0x00"));
srs569408bb0da2010-02-19 17:19:55 -050094} // GPTPart::IsUsed()
95
srs56940a697312010-01-28 21:10:52 -050096// Set the type code to the specified one. Also changes the partition
97// name *IF* the current name is the generic one for the current partition
98// type.
srs56946699b012010-02-04 00:55:30 -050099void GPTPart::SetType(PartType t) {
srs56945a608532011-03-17 13:53:01 -0400100 if (GetDescription() == partitionType.UTypeName()) {
srs56946699b012010-02-04 00:55:30 -0500101 SetName(t.TypeName());
srs56940a697312010-01-28 21:10:52 -0500102 } // if
103 partitionType = t;
104} // GPTPart::SetType()
srs5694a0eb11a2009-08-29 15:00:08 -0400105
srs569400b6d7a2011-06-26 22:40:06 -0400106#ifdef USE_UTF16
srs5694699941e2011-03-21 21:33:57 -0400107// Set the name for a partition to theName, using a C++-style string as
108// input.
109void GPTPart::SetName(const string & theName) {
110 SetName((UnicodeString) theName.c_str());
srs56945a608532011-03-17 13:53:01 -0400111} // GPTPart::SetName()
112
srs5694699941e2011-03-21 21:33:57 -0400113// Set the name for a partition to theName, using a Unicode string as
114// input.
115void GPTPart::SetName(const UnicodeString & theName) {
116 if (theName.isBogus()) {
117 cerr << "Bogus UTF-16 name found in GPTPart::SetName()! Name not changed!\n";
118 } else {
119 memset(name, 0, NAME_SIZE);
120 theName.extractBetween(0, NAME_SIZE / 2 - 1, (UChar*) name);
121 } // if/else
srs5694a0eb11a2009-08-29 15:00:08 -0400122} // GPTPart::SetName()
srs569400b6d7a2011-06-26 22:40:06 -0400123
srs5694699941e2011-03-21 21:33:57 -0400124#else
srs569400b6d7a2011-06-26 22:40:06 -0400125
srs5694699941e2011-03-21 21:33:57 -0400126// Set the name for a partition to theName. Note that theName is a
127// standard C++-style ASCII string, although the GUID partition definition
128// requires a UTF-16LE string. This function creates a simple-minded copy
129// for this.
130void GPTPart::SetName(const string & theName) {
131 int i, length;
132
133 if (theName.length() < (NAME_SIZE / 2))
134 length = theName.length();
135 else
136 length = NAME_SIZE / 2;
137 memset(name, 0, NAME_SIZE);
138 for (i = 0; i < length; i++)
139 name[i * 2] = theName[i];
srs5694d8eed462012-12-15 01:55:21 -0500140} // GPTPart::SetName(), ASCII version
srs5694699941e2011-03-21 21:33:57 -0400141#endif
srs5694a0eb11a2009-08-29 15:00:08 -0400142
srs56946699b012010-02-04 00:55:30 -0500143// Set the name for the partition based on the current GUID partition type
144// code's associated name
145void GPTPart::SetDefaultDescription(void) {
146 SetName(partitionType.TypeName());
147} // GPTPart::SetDefaultDescription()
148
srs56940a697312010-01-28 21:10:52 -0500149GPTPart & GPTPart::operator=(const GPTPart & orig) {
srs56940a697312010-01-28 21:10:52 -0500150 partitionType = orig.partitionType;
151 uniqueGUID = orig.uniqueGUID;
152 firstLBA = orig.firstLBA;
153 lastLBA = orig.lastLBA;
154 attributes = orig.attributes;
srs569464cbd172011-03-01 22:03:54 -0500155 memcpy(name, orig.name, NAME_SIZE);
srs56940a697312010-01-28 21:10:52 -0500156 return *this;
157} // assignment operator
158
srs56949a46b042011-03-15 00:34:10 -0400159// Compare the values, and return a bool result.
160// Because this is intended for sorting and a firstLBA value of 0 denotes
161// a partition that's not in use and so that should be sorted upwards,
162// we return the opposite of the usual arithmetic result when either
163// firstLBA value is 0.
164bool GPTPart::operator<(const GPTPart &other) const {
srs56949a46b042011-03-15 00:34:10 -0400165 if (firstLBA && other.firstLBA)
166 return (firstLBA < other.firstLBA);
167 else
168 return (other.firstLBA < firstLBA);
169} // GPTPart::operator<()
170
srs56940a697312010-01-28 21:10:52 -0500171// Display summary information; does nothing if the partition is empty.
172void GPTPart::ShowSummary(int partNum, uint32_t blockSize) {
srs569401f7f082011-03-15 23:53:31 -0400173 string sizeInIeee;
srs56945a608532011-03-17 13:53:01 -0400174 UnicodeString description;
srs569464cbd172011-03-01 22:03:54 -0500175 size_t i;
srs56940a697312010-01-28 21:10:52 -0500176
177 if (firstLBA != 0) {
srs569401f7f082011-03-15 23:53:31 -0400178 sizeInIeee = BytesToIeee(lastLBA - firstLBA + 1, blockSize);
srs569408bb0da2010-02-19 17:19:55 -0500179 cout.fill(' ');
srs56940a697312010-01-28 21:10:52 -0500180 cout.width(4);
181 cout << partNum + 1 << " ";
182 cout.width(14);
183 cout << firstLBA << " ";
184 cout.width(14);
185 cout << lastLBA << " ";
srs569401f7f082011-03-15 23:53:31 -0400186 cout << BytesToIeee(lastLBA - firstLBA + 1, blockSize) << " ";
187 if (sizeInIeee.length() < 10)
188 for (i = 0; i < 10 - sizeInIeee.length(); i++)
189 cout << " ";
srs56940a697312010-01-28 21:10:52 -0500190 cout.fill('0');
191 cout.width(4);
192 cout.setf(ios::uppercase);
srs56946699b012010-02-04 00:55:30 -0500193 cout << hex << partitionType.GetHexType() << " " << dec;
srs56940a697312010-01-28 21:10:52 -0500194 cout.fill(' ');
srs569400b6d7a2011-06-26 22:40:06 -0400195#ifdef USE_UTF16
srs5694699941e2011-03-21 21:33:57 -0400196 GetDescription().extractBetween(0, 23, description);
srs56945a608532011-03-17 13:53:01 -0400197 cout << description << "\n";
srs5694699941e2011-03-21 21:33:57 -0400198#else
199 cout << GetDescription().substr(0, 23) << "\n";
200#endif
srs56940a697312010-01-28 21:10:52 -0500201 cout.fill(' ');
202 } // if
203} // GPTPart::ShowSummary()
204
205// Show detailed partition information. Does nothing if the partition is
206// empty (as determined by firstLBA being 0).
207void GPTPart::ShowDetails(uint32_t blockSize) {
208 uint64_t size;
209
210 if (firstLBA != 0) {
srs56945a081752010-09-24 20:39:41 -0400211 cout << "Partition GUID code: " << partitionType;
srs56946699b012010-02-04 00:55:30 -0500212 cout << " (" << partitionType.TypeName() << ")\n";
srs56945a081752010-09-24 20:39:41 -0400213 cout << "Partition unique GUID: " << uniqueGUID << "\n";
srs56940a697312010-01-28 21:10:52 -0500214
215 cout << "First sector: " << firstLBA << " (at "
Roderick W. Smithaf39cb42013-08-06 15:23:46 -0400216 << BytesToIeee(firstLBA, blockSize) << ")\n";
srs56940a697312010-01-28 21:10:52 -0500217 cout << "Last sector: " << lastLBA << " (at "
Roderick W. Smithaf39cb42013-08-06 15:23:46 -0400218 << BytesToIeee(lastLBA, blockSize) << ")\n";
srs56940a697312010-01-28 21:10:52 -0500219 size = (lastLBA - firstLBA + 1);
220 cout << "Partition size: " << size << " sectors ("
Roderick W. Smithaf39cb42013-08-06 15:23:46 -0400221 << BytesToIeee(size, blockSize) << ")\n";
srs56940a697312010-01-28 21:10:52 -0500222 cout << "Attribute flags: ";
223 cout.fill('0');
224 cout.width(16);
225 cout << hex;
226 cout << attributes << "\n";
227 cout << dec;
srs5694699941e2011-03-21 21:33:57 -0400228 cout << "Partition name: '" << GetDescription() << "'\n";
srs56940a697312010-01-28 21:10:52 -0500229 cout.fill(' ');
230 } // if
231} // GPTPart::ShowDetails()
232
233// Blank (delete) a single partition
234void GPTPart::BlankPartition(void) {
srs56946699b012010-02-04 00:55:30 -0500235 uniqueGUID.Zero();
236 partitionType.Zero();
srs56940a697312010-01-28 21:10:52 -0500237 firstLBA = 0;
238 lastLBA = 0;
239 attributes = 0;
srs569464cbd172011-03-01 22:03:54 -0500240 memset(name, 0, NAME_SIZE);
srs56940a697312010-01-28 21:10:52 -0500241} // GPTPart::BlankPartition
242
243// Returns 1 if the two partitions overlap, 0 if they don't
244int GPTPart::DoTheyOverlap(const GPTPart & other) {
srs56940a697312010-01-28 21:10:52 -0500245 // Don't bother checking unless these are defined (both start and end points
246 // are 0 for undefined partitions, so just check the start points)
srs569464cbd172011-03-01 22:03:54 -0500247 return firstLBA && other.firstLBA &&
248 (firstLBA <= other.lastLBA) != (lastLBA < other.firstLBA);
srs56940a697312010-01-28 21:10:52 -0500249} // GPTPart::DoTheyOverlap()
250
srs56945a608532011-03-17 13:53:01 -0400251// Reverse the bytes of integral data types and of the UTF-16LE name;
252// used on big-endian systems.
srs56940a697312010-01-28 21:10:52 -0500253void GPTPart::ReversePartBytes(void) {
srs56945a608532011-03-17 13:53:01 -0400254 int i;
255
srs56940a697312010-01-28 21:10:52 -0500256 ReverseBytes(&firstLBA, 8);
257 ReverseBytes(&lastLBA, 8);
258 ReverseBytes(&attributes, 8);
srs56945a608532011-03-17 13:53:01 -0400259 for (i = 0; i < NAME_SIZE; i += 2)
260 ReverseBytes(name + i, 2);
srs56940a697312010-01-28 21:10:52 -0500261} // GPTPart::ReverseBytes()
262
263/****************************************
264 * Functions requiring user interaction *
265 ****************************************/
266
srs56946699b012010-02-04 00:55:30 -0500267// Change the type code on the partition. Also changes the name if the original
268// name is the generic one for the partition type.
srs56940a697312010-01-28 21:10:52 -0500269void GPTPart::ChangeType(void) {
srs56945a608532011-03-17 13:53:01 -0400270 string line;
srs569464cbd172011-03-01 22:03:54 -0500271 int changeName;
srs569482f3f0b2010-09-22 10:50:24 -0400272 PartType tempType = (GUIDData) "00000000-0000-0000-0000-000000000000";
srs56940a697312010-01-28 21:10:52 -0500273
srs56945a608532011-03-17 13:53:01 -0400274 changeName = (GetDescription() == GetUTypeName());
srs569455d92612010-03-07 22:16:07 -0500275
srs56946699b012010-02-04 00:55:30 -0500276 cout << "Current type is '" << GetTypeName() << "'\n";
srs569482f3f0b2010-09-22 10:50:24 -0400277 do {
srs56940741fa22013-01-09 12:55:40 -0500278 cout << "Hex code or GUID (L to show codes, Enter = " << hex << DEFAULT_GPT_TYPE << dec << "): ";
srs56945a608532011-03-17 13:53:01 -0400279 line = ReadString();
srs569482f3f0b2010-09-22 10:50:24 -0400280 if ((line[0] == 'L') || (line[0] == 'l')) {
srs56946699b012010-02-04 00:55:30 -0500281 partitionType.ShowAllTypes();
srs569482f3f0b2010-09-22 10:50:24 -0400282 } else {
srs56945a608532011-03-17 13:53:01 -0400283 if (line.length() == 0)
srs56940741fa22013-01-09 12:55:40 -0500284 tempType = DEFAULT_GPT_TYPE;
srs569482f3f0b2010-09-22 10:50:24 -0400285 else
286 tempType = line;
287 } // if/else
288 } while (tempType == (GUIDData) "00000000-0000-0000-0000-000000000000");
289 partitionType = tempType;
srs56946699b012010-02-04 00:55:30 -0500290 cout << "Changed type of partition to '" << partitionType.TypeName() << "'\n";
291 if (changeName) {
292 SetDefaultDescription();
293 } // if
srs56940a697312010-01-28 21:10:52 -0500294} // GPTPart::ChangeType()