1 /*
2 Implementation of GPTData class derivative with popt-based command
3 line processing
4 Copyright (C) 2010-2014 Roderick W. Smith
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include <string.h>
22 #include <string>
23 #include <iostream>
24 #include <sstream>
25 #include <errno.h>
26 #include "gptcl.h"
27
GPTDataCL(void)28 GPTDataCL::GPTDataCL(void) {
29 attributeOperation = backupFile = partName = hybrids = newPartInfo = NULL;
30 mbrParts = twoParts = outDevice = typeCode = partGUID = diskGUID = NULL;
31 alignment = DEFAULT_ALIGNMENT;
32 deletePartNum = infoPartNum = largestPartNum = bsdPartNum = 0;
33 tableSize = GPT_SIZE;
34 } // GPTDataCL constructor
35
GPTDataCL(string filename)36 GPTDataCL::GPTDataCL(string filename) {
37 } // GPTDataCL constructor with filename
38
~GPTDataCL(void)39 GPTDataCL::~GPTDataCL(void) {
40 } // GPTDataCL destructor
41
LoadBackupFile(string backupFile,int & saveData,int & neverSaveData)42 void GPTDataCL::LoadBackupFile(string backupFile, int &saveData, int &neverSaveData) {
43 if (LoadGPTBackup(backupFile) == 1) {
44 JustLooking(0);
45 saveData = 1;
46 } else {
47 saveData = 0;
48 neverSaveData = 1;
49 cerr << "Error loading backup file!\n";
50 } // else
51 } // GPTDataCL::LoadBackupFile()
52
53 // Perform the actions specified on the command line. This is necessarily one
54 // monster of a function!
55 // Returns values:
56 // 0 = success
57 // 1 = too few arguments
58 // 2 = error when reading partition table
59 // 3 = non-GPT disk and no -g option
60 // 4 = unable to save changes
61 // 8 = disk replication operation (-R) failed
DoOptions(int argc,char * argv[])62 int GPTDataCL::DoOptions(int argc, char* argv[]) {
63 GPTData secondDevice;
64 int opt, numOptions = 0, saveData = 0, neverSaveData = 0;
65 int partNum = 0, newPartNum = -1, saveNonGPT = 1, retval = 0, pretend = 0;
66 uint64_t low, high, startSector, endSector, sSize;
67 uint64_t temp; // temporary variable; free to use in any case
68 char *device;
69 string cmd, typeGUID, name;
70 PartType typeHelper;
71
72 struct poptOption theOptions[] =
73 {
74 {"attributes", 'A', POPT_ARG_STRING, &attributeOperation, 'A', "operate on partition attributes", "list|[partnum:show|or|nand|xor|=|set|clear|toggle|get[:bitnum|hexbitmask]]"},
75 {"set-alignment", 'a', POPT_ARG_INT, &alignment, 'a', "set sector alignment", "value"},
76 {"backup", 'b', POPT_ARG_STRING, &backupFile, 'b', "backup GPT to file", "file"},
77 {"change-name", 'c', POPT_ARG_STRING, &partName, 'c', "change partition's name", "partnum:name"},
78 {"recompute-chs", 'C', POPT_ARG_NONE, NULL, 'C', "recompute CHS values in protective/hybrid MBR", ""},
79 {"delete", 'd', POPT_ARG_INT, &deletePartNum, 'd', "delete a partition", "partnum"},
80 {"display-alignment", 'D', POPT_ARG_NONE, NULL, 'D', "show number of sectors per allocation block", ""},
81 {"move-second-header", 'e', POPT_ARG_NONE, NULL, 'e', "move second header to end of disk", ""},
82 {"end-of-largest", 'E', POPT_ARG_NONE, NULL, 'E', "show end of largest free block", ""},
83 {"first-in-largest", 'f', POPT_ARG_NONE, NULL, 'f', "show start of the largest free block", ""},
84 {"first-aligned-in-largest", 'F', POPT_ARG_NONE, NULL, 'F', "show start of the largest free block, aligned", ""},
85 {"mbrtogpt", 'g', POPT_ARG_NONE, NULL, 'g', "convert MBR to GPT", ""},
86 {"randomize-guids", 'G', POPT_ARG_NONE, NULL, 'G', "randomize disk and partition GUIDs", ""},
87 {"hybrid", 'h', POPT_ARG_STRING, &hybrids, 'h', "create hybrid MBR", "partnum[:partnum...]"},
88 {"info", 'i', POPT_ARG_INT, &infoPartNum, 'i', "show detailed information on partition", "partnum"},
89 {"skip-sync", 'j', POPT_ARG_NONE, NULL, 'j', "Don't atempt to sync and update the parittion table", ""},
90 {"load-backup", 'l', POPT_ARG_STRING, &backupFile, 'l', "load GPT backup from file", "file"},
91 {"list-types", 'L', POPT_ARG_NONE, NULL, 'L', "list known partition types", ""},
92 {"gpttombr", 'm', POPT_ARG_STRING, &mbrParts, 'm', "convert GPT to MBR", "partnum[:partnum...]"},
93 {"new", 'n', POPT_ARG_STRING, &newPartInfo, 'n', "create new partition", "partnum:start:end"},
94 {"largest-new", 'N', POPT_ARG_INT, &largestPartNum, 'N', "create largest possible new partition", "partnum"},
95 {"clear", 'o', POPT_ARG_NONE, NULL, 'o', "clear partition table", ""},
96 {"print", 'p', POPT_ARG_NONE, NULL, 'p', "print partition table", ""},
97 {"pretend", 'P', POPT_ARG_NONE, NULL, 'P', "make changes in memory, but don't write them", ""},
98 {"transpose", 'r', POPT_ARG_STRING, &twoParts, 'r', "transpose two partitions", "partnum:partnum"},
99 {"replicate", 'R', POPT_ARG_STRING, &outDevice, 'R', "replicate partition table", "device_filename"},
100 {"sort", 's', POPT_ARG_NONE, NULL, 's', "sort partition table entries", ""},
101 {"resize-table", 'S', POPT_ARG_INT, &tableSize, 'S', "resize partition table", "numparts"},
102 {"typecode", 't', POPT_ARG_STRING, &typeCode, 't', "change partition type code", "partnum:{hexcode|GUID}"},
103 {"transform-bsd", 'T', POPT_ARG_INT, &bsdPartNum, 'T', "transform BSD disklabel partition to GPT", "partnum"},
104 {"partition-guid", 'u', POPT_ARG_STRING, &partGUID, 'u', "set partition GUID", "partnum:guid"},
105 {"disk-guid", 'U', POPT_ARG_STRING, &diskGUID, 'U', "set disk GUID", "guid"},
106 {"verify", 'v', POPT_ARG_NONE, NULL, 'v', "check partition table integrity", ""},
107 {"version", 'V', POPT_ARG_NONE, NULL, 'V', "display version information", ""},
108 {"zap", 'z', POPT_ARG_NONE, NULL, 'z', "zap (destroy) GPT (but not MBR) data structures", ""},
109 {"zap-all", 'Z', POPT_ARG_NONE, NULL, 'Z', "zap (destroy) GPT and MBR data structures", ""},
110 POPT_AUTOHELP { NULL, 0, 0, NULL, 0, NULL, NULL }
111 };
112
113 // Create popt context...
114 poptCon = poptGetContext(NULL, argc, (const char**) argv, theOptions, 0);
115
116 poptSetOtherOptionHelp(poptCon, " [OPTION...] <device>");
117
118 if (argc < 2) {
119 poptPrintUsage(poptCon, stderr, 0);
120 return 1;
121 }
122
123 // Do one loop through the options to find the device filename and deal
124 // with options that don't require a device filename, to flag destructive
125 // (o, z, or Z) options, and to flag presence of a --pretend/-P option
126 while ((opt = poptGetNextOpt(poptCon)) > 0) {
127 switch (opt) {
128 case 'A':
129 cmd = GetString(attributeOperation, 1);
130 if (cmd == "list")
131 Attributes::ListAttributes();
132 break;
133 case 'L':
134 typeHelper.ShowAllTypes(0);
135 break;
136 case 'P':
137 pretend = 1;
138 break;
139 case 'V':
140 cout << "GPT fdisk (sgdisk) version " << GPTFDISK_VERSION << "\n\n";
141 break;
142 default:
143 break;
144 } // switch
145 numOptions++;
146 } // while
147
148 // Assume first non-option argument is the device filename....
149 device = (char*) poptGetArg(poptCon);
150 poptResetContext(poptCon);
151
152 if (device != NULL) {
153 JustLooking(); // reset as necessary
154 BeQuiet(); // Tell called functions to be less verbose & interactive
155 if (LoadPartitions((string) device)) {
156 if ((WhichWasUsed() == use_mbr) || (WhichWasUsed() == use_bsd))
157 saveNonGPT = 0; // flag so we don't overwrite unless directed to do so
158 sSize = GetBlockSize();
159 while ((opt = poptGetNextOpt(poptCon)) > 0) {
160 switch (opt) {
161 case 'A': {
162 if (cmd != "list") {
163 partNum = (int) GetInt(attributeOperation, 1) - 1;
164 if (partNum < 0)
165 partNum = newPartNum;
166 if ((partNum >= 0) && (partNum < (int) GetNumParts())) {
167 switch (ManageAttributes(partNum, GetString(attributeOperation, 2),
168 GetString(attributeOperation, 3))) {
169 case -1:
170 saveData = 0;
171 neverSaveData = 1;
172 break;
173 case 1:
174 JustLooking(0);
175 saveData = 1;
176 break;
177 default:
178 break;
179 } // switch
180 } else {
181 cerr << "Error: Invalid partition number " << partNum + 1 << "\n";
182 saveData = 0;
183 neverSaveData = 1;
184 } // if/else reasonable partition #
185 } // if (cmd != "list")
186 break;
187 } // case 'A':
188 case 'a':
189 SetAlignment(alignment);
190 break;
191 case 'b':
192 SaveGPTBackup(backupFile);
193 free(backupFile);
194 break;
195 case 'c':
196 cout << "Setting name!\n";
197 JustLooking(0);
198 partNum = (int) GetInt(partName, 1) - 1;
199 if (partNum < 0)
200 partNum = newPartNum;
201 cout << "partNum is " << partNum << "\n";
202 if ((partNum >= 0) && (partNum < (int) GetNumParts())) {
203 cout << "REALLY setting name!\n";
204 name = GetString(partName, 2);
205 if (SetName(partNum, (UnicodeString) name.c_str())) {
206 saveData = 1;
207 } else {
208 cerr << "Unable to set partition " << partNum + 1
209 << "'s name to '" << GetString(partName, 2) << "'!\n";
210 neverSaveData = 1;
211 } // if/else
212 free(partName);
213 }
214 break;
215 case 'C':
216 JustLooking(0);
217 RecomputeCHS();
218 saveData = 1;
219 break;
220 case 'd':
221 JustLooking(0);
222 if (DeletePartition(deletePartNum - 1) == 0) {
223 cerr << "Error " << errno << " deleting partition!\n";
224 neverSaveData = 1;
225 } else saveData = 1;
226 break;
227 case 'D':
228 cout << GetAlignment() << "\n";
229 break;
230 case 'e':
231 JustLooking(0);
232 MoveSecondHeaderToEnd();
233 saveData = 1;
234 break;
235 case 'E':
236 cout << FindLastInFree(FindFirstInLargest()) << "\n";
237 break;
238 case 'f':
239 cout << FindFirstInLargest() << "\n";
240 break;
241 case 'F':
242 temp = FindFirstInLargest();
243 Align(&temp);
244 cout << temp << "\n";
245 break;
246 case 'g':
247 JustLooking(0);
248 saveData = 1;
249 saveNonGPT = 1;
250 break;
251 case 'G':
252 JustLooking(0);
253 saveData = 1;
254 RandomizeGUIDs();
255 break;
256 case 'h':
257 JustLooking(0);
258 if (BuildMBR(hybrids, 1) == 1)
259 saveData = 1;
260 break;
261 case 'i':
262 ShowPartDetails(infoPartNum - 1);
263 break;
264 case 'j':
265 TurnOffSyncing();
266 break;
267 case 'l':
268 LoadBackupFile(backupFile, saveData, neverSaveData);
269 free(backupFile);
270 break;
271 case 'L':
272 break;
273 case 'm':
274 JustLooking(0);
275 if (BuildMBR(mbrParts, 0) == 1) {
276 if (!pretend) {
277 if (SaveMBR()) {
278 DestroyGPT();
279 } else
280 cerr << "Problem saving MBR!\n";
281 } // if
282 saveNonGPT = 0;
283 pretend = 1; // Not really, but works around problem if -g is used with this...
284 saveData = 0;
285 } // if
286 break;
287 case 'n':
288 JustLooking(0);
289 newPartNum = (int) GetInt(newPartInfo, 1) - 1;
290 if (newPartNum < 0)
291 newPartNum = FindFirstFreePart();
292 low = FindFirstInLargest();
293 Align(&low);
294 high = FindLastInFree(low);
295 startSector = IeeeToInt(GetString(newPartInfo, 2), sSize, low, high, low);
296 endSector = IeeeToInt(GetString(newPartInfo, 3), sSize, startSector, high, high);
297 if (CreatePartition(newPartNum, startSector, endSector)) {
298 saveData = 1;
299 } else {
300 cerr << "Could not create partition " << newPartNum + 1 << " from "
301 << startSector << " to " << endSector << "\n";
302 neverSaveData = 1;
303 } // if/else
304 free(newPartInfo);
305 break;
306 case 'N':
307 JustLooking(0);
308 startSector = FindFirstInLargest();
309 Align(&startSector);
310 endSector = FindLastInFree(startSector);
311 if (largestPartNum < 0)
312 largestPartNum = FindFirstFreePart();
313 if (CreatePartition(largestPartNum - 1, startSector, endSector)) {
314 saveData = 1;
315 } else {
316 cerr << "Could not create partition " << largestPartNum << " from "
317 << startSector << " to " << endSector << "\n";
318 neverSaveData = 1;
319 } // if/else
320 break;
321 case 'o':
322 JustLooking(0);
323 ClearGPTData();
324 saveData = 1;
325 break;
326 case 'p':
327 DisplayGPTData();
328 break;
329 case 'P':
330 pretend = 1;
331 break;
332 case 'r':
333 JustLooking(0);
334 uint64_t p1, p2;
335 p1 = GetInt(twoParts, 1) - 1;
336 p2 = GetInt(twoParts, 2) - 1;
337 if (SwapPartitions((uint32_t) p1, (uint32_t) p2) == 0) {
338 neverSaveData = 1;
339 cerr << "Cannot swap partitions " << p1 + 1 << " and " << p2 + 1 << "\n";
340 } else saveData = 1;
341 break;
342 case 'R':
343 secondDevice = *this;
344 secondDevice.SetDisk(outDevice);
345 secondDevice.JustLooking(0);
346 if (!secondDevice.SaveGPTData(1))
347 retval = 8;
348 break;
349 case 's':
350 JustLooking(0);
351 SortGPT();
352 saveData = 1;
353 break;
354 case 'S':
355 JustLooking(0);
356 if (SetGPTSize(tableSize) == 0)
357 neverSaveData = 1;
358 else
359 saveData = 1;
360 break;
361 case 't':
362 JustLooking(0);
363 partNum = (int) GetInt(typeCode, 1) - 1;
364 if (partNum < 0)
365 partNum = newPartNum;
366 if ((partNum >= 0) && (partNum < (int) GetNumParts())) {
367 // Remember the original hex value requested
368 string raw = GetString(typeCode, 2);
369 if (raw.size() == 4) {
370 typeRaw[partNum] = StrToHex(raw, 0);
371 }
372 typeHelper = GetString(typeCode, 2);
373 if ((typeHelper != (GUIDData) "00000000-0000-0000-0000-000000000000") &&
374 (ChangePartType(partNum, typeHelper))) {
375 saveData = 1;
376 } else {
377 cerr << "Could not change partition " << partNum + 1
378 << "'s type code to " << GetString(typeCode, 2) << "!\n";
379 neverSaveData = 1;
380 } // if/else
381 free(typeCode);
382 }
383 break;
384 case 'T':
385 JustLooking(0);
386 XFormDisklabel(bsdPartNum - 1);
387 saveData = 1;
388 break;
389 case 'u':
390 JustLooking(0);
391 saveData = 1;
392 partNum = (int) GetInt(partGUID, 1) - 1;
393 if (partNum < 0)
394 partNum = newPartNum;
395 if ((partNum >= 0) && (partNum < (int) GetNumParts())) {
396 SetPartitionGUID(partNum, GetString(partGUID, 2).c_str());
397 }
398 break;
399 case 'U':
400 JustLooking(0);
401 saveData = 1;
402 SetDiskGUID(diskGUID);
403 break;
404 case 'v':
405 Verify();
406 break;
407 case 'z':
408 if (!pretend) {
409 DestroyGPT();
410 } // if
411 saveNonGPT = 0;
412 saveData = 0;
413 break;
414 case 'Z':
415 if (!pretend) {
416 DestroyGPT();
417 DestroyMBR();
418 } // if
419 saveNonGPT = 0;
420 saveData = 0;
421 break;
422 default:
423 cerr << "Unknown option (-" << opt << ")!\n";
424 break;
425 } // switch
426 } // while
427 } else { // if loaded OK
428 poptResetContext(poptCon);
429 // Do a few types of operations even if there are problems....
430 while ((opt = poptGetNextOpt(poptCon)) > 0) {
431 switch (opt) {
432 case 'l':
433 LoadBackupFile(backupFile, saveData, neverSaveData);
434 cout << "Information: Loading backup partition table; will override earlier problems!\n";
435 free(backupFile);
436 retval = 0;
437 break;
438 case 'o':
439 JustLooking(0);
440 ClearGPTData();
441 saveData = 1;
442 cout << "Information: Creating fresh partition table; will override earlier problems!\n";
443 retval = 0;
444 break;
445 case 'v':
446 cout << "Verification may miss some problems or report too many!\n";
447 Verify();
448 break;
449 case 'z':
450 if (!pretend) {
451 DestroyGPT();
452 } // if
453 saveNonGPT = 0;
454 saveData = 0;
455 break;
456 case 'Z':
457 if (!pretend) {
458 DestroyGPT();
459 DestroyMBR();
460 } // if
461 saveNonGPT = 0;
462 saveData = 0;
463 break;
464 } // switch
465 } // while
466 retval = 2;
467 } // if/else loaded OK
468 if ((saveData) && (!neverSaveData) && (saveNonGPT) && (!pretend)) {
469 SaveGPTData(1);
470 }
471 if (saveData && (!saveNonGPT)) {
472 cout << "Non-GPT disk; not saving changes. Use -g to override.\n";
473 retval = 3;
474 } // if
475 if (neverSaveData) {
476 cerr << "Error encountered; not saving changes.\n";
477 retval = 4;
478 } // if
479 } // if (device != NULL)
480 poptFreeContext(poptCon);
481 return retval;
482 } // GPTDataCL::DoOptions()
483
484 // Create a hybrid or regular MBR from GPT data structures
BuildMBR(char * argument,int isHybrid)485 int GPTDataCL::BuildMBR(char* argument, int isHybrid) {
486 int numParts, allOK = 1, i, origPartNum;
487 MBRPart newPart;
488 BasicMBRData newMBR;
489
490 if (argument != NULL) {
491 numParts = CountColons(argument) + 1;
492 if (numParts <= (4 - isHybrid)) {
493 newMBR.SetDisk(GetDisk());
494 for (i = 0; i < numParts; i++) {
495 origPartNum = GetInt(argument, i + 1) - 1;
496 if (IsUsedPartNum(origPartNum) && (partitions[origPartNum].IsSizedForMBR() == MBR_SIZED_GOOD)) {
497 newPart.SetInclusion(PRIMARY);
498 newPart.SetLocation(operator[](origPartNum).GetFirstLBA(),
499 operator[](origPartNum).GetLengthLBA());
500 newPart.SetStatus(0);
501 newPart.SetType((uint8_t)(operator[](origPartNum).GetHexType() / 0x0100));
502 // If we were created with a specific hex type, use that instead
503 // of risking fidelity loss by doing a GUID-based lookup
504 if (typeRaw.count(origPartNum) == 1) {
505 newPart.SetType(typeRaw[origPartNum]);
506 }
507 newMBR.AddPart(i + isHybrid, newPart);
508 } else {
509 cerr << "Original partition " << origPartNum + 1 << " does not exist or is too big! Aborting operation!\n";
510 allOK = 0;
511 } // if/else
512 } // for
513 if (isHybrid) {
514 newPart.SetInclusion(PRIMARY);
515 newPart.SetLocation(1, newMBR.FindLastInFree(1));
516 newPart.SetStatus(0);
517 newPart.SetType(0xEE);
518 newMBR.AddPart(0, newPart);
519 } // if
520 if (allOK)
521 SetProtectiveMBR(newMBR);
522 } else allOK = 0;
523 } else allOK = 0;
524 if (!allOK)
525 cerr << "Problem creating MBR!\n";
526 return allOK;
527 } // GPTDataCL::BuildMBR()
528
529 // Returns the number of colons in argument string, ignoring the
530 // first character (thus, a leading colon is ignored, as GetString()
531 // does).
CountColons(char * argument)532 int CountColons(char* argument) {
533 int num = 0;
534
535 while ((argument[0] != '\0') && (argument = strchr(&argument[1], ':')))
536 num++;
537
538 return num;
539 } // GPTDataCL::CountColons()
540
541 // Extract integer data from argument string, which should be colon-delimited
GetInt(const string & argument,int itemNum)542 uint64_t GetInt(const string & argument, int itemNum) {
543 uint64_t retval;
544
545 istringstream inString(GetString(argument, itemNum));
546 inString >> retval;
547 return retval;
548 } // GPTDataCL::GetInt()
549
550 // Extract string data from argument string, which should be colon-delimited
551 // If string begins with a colon, that colon is skipped in the counting. If an
552 // invalid itemNum is specified, returns an empty string.
GetString(string argument,int itemNum)553 string GetString(string argument, int itemNum) {
554 size_t startPos = 0, endPos = 0;
555 string retVal = "";
556 int foundLast = 0;
557 int numFound = 0;
558
559 if (argument[0] == ':')
560 argument.erase(0, 1);
561 while ((numFound < itemNum) && (!foundLast)) {
562 endPos = argument.find(':', startPos);
563 numFound++;
564 if (endPos == string::npos) {
565 foundLast = 1;
566 endPos = argument.length();
567 } else if (numFound < itemNum) {
568 startPos = endPos + 1;
569 } // if/elseif
570 } // while
571 if ((numFound == itemNum) && (numFound > 0))
572 retVal = argument.substr(startPos, endPos - startPos);
573
574 return retVal;
575 } // GetString()
576