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/support.cc
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
359 lines (322 sloc)
12.1 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
// support.cc | |
// Non-class support functions for gdisk program. | |
// Primarily by Rod Smith, February 2009, but with a few functions | |
// copied from other sources (see attributions below). | |
/* This program is copyright (c) 2009-2013 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 | |
#include <stdio.h> | |
#include <stdint.h> | |
#include <errno.h> | |
#include <fcntl.h> | |
#include <string.h> | |
#include <sys/stat.h> | |
#include <string> | |
#include <iostream> | |
#include <sstream> | |
#include "support.h" | |
#include <sys/types.h> | |
// As of 1/2010, BLKPBSZGET is very new, so I'm explicitly defining it if | |
// it's not already defined. This should become unnecessary in the future. | |
// Note that this is a Linux-only ioctl.... | |
#ifndef BLKPBSZGET | |
#define BLKPBSZGET _IO(0x12,123) | |
#endif | |
using namespace std; | |
// Reads a string from stdin, returning it as a C++-style string. | |
// Note that the returned string will NOT include the carriage return | |
// entered by the user. | |
#ifdef EFI | |
extern int __sscanf( const char * str , const char * format , ... ) ; | |
string ReadString(void) { | |
string inString; | |
char efiString[256]; | |
int stringLength; | |
if (fgets(efiString, 255, stdin) != NULL) { | |
stringLength = strlen(efiString); | |
if ((stringLength > 0) && (efiString[stringLength - 1] == '\n')) | |
efiString[stringLength - 1] = '\0'; | |
inString = efiString; | |
} else { | |
inString = ""; | |
} | |
return inString; | |
} // ReadString() | |
#else | |
string ReadString(void) { | |
string inString; | |
getline(cin, inString); | |
if (!cin.good()) | |
exit(5); | |
return inString; | |
} // ReadString() | |
#endif | |
// Get a numeric value from the user, between low and high (inclusive). | |
// Keeps looping until the user enters a value within that range. | |
// If user provides no input, def (default value) is returned. | |
// (If def is outside of the low-high range, an explicit response | |
// is required.) | |
int GetNumber(int low, int high, int def, const string & prompt) { | |
int response, num; | |
char line[255]; | |
if (low != high) { // bother only if low and high differ... | |
do { | |
cout << prompt; | |
cin.getline(line, 255); | |
if (!cin.good()) | |
exit(5); | |
num = sscanf(line, "%d", &response); | |
if (num == 1) { // user provided a response | |
if ((response < low) || (response > high)) | |
cout << "Value out of range\n"; | |
} else { // user hit enter; return default | |
response = def; | |
} // if/else | |
} while ((response < low) || (response > high)); | |
} else { // low == high, so return this value | |
cout << "Using " << low << "\n"; | |
response = low; | |
} // else | |
return (response); | |
} // GetNumber() | |
// Gets a Y/N response (and converts lowercase to uppercase) | |
char GetYN(void) { | |
char response; | |
string line; | |
bool again = 0 ; | |
do { | |
if ( again ) { cout << "Your option? " ; } | |
again = 1 ; | |
cout << "(Y/N): "; | |
line = ReadString(); | |
response = toupper(line[0]); | |
} while ((response != 'Y') && (response != 'N')); | |
return response; | |
} // GetYN(void) | |
// Obtains a sector number, between low and high, from the | |
// user, accepting values prefixed by "+" to add sectors to low, | |
// or the same with "K", "M", "G", "T", or "P" as suffixes to add | |
// kilobytes, megabytes, gigabytes, terabytes, or petabytes, | |
// respectively. If a "-" prefix is used, use the high value minus | |
// the user-specified number of sectors (or KiB, MiB, etc.). Use the | |
// def value as the default if the user just hits Enter. The sSize is | |
// the sector size of the device. | |
uint64_t GetSectorNum(uint64_t low, uint64_t high, uint64_t def, uint64_t sSize, | |
const string & prompt) { | |
uint64_t response; | |
char line[255]; | |
do { | |
cout << prompt; | |
cin.getline(line, 255); | |
if (!cin.good()) | |
exit(5); | |
response = IeeeToInt(line, sSize, low, high, def); | |
} while ((response < low) || (response > high)); | |
return response; | |
} // GetSectorNum() | |
// Convert an IEEE-1541-2002 value (K, M, G, T, P, or E) to its equivalent in | |
// number of sectors. If no units are appended, interprets as the number | |
// of sectors; otherwise, interprets as number of specified units and | |
// converts to sectors. For instance, with 512-byte sectors, "1K" converts | |
// to 2. If value includes a "+", adds low and subtracts 1; if SIValue | |
// inclues a "-", subtracts from high. If IeeeValue is empty, returns def. | |
// Returns final sector value. In case inValue is invalid, returns 0 (a | |
// sector value that's always in use on GPT and therefore invalid); and if | |
// inValue works out to something outside the range low-high, returns the | |
// computed value; the calling function is responsible for checking the | |
// validity of this value. | |
// NOTE: There's a difference in how GCC and VC++ treat oversized values | |
// (say, "999999999999999999999") read via the ">>" operator; GCC turns | |
// them into the maximum value for the type, whereas VC++ turns them into | |
// 0 values. The result is that IeeeToInt() returns UINT64_MAX when | |
// compiled with GCC (and so the value is rejected), whereas when VC++ | |
// is used, the default value is returned. | |
uint64_t IeeeToInt(string inValue, uint64_t sSize, uint64_t low, uint64_t high, uint64_t def) { | |
uint64_t response = def, bytesPerUnit = 1, mult = 1, divide = 1; | |
size_t foundAt = 0; | |
char suffix = ' ', plusFlag = ' '; | |
string suffixes = "KMGTPE"; | |
int badInput = 0; // flag bad input; once this goes to 1, other values are irrelevant | |
if (sSize == 0) { | |
sSize = SECTOR_SIZE; | |
cerr << "Bug: Sector size invalid in IeeeToInt()!\n"; | |
} // if | |
// Remove leading spaces, if present | |
while (inValue[0] == ' ') | |
inValue.erase(0, 1); | |
// If present, flag and remove leading plus or minus sign | |
if ((inValue[0] == '+') || (inValue[0] == '-')) { | |
plusFlag = inValue[0]; | |
inValue.erase(0, 1); | |
} // if | |
// Extract numeric response and, if present, suffix | |
istringstream inString(inValue); | |
if (((inString.peek() < '0') || (inString.peek() > '9')) && (inString.peek() != -1)) | |
badInput = 1; | |
inString >> response >> suffix; | |
suffix = toupper(suffix); | |
// If no response, or if response == 0, use default (def) | |
if ((inValue.length() == 0) || (response == 0)) { | |
response = def; | |
suffix = ' '; | |
plusFlag = ' '; | |
} // if | |
// Find multiplication and division factors for the suffix | |
foundAt = suffixes.find(suffix); | |
if (foundAt != string::npos) { | |
bytesPerUnit = UINT64_C(1) << (10 * (foundAt + 1)); | |
mult = bytesPerUnit / sSize; | |
divide = sSize / bytesPerUnit; | |
} // if | |
// Adjust response based on multiplier and plus flag, if present | |
if (mult > 1) { | |
if (response > (UINT64_MAX / mult)) | |
badInput = 1; | |
else | |
response *= mult; | |
} else if (divide > 1) { | |
response /= divide; | |
} // if/elseif | |
if (plusFlag == '+') { | |
// Recompute response based on low part of range (if default == high | |
// value, which should be the case when prompting for the end of a | |
// range) or the defaut value (if default != high, which should be | |
// the case for the first sector of a partition). | |
if (def == high) { | |
if (response > 0) | |
response--; | |
if (response > (UINT64_MAX - low)) | |
badInput = 1; | |
else | |
response = response + low; | |
} else { | |
if (response > (UINT64_MAX - def)) | |
badInput = 1; | |
else | |
response = response + def; | |
} // if/else | |
} else if (plusFlag == '-') { | |
if (response > high) | |
badInput = 1; | |
else | |
response = high - response; | |
} // if | |
if (badInput) | |
response = UINT64_C(0); | |
return response; | |
} // IeeeToInt() | |
// Takes a size and converts this to a size in IEEE-1541-2002 units (KiB, MiB, | |
// GiB, TiB, PiB, or EiB), returned in C++ string form. The size is either in | |
// units of the sector size or, if that parameter is omitted, in bytes. | |
// (sectorSize defaults to 1). Note that this function uses peculiar | |
// manual computation of decimal value rather than simply setting | |
// theValue.precision() because this isn't possible using the available | |
// EFI library. | |
string BytesToIeee(uint64_t size, uint32_t sectorSize) { | |
uint64_t sizeInIeee; | |
uint64_t previousIeee; | |
float decimalIeee; | |
uint64_t index = 0; | |
string units, prefixes = " KMGTPEZ"; | |
ostringstream theValue; | |
sizeInIeee = previousIeee = size * (uint64_t) sectorSize; | |
while ((sizeInIeee > 1024) && (index < (prefixes.length() - 1))) { | |
index++; | |
previousIeee = sizeInIeee; | |
sizeInIeee /= 1024; | |
} // while | |
if (prefixes[index] == ' ') { | |
theValue << sizeInIeee << " bytes"; | |
} else { | |
units = " iB"; | |
units[1] = prefixes[index]; | |
decimalIeee = ((float) previousIeee - | |
((float) sizeInIeee * 1024.0) + 51.2) / 102.4; | |
if (decimalIeee >= 10.0) { | |
decimalIeee = 0.0; | |
sizeInIeee++; | |
} | |
theValue << sizeInIeee << "." << (uint32_t) decimalIeee << units; | |
} // if/else | |
return theValue.str(); | |
} // BytesToIeee() | |
// Converts two consecutive characters in the input string into a | |
// number, interpreting the string as a hexadecimal number, starting | |
// at the specified position. | |
unsigned char StrToHex(const string & input, unsigned int position) { | |
unsigned char retval = 0x00; | |
unsigned int temp; | |
if (input.length() > position) { | |
sscanf(input.substr(position, 2).c_str(), "%x", &temp); | |
retval = (unsigned char) temp; | |
} // if | |
return retval; | |
} // StrToHex() | |
// Returns 1 if input can be interpreted as a hexadecimal number -- | |
// all characters must be spaces, digits, or letters A-F (upper- or | |
// lower-case), with at least one valid hexadecimal digit; with the | |
// exception of the first two characters, which may be "0x"; otherwise | |
// returns 0. | |
int IsHex(string input) { | |
int isHex = 1, foundHex = 0, i; | |
if (input.substr(0, 2) == "0x") | |
input.erase(0, 2); | |
for (i = 0; i < (int) input.length(); i++) { | |
if ((input[i] < '0') || (input[i] > '9')) { | |
if ((input[i] < 'A') || (input[i] > 'F')) { | |
if ((input[i] < 'a') || (input[i] > 'f')) { | |
if ((input[i] != ' ') && (input[i] != '\n')) { | |
isHex = 0; | |
} | |
} else foundHex = 1; | |
} else foundHex = 1; | |
} else foundHex = 1; | |
} // for | |
if (!foundHex) | |
isHex = 0; | |
return isHex; | |
} // IsHex() | |
// Return 1 if the CPU architecture is little endian, 0 if it's big endian.... | |
int IsLittleEndian(void) { | |
int littleE = 1; // assume little-endian (Intel-style) | |
union { | |
uint32_t num; | |
unsigned char uc[sizeof(uint32_t)]; | |
} endian; | |
endian.num = 1; | |
if (endian.uc[0] != (unsigned char) 1) { | |
littleE = 0; | |
} // if | |
return (littleE); | |
} // IsLittleEndian() | |
// Reverse the byte order of theValue; numBytes is number of bytes | |
void ReverseBytes(void* theValue, int numBytes) { | |
char* tempValue = NULL; | |
int i; | |
tempValue = new char [numBytes]; | |
if (tempValue != NULL) { | |
memcpy(tempValue, theValue, numBytes); | |
for (i = 0; i < numBytes; i++) | |
((char*) theValue)[i] = tempValue[numBytes - i - 1]; | |
delete[] tempValue; | |
} else { | |
cerr << "Could not allocate memory in ReverseBytes()! Terminating\n"; | |
exit(1); | |
} // if/else | |
} // ReverseBytes() | |
// On Windows, display a warning and ask whether to continue. If the user elects | |
// not to continue, exit immediately. | |
void WinWarning(void) { | |
#ifdef _WIN32 | |
cout << "\a************************************************************************\n" | |
<< "Most versions of Windows cannot boot from a GPT disk except on a UEFI-based\n" | |
<< "computer, and most varieties prior to Vista cannot read GPT disks. Therefore,\n" | |
<< "you should exit now unless you understand the implications of converting MBR\n" | |
<< "to GPT or creating a new GPT disk layout!\n" | |
<< "************************************************************************\n\n"; | |
cout << "Are you SURE you want to continue? "; | |
if (GetYN() != 'Y') | |
exit(0); | |
#endif | |
} // WinWarning() |