1 //
2 // C++ Implementation: gptpart
3 //
4 // Description: Class to implement a SINGLE GPT partition
5 //
6 //
7 // Author: Rod Smith <rodsmith@rodsbooks.com>, (C) 2009-2013
8 //
9 // Copyright: See COPYING file that comes with this distribution
10 //
11 //
12 // 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.
14
15 #define __STDC_LIMIT_MACROS
16 #define __STDC_CONSTANT_MACROS
17
18 #ifdef USE_UTF16
19 #include <unicode/ustdio.h>
20 #else
21 #define UnicodeString string
22 #endif
23
24 #include <string.h>
25 #include <stdio.h>
26 #include <iostream>
27 #include "gptpart.h"
28 #include "attributes.h"
29
30 using namespace std;
31
GPTPart(void)32 GPTPart::GPTPart(void) {
33 partitionType.Zero();
34 uniqueGUID.Zero();
35 firstLBA = 0;
36 lastLBA = 0;
37 attributes = 0;
38 memset(name, 0, NAME_SIZE * sizeof(name[0]) );
39 } // Default constructor
40
~GPTPart(void)41 GPTPart::~GPTPart(void) {
42 } // destructor
43
44 // Return the gdisk-specific two-byte hex code for the partition
GetHexType(void) const45 uint16_t GPTPart::GetHexType(void) const {
46 return partitionType.GetHexType();
47 } // GPTPart::GetHexType()
48
49 // Return a plain-text description of the partition type (e.g., "Linux/Windows
50 // data" or "Linux swap").
GetTypeName(void)51 string GPTPart::GetTypeName(void) {
52 return partitionType.TypeName();
53 } // GPTPart::GetNameType()
54
55 #ifdef USE_UTF16
56 // Return a Unicode description of the partition type (e.g., "Linux/Windows
57 // data" or "Linux swap").
GetUTypeName(void)58 UnicodeString GPTPart::GetUTypeName(void) {
59 return partitionType.UTypeName();
60 } // GPTPart::GetNameType()
61 #endif
62
63 // Compute and return the partition's length (or 0 if the end is incorrectly
64 // set before the beginning).
GetLengthLBA(void) const65 uint64_t GPTPart::GetLengthLBA(void) const {
66 uint64_t length = 0;
67
68 if (firstLBA <= lastLBA)
69 length = lastLBA - firstLBA + UINT64_C(1);
70 return length;
71 } // GPTPart::GetLengthLBA()
72
73 #ifdef USE_UTF16
74 // Return partition's name field, converted to a Unicode string
GetDescription(void)75 UnicodeString GPTPart::GetDescription(void) {
76 return (UChar*) name;
77 } // GPTPart::GetDescription()
78 #else
79 // Return partition's name field, converted to a C++ UTF-8 string
GetDescription(void)80 string GPTPart::GetDescription(void) {
81 // convert name to utf32 then to utf8
82 string utf8 ;
83 size_t pos = 0 ;
84 while ( ( pos < NAME_SIZE ) && ( name[ pos ] != 0 ) ) {
85 uint16_t cp = name[ pos ++ ] ;
86 if ( ! IsLittleEndian() ) ReverseBytes( & cp , 2 ) ;
87 // first to utf32
88 uint32_t uni ;
89 if ( cp < 0xd800 || cp > 0xdfff ) {
90 uni = cp ;
91 } // if
92 else if ( cp < 0xdc00 ) {
93 // lead surrogate
94 uni = ( (uint32_t)( cp & 0x3ff ) ) << 10 ;
95 if ( pos >= NAME_SIZE ) {
96 // missing trail surrogate, name[] is invalid
97 break ;
98 } // if
99 cp = name[ pos ++ ] ;
100 if ( cp < 0xdc00 || cp > 0xdfff ) {
101 // invalid trail surrogate, name[] is invalid
102 break ;
103 } // if
104 // trail surrogate
105 uni |= cp & 0x3ff ;
106 uni += 0x10000 ;
107 } // if
108 else {
109 // unexpected trail surrogate, name[] is invalid
110 break ;
111 } // if
112 // then to utf8
113 if ( uni < 0x80 ) {
114 utf8 += (char) uni ;
115 } // if
116 else if ( uni < 0x800 ) {
117 utf8 += (char) ( 0xc0 | ( uni >> 6 ) ) ;
118 utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ;
119 } // if
120 else if ( uni < 0x10000 ) {
121 utf8 += (char) ( 0xe0 | ( uni >> 12 ) ) ;
122 utf8 += (char) ( 0x80 | ( ( uni >> 6 ) & 0x3f ) ) ;
123 utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ;
124 } // if
125 else {
126 utf8 += (char) ( 0xf0 | ( uni >> 18 ) ) ;
127 utf8 += (char) ( 0xe0 | ( ( uni >> 12 ) & 0x3f ) ) ;
128 utf8 += (char) ( 0x80 | ( ( uni >> 6 ) & 0x3f ) ) ;
129 utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ;
130 } // if
131 }
132 return utf8 ;
133 } // GPTPart::GetDescription(), UTF-8 version
134 #endif
135
136 // Return 1 if the partition is in use
IsUsed(void)137 int GPTPart::IsUsed(void) {
138 return (partitionType != GUIDData("0x00"));
139 } // GPTPart::IsUsed()
140
141 // Returns MBR_SIZED_GOOD, MBR_SIZED_IFFY, or MBR_SIZED_BAD; see comments
142 // in header file for details.
IsSizedForMBR(void)143 int GPTPart::IsSizedForMBR(void) {
144 int retval = MBR_SIZED_GOOD;
145
146 if ((firstLBA > UINT32_MAX) || ((lastLBA - firstLBA) > UINT32_MAX) || (firstLBA > lastLBA))
147 retval = MBR_SIZED_BAD;
148 else if (lastLBA > UINT32_MAX)
149 retval = MBR_SIZED_IFFY;
150
151 return (retval);
152 } // GPTPart::IsSizedForMBR()
153
154 // Set the type code to the specified one. Also changes the partition
155 // name *IF* the current name is the generic one for the current partition
156 // type.
SetType(PartType t)157 void GPTPart::SetType(PartType t) {
158 #ifdef USE_UTF16
159 if (GetDescription() == partitionType.UTypeName()) {
160 #else
161 if (GetDescription() == partitionType.TypeName()) {
162 #endif
163 SetName(t.TypeName());
164 } // if
165 partitionType = t;
166 } // GPTPart::SetType()
167
168 #ifdef USE_UTF16
169 // Set the name for a partition to theName, using a C++-style string as
170 // input.
171 void GPTPart::SetName(const string & theName) {
172 SetName((UnicodeString) theName.c_str());
173 } // GPTPart::SetName()
174
175 // Set the name for a partition to theName, using a Unicode string as
176 // input.
177 void GPTPart::SetName(const UnicodeString & theName) {
178 if (theName.isBogus()) {
179 cerr << "Bogus UTF-16 name found in GPTPart::SetName()! Name not changed!\n";
180 } else {
181 memset(name, 0, NAME_SIZE * sizeof(name[0]) );
182 theName.extractBetween(0, NAME_SIZE, (UChar*) name);
183 } // if/else
184 } // GPTPart::SetName()
185
186 #else
187
188 // Set the name for a partition to theName. Note that theName is a
189 // standard C++-style ASCII string, although the GUID partition definition
190 // requires a UTF-16LE string. This function creates a simple-minded copy
191 // for this.
192 void GPTPart::SetName(const string & theName) {
193 // convert utf8 to utf32 then to utf16le
194 size_t len = theName.length() ;
195 size_t pos = 0 ;
196 for ( size_t i = 0 ; pos < NAME_SIZE && i < len ; ) {
197 uint32_t uni ;
198 uint8_t cp = theName[ i ++ ] ;
199 int todo ;
200 if ( cp < 0x80 ) {
201 uni = cp ;
202 todo = 0 ;
203 } // if
204 else if ( cp < 0xc0 || cp > 0xf7 ) {
205 // invalid byte, theName is broken
206 break ;
207 } // if
208 else if ( cp < 0xe0 ) {
209 uni = cp & 0x1f ;
210 todo = 1 ;
211 } // if
212 else if ( cp < 0xf0 ) {
213 uni = cp & 0x0f ;
214 todo = 2 ;
215 } // if
216 else {
217 uni = cp & 0x7 ;
218 todo = 3 ;
219 } // if
220 while ( todo > 0 ) {
221 if ( i >= len ) {
222 // missing continuation byte, theName is broken
223 goto break_converter ;
224 } // if
225 cp = theName[ i ++ ] ;
226 if ( cp > 0xbf || cp < 0x80 ) {
227 // invalid continuation byte, theName is broken
228 goto break_converter ;
229 } // if
230 uni <<= 6 ;
231 uni |= cp & 0x3f ;
232 todo -- ;
233 } // while
234 // then to utf16le
235 if ( uni < 0x10000 ) {
236 name[ pos ] = (uint16_t) uni ;
237 if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ;
238 pos ++ ;
239 } // if
240 else {
241 if ( pos > NAME_SIZE - 2 ) {
242 // not enough room for two surrogates, truncate
243 break ;
244 } // if
245 uni -= 0x10000 ;
246 name[ pos ] = (uint16_t)( uni >> 10 ) | 0xd800 ;
247 if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ;
248 pos ++ ;
249 name[ pos ] = (uint16_t)( uni & 0x3ff ) | 0xdc00 ;
250 if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ;
251 pos ++ ;
252 }
253 } // for
254 break_converter : ;
255 // finally fill with zeroes
256 while ( pos < NAME_SIZE ) {
257 name[ pos ++ ] = 0 ;
258 } // while
259 } // GPTPart::SetName(), UTF-8 version
260 #endif
261
262 // Set the name for the partition based on the current GUID partition type
263 // code's associated name
264 void GPTPart::SetDefaultDescription(void) {
265 SetName(partitionType.TypeName());
266 } // GPTPart::SetDefaultDescription()
267
268 GPTPart & GPTPart::operator=(const GPTPart & orig) {
269 partitionType = orig.partitionType;
270 uniqueGUID = orig.uniqueGUID;
271 firstLBA = orig.firstLBA;
272 lastLBA = orig.lastLBA;
273 attributes = orig.attributes;
274 memcpy(name, orig.name, NAME_SIZE * sizeof( name[ 0 ] ) );
275 return *this;
276 } // assignment operator
277
278 // Compare the values, and return a bool result.
279 // Because this is intended for sorting and a firstLBA value of 0 denotes
280 // a partition that's not in use and so that should be sorted upwards,
281 // we return the opposite of the usual arithmetic result when either
282 // firstLBA value is 0.
283 bool GPTPart::operator<(const GPTPart &other) const {
284 if (firstLBA && other.firstLBA)
285 return (firstLBA < other.firstLBA);
286 else
287 return (other.firstLBA < firstLBA);
288 } // GPTPart::operator<()
289
290 // Display summary information; does nothing if the partition is empty.
291 void GPTPart::ShowSummary(int partNum, uint32_t blockSize) {
292 string sizeInIeee;
293 UnicodeString description;
294 size_t i;
295
296 if (firstLBA != 0) {
297 sizeInIeee = BytesToIeee(lastLBA - firstLBA + 1, blockSize);
298 cout.fill(' ');
299 cout.width(4);
300 cout << partNum + 1 << " ";
301 cout.width(14);
302 cout << firstLBA << " ";
303 cout.width(14);
304 cout << lastLBA << " ";
305 cout << sizeInIeee << " ";
306 if (sizeInIeee.length() < 10)
307 for (i = 0; i < 10 - sizeInIeee.length(); i++)
308 cout << " ";
309 cout.fill('0');
310 cout.width(4);
311 cout.setf(ios::uppercase);
312 cout << hex << partitionType.GetHexType() << " " << dec;
313 cout.fill(' ');
314 #ifdef USE_UTF16
315 GetDescription().extractBetween(0, 23, description);
316 cout << description << "\n";
317 #else
318 string desc = GetDescription() ;
319 size_t n = 0 ;
320 size_t i = 0 ;
321 size_t len = desc.length() ;
322 while ( n < 22 && i < len ) {
323 i ++ ;
324 if ( i >= len ) {
325 // short description
326 break ;
327 } // if
328 // skip continuation bytes
329 while ( i < len && ( ( desc[ i ] & 0xC0 ) == 0x80 ) ) {
330 // utf8 continuation byte
331 i ++ ;
332 } // while
333 n ++ ;
334 } // while
335 if ( i < len ) {
336 n = 0 ;
337 i = 0 ;
338 // description is long we will truncate it
339 while ( n < 19 && i < len ) {
340 i ++ ;
341 if ( i >= len ) {
342 // should not happen
343 break ;
344 } // if
345 // skip continuation bytes
346 while ( i < len && ( ( desc[ i ] & 0xC0 ) == 0x80 ) ) {
347 // utf8 continuation byte
348 i ++ ;
349 } // while
350 n ++ ;
351 } // while
352 } // for
353 cout << GetDescription().substr( 0 , i ) ;
354 if ( i < len ) cout << "..." ;
355 cout << "\n";
356 #endif
357 cout.fill(' ');
358 } // if
359 } // GPTPart::ShowSummary()
360
361 // Show detailed partition information. Does nothing if the partition is
362 // empty (as determined by firstLBA being 0).
363 void GPTPart::ShowDetails(uint32_t blockSize) {
364 uint64_t size;
365
366 if (firstLBA != 0) {
367 cout << "Partition GUID code: " << partitionType;
368 cout << " (" << partitionType.TypeName() << ")\n";
369 cout << "Partition unique GUID: " << uniqueGUID << "\n";
370
371 cout << "First sector: " << firstLBA << " (at "
372 << BytesToIeee(firstLBA, blockSize) << ")\n";
373 cout << "Last sector: " << lastLBA << " (at "
374 << BytesToIeee(lastLBA, blockSize) << ")\n";
375 size = (lastLBA - firstLBA + 1);
376 cout << "Partition size: " << size << " sectors ("
377 << BytesToIeee(size, blockSize) << ")\n";
378 cout << "Attribute flags: ";
379 cout.fill('0');
380 cout.width(16);
381 cout << hex;
382 cout << attributes << "\n";
383 cout << dec;
384 cout << "Partition name: '" << GetDescription() << "'\n";
385 cout.fill(' ');
386 } // if
387 } // GPTPart::ShowDetails()
388
389 // Blank (delete) a single partition
390 void GPTPart::BlankPartition(void) {
391 uniqueGUID.Zero();
392 partitionType.Zero();
393 firstLBA = 0;
394 lastLBA = 0;
395 attributes = 0;
396 memset(name, 0, NAME_SIZE * sizeof( name[0]) );
397 } // GPTPart::BlankPartition
398
399 // Returns 1 if the two partitions overlap, 0 if they don't
400 int GPTPart::DoTheyOverlap(const GPTPart & other) {
401 // Don't bother checking unless these are defined (both start and end points
402 // are 0 for undefined partitions, so just check the start points)
403 return firstLBA && other.firstLBA &&
404 (firstLBA <= other.lastLBA) != (lastLBA < other.firstLBA);
405 } // GPTPart::DoTheyOverlap()
406
407 // Reverse the bytes of integral data types and of the UTF-16LE name;
408 // used on big-endian systems.
409 void GPTPart::ReversePartBytes(void) {
410 int i;
411
412 ReverseBytes(&firstLBA, 8);
413 ReverseBytes(&lastLBA, 8);
414 ReverseBytes(&attributes, 8);
415 for (i = 0; i < NAME_SIZE; i ++ )
416 ReverseBytes(name + i, 2);
417 } // GPTPart::ReverseBytes()
418
419 /****************************************
420 * Functions requiring user interaction *
421 ****************************************/
422
423 // Change the type code on the partition. Also changes the name if the original
424 // name is the generic one for the partition type.
425 void GPTPart::ChangeType(void) {
426 string line;
427 int changeName;
428 PartType tempType = (GUIDData) "00000000-0000-0000-0000-000000000000";
429
430 #ifdef USE_UTF16
431 changeName = (GetDescription() == GetUTypeName());
432 #else
433 changeName = (GetDescription() == GetTypeName());
434 #endif
435
436 cout << "Current type is '" << GetTypeName() << "'\n";
437 do {
438 cout << "Hex code or GUID (L to show codes, Enter = " << hex << DEFAULT_GPT_TYPE << dec << "): ";
439 line = ReadString();
440 if ((line[0] == 'L') || (line[0] == 'l')) {
441 partitionType.ShowAllTypes();
442 } else {
443 if (line.length() == 0)
444 tempType = DEFAULT_GPT_TYPE;
445 else
446 tempType = line;
447 } // if/else
448 } while (tempType == (GUIDData) "00000000-0000-0000-0000-000000000000");
449 partitionType = tempType;
450 cout << "Changed type of partition to '" << partitionType.TypeName() << "'\n";
451 if (changeName) {
452 SetDefaultDescription();
453 } // if
454 } // GPTPart::ChangeType()
455