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
34using 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.
39string 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.)
53int 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)
79char 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.
102uint64_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.
134uint64_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.
226string 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.
259unsigned 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.
275int 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....
297int 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
312void 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.
330void 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