Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
gptfdisk/gptpart.cc
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
454 lines (417 sloc)
13.8 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// | |
// 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 | |
#define __STDC_CONSTANT_MACROS | |
#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() |