| // |
| // C++ Implementation: gptpart |
| // |
| // Description: Class to implement a SINGLE GPT partition |
| // |
| // |
| // Author: Rod Smith <rodsmith@rodsbooks.com>, (C) 2009-2013 |
| // |
| // Copyright: See COPYING file that comes with this distribution |
| // |
| // |
| // This program is copyright (c) 2009 by Roderick W. Smith. It is distributed |
| // under the terms of the GNU GPL version 2, as detailed in the COPYING file. |
| |
| #define __STDC_LIMIT_MACROS |
| #ifndef __STDC_CONSTANT_MACROS |
| #define __STDC_CONSTANT_MACROS |
| #endif |
| |
| #ifdef USE_UTF16 |
| #include <unicode/ustdio.h> |
| #else |
| #define UnicodeString string |
| #endif |
| |
| #include <string.h> |
| #include <stdio.h> |
| #include <iostream> |
| #include "gptpart.h" |
| #include "attributes.h" |
| |
| using namespace std; |
| |
| GPTPart::GPTPart(void) { |
| partitionType.Zero(); |
| uniqueGUID.Zero(); |
| firstLBA = 0; |
| lastLBA = 0; |
| attributes = 0; |
| memset(name, 0, NAME_SIZE * sizeof(name[0]) ); |
| } // Default constructor |
| |
| GPTPart::~GPTPart(void) { |
| } // destructor |
| |
| // Return the gdisk-specific two-byte hex code for the partition |
| uint16_t GPTPart::GetHexType(void) const { |
| return partitionType.GetHexType(); |
| } // GPTPart::GetHexType() |
| |
| // Return a plain-text description of the partition type (e.g., "Linux/Windows |
| // data" or "Linux swap"). |
| string GPTPart::GetTypeName(void) { |
| return partitionType.TypeName(); |
| } // GPTPart::GetNameType() |
| |
| #ifdef USE_UTF16 |
| // Return a Unicode description of the partition type (e.g., "Linux/Windows |
| // data" or "Linux swap"). |
| UnicodeString GPTPart::GetUTypeName(void) { |
| return partitionType.UTypeName(); |
| } // GPTPart::GetNameType() |
| #endif |
| |
| // Compute and return the partition's length (or 0 if the end is incorrectly |
| // set before the beginning). |
| uint64_t GPTPart::GetLengthLBA(void) const { |
| uint64_t length = 0; |
| |
| if (firstLBA <= lastLBA) |
| length = lastLBA - firstLBA + UINT64_C(1); |
| return length; |
| } // GPTPart::GetLengthLBA() |
| |
| #ifdef USE_UTF16 |
| // Return partition's name field, converted to a Unicode string |
| UnicodeString GPTPart::GetDescription(void) { |
| return (UChar*) name; |
| } // GPTPart::GetDescription() |
| #else |
| // Return partition's name field, converted to a C++ UTF-8 string |
| string GPTPart::GetDescription(void) { |
| // convert name to utf32 then to utf8 |
| string utf8 ; |
| size_t pos = 0 ; |
| while ( ( pos < NAME_SIZE ) && ( name[ pos ] != 0 ) ) { |
| uint16_t cp = name[ pos ++ ] ; |
| if ( ! IsLittleEndian() ) ReverseBytes( & cp , 2 ) ; |
| // first to utf32 |
| uint32_t uni ; |
| if ( cp < 0xd800 || cp > 0xdfff ) { |
| uni = cp ; |
| } // if |
| else if ( cp < 0xdc00 ) { |
| // lead surrogate |
| uni = ( (uint32_t)( cp & 0x3ff ) ) << 10 ; |
| if ( pos >= NAME_SIZE ) { |
| // missing trail surrogate, name[] is invalid |
| break ; |
| } // if |
| cp = name[ pos ++ ] ; |
| if ( cp < 0xdc00 || cp > 0xdfff ) { |
| // invalid trail surrogate, name[] is invalid |
| break ; |
| } // if |
| // trail surrogate |
| uni |= cp & 0x3ff ; |
| uni += 0x10000 ; |
| } // if |
| else { |
| // unexpected trail surrogate, name[] is invalid |
| break ; |
| } // if |
| // then to utf8 |
| if ( uni < 0x80 ) { |
| utf8 += (char) uni ; |
| } // if |
| else if ( uni < 0x800 ) { |
| utf8 += (char) ( 0xc0 | ( uni >> 6 ) ) ; |
| utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ; |
| } // if |
| else if ( uni < 0x10000 ) { |
| utf8 += (char) ( 0xe0 | ( uni >> 12 ) ) ; |
| utf8 += (char) ( 0x80 | ( ( uni >> 6 ) & 0x3f ) ) ; |
| utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ; |
| } // if |
| else { |
| utf8 += (char) ( 0xf0 | ( uni >> 18 ) ) ; |
| utf8 += (char) ( 0xe0 | ( ( uni >> 12 ) & 0x3f ) ) ; |
| utf8 += (char) ( 0x80 | ( ( uni >> 6 ) & 0x3f ) ) ; |
| utf8 += (char) ( 0x80 | ( uni & 0x3f ) ) ; |
| } // if |
| } |
| return utf8 ; |
| } // GPTPart::GetDescription(), UTF-8 version |
| #endif |
| |
| // Return 1 if the partition is in use |
| int GPTPart::IsUsed(void) { |
| return (partitionType != GUIDData("0x00")); |
| } // GPTPart::IsUsed() |
| |
| // Returns MBR_SIZED_GOOD, MBR_SIZED_IFFY, or MBR_SIZED_BAD; see comments |
| // in header file for details. |
| int GPTPart::IsSizedForMBR(void) { |
| int retval = MBR_SIZED_GOOD; |
| |
| if ((firstLBA > UINT32_MAX) || ((lastLBA - firstLBA) > UINT32_MAX) || (firstLBA > lastLBA)) |
| retval = MBR_SIZED_BAD; |
| else if (lastLBA > UINT32_MAX) |
| retval = MBR_SIZED_IFFY; |
| |
| return (retval); |
| } // GPTPart::IsSizedForMBR() |
| |
| // Set the type code to the specified one. Also changes the partition |
| // name *IF* the current name is the generic one for the current partition |
| // type. |
| void GPTPart::SetType(PartType t) { |
| #ifdef USE_UTF16 |
| if (GetDescription() == partitionType.UTypeName()) { |
| #else |
| if (GetDescription() == partitionType.TypeName()) { |
| #endif |
| SetName(t.TypeName()); |
| } // if |
| partitionType = t; |
| } // GPTPart::SetType() |
| |
| #ifdef USE_UTF16 |
| // Set the name for a partition to theName, using a C++-style string as |
| // input. |
| void GPTPart::SetName(const string & theName) { |
| SetName((UnicodeString) theName.c_str()); |
| } // GPTPart::SetName() |
| |
| // Set the name for a partition to theName, using a Unicode string as |
| // input. |
| void GPTPart::SetName(const UnicodeString & theName) { |
| if (theName.isBogus()) { |
| cerr << "Bogus UTF-16 name found in GPTPart::SetName()! Name not changed!\n"; |
| } else { |
| memset(name, 0, NAME_SIZE * sizeof(name[0]) ); |
| theName.extractBetween(0, NAME_SIZE, (UChar*) name); |
| } // if/else |
| } // GPTPart::SetName() |
| |
| #else |
| |
| // Set the name for a partition to theName. Note that theName is a |
| // standard C++-style ASCII string, although the GUID partition definition |
| // requires a UTF-16LE string. This function creates a simple-minded copy |
| // for this. |
| void GPTPart::SetName(const string & theName) { |
| // convert utf8 to utf32 then to utf16le |
| size_t len = theName.length() ; |
| size_t pos = 0 ; |
| for ( size_t i = 0 ; pos < NAME_SIZE && i < len ; ) { |
| uint32_t uni ; |
| uint8_t cp = theName[ i ++ ] ; |
| int todo ; |
| if ( cp < 0x80 ) { |
| uni = cp ; |
| todo = 0 ; |
| } // if |
| else if ( cp < 0xc0 || cp > 0xf7 ) { |
| // invalid byte, theName is broken |
| break ; |
| } // if |
| else if ( cp < 0xe0 ) { |
| uni = cp & 0x1f ; |
| todo = 1 ; |
| } // if |
| else if ( cp < 0xf0 ) { |
| uni = cp & 0x0f ; |
| todo = 2 ; |
| } // if |
| else { |
| uni = cp & 0x7 ; |
| todo = 3 ; |
| } // if |
| while ( todo > 0 ) { |
| if ( i >= len ) { |
| // missing continuation byte, theName is broken |
| goto break_converter ; |
| } // if |
| cp = theName[ i ++ ] ; |
| if ( cp > 0xbf || cp < 0x80 ) { |
| // invalid continuation byte, theName is broken |
| goto break_converter ; |
| } // if |
| uni <<= 6 ; |
| uni |= cp & 0x3f ; |
| todo -- ; |
| } // while |
| // then to utf16le |
| if ( uni < 0x10000 ) { |
| name[ pos ] = (uint16_t) uni ; |
| if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ; |
| pos ++ ; |
| } // if |
| else { |
| if ( pos > NAME_SIZE - 2 ) { |
| // not enough room for two surrogates, truncate |
| break ; |
| } // if |
| uni -= 0x10000 ; |
| name[ pos ] = (uint16_t)( uni >> 10 ) | 0xd800 ; |
| if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ; |
| pos ++ ; |
| name[ pos ] = (uint16_t)( uni & 0x3ff ) | 0xdc00 ; |
| if ( ! IsLittleEndian() ) ReverseBytes( name + pos , 2 ) ; |
| pos ++ ; |
| } |
| } // for |
| break_converter : ; |
| // finally fill with zeroes |
| while ( pos < NAME_SIZE ) { |
| name[ pos ++ ] = 0 ; |
| } // while |
| } // GPTPart::SetName(), UTF-8 version |
| #endif |
| |
| // Set the name for the partition based on the current GUID partition type |
| // code's associated name |
| void GPTPart::SetDefaultDescription(void) { |
| SetName(partitionType.TypeName()); |
| } // GPTPart::SetDefaultDescription() |
| |
| GPTPart & GPTPart::operator=(const GPTPart & orig) { |
| partitionType = orig.partitionType; |
| uniqueGUID = orig.uniqueGUID; |
| firstLBA = orig.firstLBA; |
| lastLBA = orig.lastLBA; |
| attributes = orig.attributes; |
| memcpy(name, orig.name, NAME_SIZE * sizeof( name[ 0 ] ) ); |
| return *this; |
| } // assignment operator |
| |
| // Compare the values, and return a bool result. |
| // Because this is intended for sorting and a firstLBA value of 0 denotes |
| // a partition that's not in use and so that should be sorted upwards, |
| // we return the opposite of the usual arithmetic result when either |
| // firstLBA value is 0. |
| bool GPTPart::operator<(const GPTPart &other) const { |
| if (firstLBA && other.firstLBA) |
| return (firstLBA < other.firstLBA); |
| else |
| return (other.firstLBA < firstLBA); |
| } // GPTPart::operator<() |
| |
| // Display summary information; does nothing if the partition is empty. |
| void GPTPart::ShowSummary(int partNum, uint32_t blockSize) { |
| string sizeInIeee; |
| UnicodeString description; |
| size_t i; |
| |
| if (firstLBA != 0) { |
| sizeInIeee = BytesToIeee(lastLBA - firstLBA + 1, blockSize); |
| cout.fill(' '); |
| cout.width(4); |
| cout << partNum + 1 << " "; |
| cout.width(14); |
| cout << firstLBA << " "; |
| cout.width(14); |
| cout << lastLBA << " "; |
| cout << sizeInIeee << " "; |
| if (sizeInIeee.length() < 10) |
| for (i = 0; i < 10 - sizeInIeee.length(); i++) |
| cout << " "; |
| cout.fill('0'); |
| cout.width(4); |
| cout.setf(ios::uppercase); |
| cout << hex << partitionType.GetHexType() << " " << dec; |
| cout.fill(' '); |
| #ifdef USE_UTF16 |
| GetDescription().extractBetween(0, 23, description); |
| cout << description << "\n"; |
| #else |
| string desc = GetDescription() ; |
| size_t n = 0 ; |
| size_t i = 0 ; |
| size_t len = desc.length() ; |
| while ( n < 22 && i < len ) { |
| i ++ ; |
| if ( i >= len ) { |
| // short description |
| break ; |
| } // if |
| // skip continuation bytes |
| while ( i < len && ( ( desc[ i ] & 0xC0 ) == 0x80 ) ) { |
| // utf8 continuation byte |
| i ++ ; |
| } // while |
| n ++ ; |
| } // while |
| if ( i < len ) { |
| n = 0 ; |
| i = 0 ; |
| // description is long we will truncate it |
| while ( n < 19 && i < len ) { |
| i ++ ; |
| if ( i >= len ) { |
| // should not happen |
| break ; |
| } // if |
| // skip continuation bytes |
| while ( i < len && ( ( desc[ i ] & 0xC0 ) == 0x80 ) ) { |
| // utf8 continuation byte |
| i ++ ; |
| } // while |
| n ++ ; |
| } // while |
| } // for |
| cout << GetDescription().substr( 0 , i ) ; |
| if ( i < len ) cout << "..." ; |
| cout << "\n"; |
| #endif |
| cout.fill(' '); |
| } // if |
| } // GPTPart::ShowSummary() |
| |
| // Show detailed partition information. Does nothing if the partition is |
| // empty (as determined by firstLBA being 0). |
| void GPTPart::ShowDetails(uint32_t blockSize) { |
| uint64_t size; |
| |
| if (firstLBA != 0) { |
| cout << "Partition GUID code: " << partitionType; |
| cout << " (" << partitionType.TypeName() << ")\n"; |
| cout << "Partition unique GUID: " << uniqueGUID << "\n"; |
| |
| cout << "First sector: " << firstLBA << " (at " |
| << BytesToIeee(firstLBA, blockSize) << ")\n"; |
| cout << "Last sector: " << lastLBA << " (at " |
| << BytesToIeee(lastLBA, blockSize) << ")\n"; |
| size = (lastLBA - firstLBA + 1); |
| cout << "Partition size: " << size << " sectors (" |
| << BytesToIeee(size, blockSize) << ")\n"; |
| cout << "Attribute flags: "; |
| cout.fill('0'); |
| cout.width(16); |
| cout << hex; |
| cout << attributes << "\n"; |
| cout << dec; |
| cout << "Partition name: '" << GetDescription() << "'\n"; |
| cout.fill(' '); |
| } // if |
| } // GPTPart::ShowDetails() |
| |
| // Blank (delete) a single partition |
| void GPTPart::BlankPartition(void) { |
| uniqueGUID.Zero(); |
| partitionType.Zero(); |
| firstLBA = 0; |
| lastLBA = 0; |
| attributes = 0; |
| memset(name, 0, NAME_SIZE * sizeof( name[0]) ); |
| } // GPTPart::BlankPartition |
| |
| // Returns 1 if the two partitions overlap, 0 if they don't |
| int GPTPart::DoTheyOverlap(const GPTPart & other) { |
| // Don't bother checking unless these are defined (both start and end points |
| // are 0 for undefined partitions, so just check the start points) |
| return firstLBA && other.firstLBA && |
| (firstLBA <= other.lastLBA) != (lastLBA < other.firstLBA); |
| } // GPTPart::DoTheyOverlap() |
| |
| // Reverse the bytes of integral data types and of the UTF-16LE name; |
| // used on big-endian systems. |
| void GPTPart::ReversePartBytes(void) { |
| int i; |
| |
| ReverseBytes(&firstLBA, 8); |
| ReverseBytes(&lastLBA, 8); |
| ReverseBytes(&attributes, 8); |
| for (i = 0; i < NAME_SIZE; i ++ ) |
| ReverseBytes(name + i, 2); |
| } // GPTPart::ReverseBytes() |
| |
| /**************************************** |
| * Functions requiring user interaction * |
| ****************************************/ |
| |
| // Change the type code on the partition. Also changes the name if the original |
| // name is the generic one for the partition type. |
| void GPTPart::ChangeType(void) { |
| string line; |
| int changeName; |
| PartType tempType = (GUIDData) "00000000-0000-0000-0000-000000000000"; |
| |
| #ifdef USE_UTF16 |
| changeName = (GetDescription() == GetUTypeName()); |
| #else |
| changeName = (GetDescription() == GetTypeName()); |
| #endif |
| |
| cout << "Current type is '" << GetTypeName() << "'\n"; |
| do { |
| cout << "Hex code or GUID (L to show codes, Enter = " << hex << DEFAULT_GPT_TYPE << dec << "): "; |
| line = ReadString(); |
| if ((line[0] == 'L') || (line[0] == 'l')) { |
| partitionType.ShowAllTypes(); |
| } else { |
| if (line.length() == 0) |
| tempType = DEFAULT_GPT_TYPE; |
| else |
| tempType = line; |
| } // if/else |
| } while (tempType == (GUIDData) "00000000-0000-0000-0000-000000000000"); |
| partitionType = tempType; |
| cout << "Changed type of partition to '" << partitionType.TypeName() << "'\n"; |
| if (changeName) { |
| SetDefaultDescription(); |
| } // if |
| } // GPTPart::ChangeType() |
