1 // support.cc 2 // Non-class support functions for gdisk program. 3 // Primarily by Rod Smith, February 2009, but with a few functions 4 // copied from other sources (see attributions below). 5 6 /* This program is copyright (c) 2009-2013 by Roderick W. Smith. It is distributed 7 under the terms of the GNU GPL version 2, as detailed in the COPYING file. */ 8 9 #define __STDC_LIMIT_MACROS 10 #ifndef __STDC_CONSTANT_MACROS 11 #define __STDC_CONSTANT_MACROS 12 #endif 13 14 #include <stdio.h> 15 #include <stdint.h> 16 #include <errno.h> 17 #include <fcntl.h> 18 #include <string.h> 19 #include <sys/stat.h> 20 #include <string> 21 #include <iostream> 22 #include <sstream> 23 #include "support.h" 24 25 #include <sys/types.h> 26 27 // As of 1/2010, BLKPBSZGET is very new, so I'm explicitly defining it if 28 // it's not already defined. This should become unnecessary in the future. 29 // Note that this is a Linux-only ioctl.... 30 #ifndef BLKPBSZGET 31 #define BLKPBSZGET _IO(0x12,123) 32 #endif 33 34 using namespace std; 35 36 // Reads a string from stdin, returning it as a C++-style string. 37 // Note that the returned string will NOT include the carriage return 38 // entered by the user. 39 string ReadString(void) { 40 string inString; 41 42 getline(cin, inString); 43 if (!cin.good()) 44 exit(5); 45 return inString; 46 } // ReadString() 47 48 // Get a numeric value from the user, between low and high (inclusive). 49 // Keeps looping until the user enters a value within that range. 50 // If user provides no input, def (default value) is returned. 51 // (If def is outside of the low-high range, an explicit response 52 // is required.) 53 int GetNumber(int low, int high, int def, const string & prompt) { 54 int response, num; 55 char line[255]; 56 57 if (low != high) { // bother only if low and high differ... 58 do { 59 cout << prompt; 60 cin.getline(line, 255); 61 if (!cin.good()) 62 exit(5); 63 num = sscanf(line, "%d", &response); 64 if (num == 1) { // user provided a response 65 if ((response < low) || (response > high)) 66 cout << "Value out of range\n"; 67 } else { // user hit enter; return default 68 response = def; 69 } // if/else 70 } while ((response < low) || (response > high)); 71 } else { // low == high, so return this value 72 cout << "Using " << low << "\n"; 73 response = low; 74 } // else 75 return (response); 76 } // GetNumber() 77 78 // Gets a Y/N response (and converts lowercase to uppercase) 79 char GetYN(void) { 80 char response; 81 string line; 82 bool again = 0 ; 83 84 do { 85 if ( again ) { cout << "Your option? " ; } 86 again = 1 ; 87 cout << "(Y/N): "; 88 line = ReadString(); 89 response = toupper(line[0]); 90 } while ((response != 'Y') && (response != 'N')); 91 return response; 92 } // GetYN(void) 93 94 // Obtains a sector number, between low and high, from the 95 // user, accepting values prefixed by "+" to add sectors to low, 96 // or the same with "K", "M", "G", "T", or "P" as suffixes to add 97 // kilobytes, megabytes, gigabytes, terabytes, or petabytes, 98 // respectively. If a "-" prefix is used, use the high value minus 99 // the user-specified number of sectors (or KiB, MiB, etc.). Use the 100 // def value as the default if the user just hits Enter. The sSize is 101 // the sector size of the device. 102 uint64_t GetSectorNum(uint64_t low, uint64_t high, uint64_t def, uint64_t sSize, 103 const string & prompt) { 104 uint64_t response; 105 char line[255]; 106 107 do { 108 cout << prompt; 109 cin.getline(line, 255); 110 if (!cin.good()) 111 exit(5); 112 response = IeeeToInt(line, sSize, low, high, def); 113 } while ((response < low) || (response > high)); 114 return response; 115 } // GetSectorNum() 116 117 // Convert an IEEE-1541-2002 value (K, M, G, T, P, or E) to its equivalent in 118 // number of sectors. If no units are appended, interprets as the number 119 // of sectors; otherwise, interprets as number of specified units and 120 // converts to sectors. For instance, with 512-byte sectors, "1K" converts 121 // to 2. If value includes a "+", adds low and subtracts 1; if SIValue 122 // inclues a "-", subtracts from high. If IeeeValue is empty, returns def. 123 // Returns final sector value. In case inValue is invalid, returns 0 (a 124 // sector value that's always in use on GPT and therefore invalid); and if 125 // inValue works out to something outside the range low-high, returns the 126 // computed value; the calling function is responsible for checking the 127 // validity of this value. 128 // NOTE: There's a difference in how GCC and VC++ treat oversized values 129 // (say, "999999999999999999999") read via the ">>" operator; GCC turns 130 // them into the maximum value for the type, whereas VC++ turns them into 131 // 0 values. The result is that IeeeToInt() returns UINT64_MAX when 132 // compiled with GCC (and so the value is rejected), whereas when VC++ 133 // is used, the default value is returned. 134 uint64_t IeeeToInt(string inValue, uint64_t sSize, uint64_t low, uint64_t high, uint64_t def) { 135 uint64_t response = def, bytesPerUnit = 1, mult = 1, divide = 1; 136 size_t foundAt = 0; 137 char suffix, plusFlag = ' '; 138 string suffixes = "KMGTPE"; 139 int badInput = 0; // flag bad input; once this goes to 1, other values are irrelevant 140 141 if (sSize == 0) { 142 sSize = SECTOR_SIZE; 143 cerr << "Bug: Sector size invalid in IeeeToInt()!\n"; 144 } // if 145 146 // Remove leading spaces, if present 147 while (inValue[0] == ' ') 148 inValue.erase(0, 1); 149 150 // If present, flag and remove leading plus or minus sign 151 if ((inValue[0] == '+') || (inValue[0] == '-')) { 152 plusFlag = inValue[0]; 153 inValue.erase(0, 1); 154 } // if 155 156 // Extract numeric response and, if present, suffix 157 istringstream inString(inValue); 158 if (((inString.peek() < '0') || (inString.peek() > '9')) && (inString.peek() != -1)) 159 badInput = 1; 160 inString >> response >> suffix; 161 suffix = toupper(suffix); 162 163 // If no response, or if response == 0, use default (def) 164 if ((inValue.length() == 0) || (response == 0)) { 165 response = def; 166 suffix = ' '; 167 plusFlag = ' '; 168 } // if 169 170 // Find multiplication and division factors for the suffix 171 foundAt = suffixes.find(suffix); 172 if (foundAt != string::npos) { 173 bytesPerUnit = UINT64_C(1) << (10 * (foundAt + 1)); 174 mult = bytesPerUnit / sSize; 175 divide = sSize / bytesPerUnit; 176 } // if 177 178 // Adjust response based on multiplier and plus flag, if present 179 if (mult > 1) { 180 if (response > (UINT64_MAX / mult)) 181 badInput = 1; 182 else 183 response *= mult; 184 } else if (divide > 1) { 185 response /= divide; 186 } // if/elseif 187 188 if (plusFlag == '+') { 189 // Recompute response based on low part of range (if default == high 190 // value, which should be the case when prompting for the end of a 191 // range) or the defaut value (if default != high, which should be 192 // the case for the first sector of a partition). 193 if (def == high) { 194 if (response > 0) 195 response--; 196 if (response > (UINT64_MAX - low)) 197 badInput = 1; 198 else 199 response = response + low; 200 } else { 201 if (response > (UINT64_MAX - def)) 202 badInput = 1; 203 else 204 response = response + def; 205 } // if/else 206 } else if (plusFlag == '-') { 207 if (response > high) 208 badInput = 1; 209 else 210 response = high - response; 211 } // if 212 213 if (badInput) 214 response = UINT64_C(0); 215 216 return response; 217 } // IeeeToInt() 218 219 // Takes a size and converts this to a size in IEEE-1541-2002 units (KiB, MiB, 220 // GiB, TiB, PiB, or EiB), returned in C++ string form. The size is either in 221 // units of the sector size or, if that parameter is omitted, in bytes. 222 // (sectorSize defaults to 1). Note that this function uses peculiar 223 // manual computation of decimal value rather than simply setting 224 // theValue.precision() because this isn't possible using the available 225 // EFI library. 226 string BytesToIeee(uint64_t size, uint32_t sectorSize) { 227 uint64_t sizeInIeee; 228 uint64_t previousIeee; 229 float decimalIeee; 230 uint index = 0; 231 string units, prefixes = " KMGTPEZ"; 232 ostringstream theValue; 233 234 sizeInIeee = previousIeee = size * (uint64_t) sectorSize; 235 while ((sizeInIeee > 1024) && (index < (prefixes.length() - 1))) { 236 index++; 237 previousIeee = sizeInIeee; 238 sizeInIeee /= 1024; 239 } // while 240 if (prefixes[index] == ' ') { 241 theValue << sizeInIeee << " bytes"; 242 } else { 243 units = " iB"; 244 units[1] = prefixes[index]; 245 decimalIeee = ((float) previousIeee - 246 ((float) sizeInIeee * 1024.0) + 51.2) / 102.4; 247 if (decimalIeee >= 10.0) { 248 decimalIeee = 0.0; 249 sizeInIeee++; 250 } 251 theValue << sizeInIeee << "." << (uint32_t) decimalIeee << units; 252 } // if/else 253 return theValue.str(); 254 } // BytesToIeee() 255 256 // Converts two consecutive characters in the input string into a 257 // number, interpreting the string as a hexadecimal number, starting 258 // at the specified position. 259 unsigned char StrToHex(const string & input, unsigned int position) { 260 unsigned char retval = 0x00; 261 unsigned int temp; 262 263 if (input.length() > position) { 264 sscanf(input.substr(position, 2).c_str(), "%x", &temp); 265 retval = (unsigned char) temp; 266 } // if 267 return retval; 268 } // StrToHex() 269 270 // Returns 1 if input can be interpreted as a hexadecimal number -- 271 // all characters must be spaces, digits, or letters A-F (upper- or 272 // lower-case), with at least one valid hexadecimal digit; with the 273 // exception of the first two characters, which may be "0x"; otherwise 274 // returns 0. 275 int IsHex(string input) { 276 int isHex = 1, foundHex = 0, i; 277 278 if (input.substr(0, 2) == "0x") 279 input.erase(0, 2); 280 for (i = 0; i < (int) input.length(); i++) { 281 if ((input[i] < '0') || (input[i] > '9')) { 282 if ((input[i] < 'A') || (input[i] > 'F')) { 283 if ((input[i] < 'a') || (input[i] > 'f')) { 284 if ((input[i] != ' ') && (input[i] != '\n')) { 285 isHex = 0; 286 } 287 } else foundHex = 1; 288 } else foundHex = 1; 289 } else foundHex = 1; 290 } // for 291 if (!foundHex) 292 isHex = 0; 293 return isHex; 294 } // IsHex() 295 296 // Return 1 if the CPU architecture is little endian, 0 if it's big endian.... 297 int IsLittleEndian(void) { 298 int littleE = 1; // assume little-endian (Intel-style) 299 union { 300 uint32_t num; 301 unsigned char uc[sizeof(uint32_t)]; 302 } endian; 303 304 endian.num = 1; 305 if (endian.uc[0] != (unsigned char) 1) { 306 littleE = 0; 307 } // if 308 return (littleE); 309 } // IsLittleEndian() 310 311 // Reverse the byte order of theValue; numBytes is number of bytes 312 void ReverseBytes(void* theValue, int numBytes) { 313 char* tempValue = NULL; 314 int i; 315 316 tempValue = new char [numBytes]; 317 if (tempValue != NULL) { 318 memcpy(tempValue, theValue, numBytes); 319 for (i = 0; i < numBytes; i++) 320 ((char*) theValue)[i] = tempValue[numBytes - i - 1]; 321 delete[] tempValue; 322 } else { 323 cerr << "Could not allocate memory in ReverseBytes()! Terminating\n"; 324 exit(1); 325 } // if/else 326 } // ReverseBytes() 327 328 // On Windows, display a warning and ask whether to continue. If the user elects 329 // not to continue, exit immediately. 330 void WinWarning(void) { 331 #ifdef _WIN32 332 cout << "\a************************************************************************\n" 333 << "Most versions of Windows cannot boot from a GPT disk except on a UEFI-based\n" 334 << "computer, and most varieties prior to Vista cannot read GPT disks. Therefore,\n" 335 << "you should exit now unless you understand the implications of converting MBR\n" 336 << "to GPT or creating a new GPT disk layout!\n" 337 << "************************************************************************\n\n"; 338 cout << "Are you SURE you want to continue? "; 339 if (GetYN() != 'Y') 340 exit(0); 341 #endif 342 } // WinWarning() 343
