1 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 *
5 * Utility for ChromeOS-specific GPT partitions, Please see corresponding .c
6 * files for more details.
7 */
8
9 #include <errno.h>
10 #include <fcntl.h>
11 #include <getopt.h>
12 #ifndef HAVE_MACOS
13 #include <linux/major.h>
14 #include <mtd/mtd-user.h>
15 #endif
16 #include <stdarg.h>
17 #include <stdint.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <sys/ioctl.h>
22 #include <sys/mount.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26
27 #include "cgpt.h"
28 #include "cgptlib_internal.h"
29 #include "crc32.h"
30 #include "vboot_host.h"
31
32 static const char kErrorTag[] = "ERROR";
33 static const char kWarningTag[] = "WARNING";
34
LogToStderr(const char * tag,const char * format,va_list ap)35 static void LogToStderr(const char *tag, const char *format, va_list ap) {
36 fprintf(stderr, "%s: ", tag);
37 vfprintf(stderr, format, ap);
38 }
39
Error(const char * format,...)40 void Error(const char *format, ...) {
41 va_list ap;
42 va_start(ap, format);
43 LogToStderr(kErrorTag, format, ap);
44 va_end(ap);
45 }
46
Warning(const char * format,...)47 void Warning(const char *format, ...) {
48 va_list ap;
49 va_start(ap, format);
50 LogToStderr(kWarningTag, format, ap);
51 va_end(ap);
52 }
53
CheckValid(const struct drive * drive)54 int CheckValid(const struct drive *drive) {
55 if ((drive->gpt.valid_headers != MASK_BOTH) ||
56 (drive->gpt.valid_entries != MASK_BOTH)) {
57 Warning("One of the GPT headers/entries is invalid\n\n");
58 return CGPT_FAILED;
59 }
60 return CGPT_OK;
61 }
62
Load(struct drive * drive,uint8_t ** buf,const uint64_t sector,const uint64_t sector_bytes,const uint64_t sector_count)63 int Load(struct drive *drive, uint8_t **buf,
64 const uint64_t sector,
65 const uint64_t sector_bytes,
66 const uint64_t sector_count) {
67 int count; /* byte count to read */
68 int nread;
69
70 require(buf);
71 if (!sector_count || !sector_bytes) {
72 Error("%s() failed at line %d: sector_count=%ld, sector_bytes=%ld\n",
73 __FUNCTION__, __LINE__, sector_count, sector_bytes);
74 return CGPT_FAILED;
75 }
76 /* Make sure that sector_bytes * sector_count doesn't roll over. */
77 if (sector_bytes > (UINT64_MAX / sector_count)) {
78 Error("%s() failed at line %d: sector_count=%d, sector_bytes=%d\n",
79 __FUNCTION__, __LINE__, sector_count, sector_bytes);
80 return CGPT_FAILED;
81 }
82 count = sector_bytes * sector_count;
83 *buf = malloc(count);
84 require(*buf);
85
86 if (-1 == lseek(drive->fd, sector * sector_bytes, SEEK_SET)) {
87 Error("Can't seek: %s\n", strerror(errno));
88 goto error_free;
89 }
90
91 nread = read(drive->fd, *buf, count);
92 if (nread < count) {
93 Error("Can't read enough: %d, not %d\n", nread, count);
94 goto error_free;
95 }
96
97 return CGPT_OK;
98
99 error_free:
100 free(*buf);
101 *buf = 0;
102 return CGPT_FAILED;
103 }
104
105
ReadPMBR(struct drive * drive)106 int ReadPMBR(struct drive *drive) {
107 if (-1 == lseek(drive->fd, 0, SEEK_SET))
108 return CGPT_FAILED;
109
110 int nread = read(drive->fd, &drive->pmbr, sizeof(struct pmbr));
111 if (nread != sizeof(struct pmbr))
112 return CGPT_FAILED;
113
114 return CGPT_OK;
115 }
116
WritePMBR(struct drive * drive)117 int WritePMBR(struct drive *drive) {
118 if (-1 == lseek(drive->fd, 0, SEEK_SET))
119 return CGPT_FAILED;
120
121 int nwrote = write(drive->fd, &drive->pmbr, sizeof(struct pmbr));
122 if (nwrote != sizeof(struct pmbr))
123 return CGPT_FAILED;
124
125 return CGPT_OK;
126 }
127
Save(struct drive * drive,const uint8_t * buf,const uint64_t sector,const uint64_t sector_bytes,const uint64_t sector_count)128 int Save(struct drive *drive, const uint8_t *buf,
129 const uint64_t sector,
130 const uint64_t sector_bytes,
131 const uint64_t sector_count) {
132 int count; /* byte count to write */
133 int nwrote;
134
135 require(buf);
136 count = sector_bytes * sector_count;
137
138 if (-1 == lseek(drive->fd, sector * sector_bytes, SEEK_SET))
139 return CGPT_FAILED;
140
141 nwrote = write(drive->fd, buf, count);
142 if (nwrote < count)
143 return CGPT_FAILED;
144
145 return CGPT_OK;
146 }
147
GptLoad(struct drive * drive,uint32_t sector_bytes)148 static int GptLoad(struct drive *drive, uint32_t sector_bytes) {
149 drive->gpt.sector_bytes = sector_bytes;
150 if (drive->size % drive->gpt.sector_bytes) {
151 Error("Media size (%llu) is not a multiple of sector size(%d)\n",
152 (long long unsigned int)drive->size, drive->gpt.sector_bytes);
153 return -1;
154 }
155 drive->gpt.streaming_drive_sectors = drive->size / drive->gpt.sector_bytes;
156
157 /* TODO(namnguyen): Remove this and totally trust gpt_drive_sectors. */
158 if (!(drive->gpt.flags & GPT_FLAG_EXTERNAL)) {
159 drive->gpt.gpt_drive_sectors = drive->gpt.streaming_drive_sectors;
160 } /* Else, we trust gpt.gpt_drive_sectors. */
161
162 // Read the data.
163 if (CGPT_OK != Load(drive, &drive->gpt.primary_header,
164 GPT_PMBR_SECTORS,
165 drive->gpt.sector_bytes, GPT_HEADER_SECTORS)) {
166 Error("Cannot read primary GPT header\n");
167 return -1;
168 }
169 if (CGPT_OK != Load(drive, &drive->gpt.secondary_header,
170 drive->gpt.gpt_drive_sectors - GPT_PMBR_SECTORS,
171 drive->gpt.sector_bytes, GPT_HEADER_SECTORS)) {
172 Error("Cannot read secondary GPT header\n");
173 return -1;
174 }
175 GptHeader* primary_header = (GptHeader*)drive->gpt.primary_header;
176 if (CheckHeader(primary_header, 0, drive->gpt.streaming_drive_sectors,
177 drive->gpt.gpt_drive_sectors,
178 drive->gpt.flags) == 0) {
179 if (CGPT_OK != Load(drive, &drive->gpt.primary_entries,
180 primary_header->entries_lba,
181 drive->gpt.sector_bytes,
182 CalculateEntriesSectors(primary_header))) {
183 Error("Cannot read primary partition entry array\n");
184 return -1;
185 }
186 } else {
187 Warning("Primary GPT header is invalid\n");
188 }
189 GptHeader* secondary_header = (GptHeader*)drive->gpt.secondary_header;
190 if (CheckHeader(secondary_header, 1, drive->gpt.streaming_drive_sectors,
191 drive->gpt.gpt_drive_sectors,
192 drive->gpt.flags) == 0) {
193 if (CGPT_OK != Load(drive, &drive->gpt.secondary_entries,
194 secondary_header->entries_lba,
195 drive->gpt.sector_bytes,
196 CalculateEntriesSectors(secondary_header))) {
197 Error("Cannot read secondary partition entry array\n");
198 return -1;
199 }
200 } else {
201 Warning("Secondary GPT header is invalid\n");
202 }
203 return 0;
204 }
205
GptSave(struct drive * drive)206 static int GptSave(struct drive *drive) {
207 int errors = 0;
208 if (drive->gpt.modified & GPT_MODIFIED_HEADER1) {
209 if (CGPT_OK != Save(drive, drive->gpt.primary_header,
210 GPT_PMBR_SECTORS,
211 drive->gpt.sector_bytes, GPT_HEADER_SECTORS)) {
212 errors++;
213 Error("Cannot write primary header: %s\n", strerror(errno));
214 }
215 }
216
217 if (drive->gpt.modified & GPT_MODIFIED_HEADER2) {
218 if(CGPT_OK != Save(drive, drive->gpt.secondary_header,
219 drive->gpt.gpt_drive_sectors - GPT_PMBR_SECTORS,
220 drive->gpt.sector_bytes, GPT_HEADER_SECTORS)) {
221 errors++;
222 Error("Cannot write secondary header: %s\n", strerror(errno));
223 }
224 }
225 GptHeader* primary_header = (GptHeader*)drive->gpt.primary_header;
226 if (drive->gpt.modified & GPT_MODIFIED_ENTRIES1) {
227 if (CGPT_OK != Save(drive, drive->gpt.primary_entries,
228 primary_header->entries_lba,
229 drive->gpt.sector_bytes,
230 CalculateEntriesSectors(primary_header))) {
231 errors++;
232 Error("Cannot write primary entries: %s\n", strerror(errno));
233 }
234 }
235 GptHeader* secondary_header = (GptHeader*)drive->gpt.secondary_header;
236 if (drive->gpt.modified & GPT_MODIFIED_ENTRIES2) {
237 if (CGPT_OK != Save(drive, drive->gpt.secondary_entries,
238 secondary_header->entries_lba,
239 drive->gpt.sector_bytes,
240 CalculateEntriesSectors(secondary_header))) {
241 errors++;
242 Error("Cannot write secondary entries: %s\n", strerror(errno));
243 }
244 }
245
246 if (drive->gpt.primary_header)
247 free(drive->gpt.primary_header);
248 drive->gpt.primary_header = 0;
249 if (drive->gpt.primary_entries)
250 free(drive->gpt.primary_entries);
251 drive->gpt.primary_entries = 0;
252 if (drive->gpt.secondary_header)
253 free(drive->gpt.secondary_header);
254 drive->gpt.secondary_header = 0;
255 if (drive->gpt.secondary_entries)
256 free(drive->gpt.secondary_entries);
257 drive->gpt.secondary_entries = 0;
258 return errors ? -1 : 0;
259 }
260
261 /*
262 * Query drive size and bytes per sector. Return zero on success. On error,
263 * -1 is returned and errno is set appropriately.
264 */
ObtainDriveSize(int fd,uint64_t * size,uint32_t * sector_bytes)265 static int ObtainDriveSize(int fd, uint64_t* size, uint32_t* sector_bytes) {
266 struct stat stat;
267 if (fstat(fd, &stat) == -1) {
268 return -1;
269 }
270 #ifndef HAVE_MACOS
271 if ((stat.st_mode & S_IFMT) != S_IFREG) {
272 if (ioctl(fd, BLKGETSIZE64, size) < 0) {
273 return -1;
274 }
275 if (ioctl(fd, BLKSSZGET, sector_bytes) < 0) {
276 return -1;
277 }
278 } else {
279 *sector_bytes = 512; /* bytes */
280 *size = stat.st_size;
281 }
282 #else
283 *sector_bytes = 512; /* bytes */
284 *size = stat.st_size;
285 #endif
286 return 0;
287 }
288
DriveOpen(const char * drive_path,struct drive * drive,int mode,uint64_t drive_size)289 int DriveOpen(const char *drive_path, struct drive *drive, int mode,
290 uint64_t drive_size) {
291 uint32_t sector_bytes;
292
293 require(drive_path);
294 require(drive);
295
296 // Clear struct for proper error handling.
297 memset(drive, 0, sizeof(struct drive));
298
299 drive->fd = open(drive_path, mode |
300 #ifndef HAVE_MACOS
301 O_LARGEFILE |
302 #endif
303 O_NOFOLLOW);
304 if (drive->fd == -1) {
305 Error("Can't open %s: %s\n", drive_path, strerror(errno));
306 return CGPT_FAILED;
307 }
308
309 sector_bytes = 512;
310 uint64_t gpt_drive_size;
311 if (ObtainDriveSize(drive->fd, &gpt_drive_size, §or_bytes) != 0) {
312 Error("Can't get drive size and bytes per sector for %s: %s\n",
313 drive_path, strerror(errno));
314 goto error_close;
315 }
316
317 drive->gpt.gpt_drive_sectors = gpt_drive_size / sector_bytes;
318 if (drive_size == 0) {
319 drive->size = gpt_drive_size;
320 drive->gpt.flags = 0;
321 } else {
322 drive->size = drive_size;
323 drive->gpt.flags = GPT_FLAG_EXTERNAL;
324 }
325
326
327 if (GptLoad(drive, sector_bytes)) {
328 goto error_close;
329 }
330
331 // We just load the data. Caller must validate it.
332 return CGPT_OK;
333
334 error_close:
335 (void) DriveClose(drive, 0);
336 return CGPT_FAILED;
337 }
338
339
DriveClose(struct drive * drive,int update_as_needed)340 int DriveClose(struct drive *drive, int update_as_needed) {
341 int errors = 0;
342
343 if (update_as_needed) {
344 if (GptSave(drive)) {
345 errors++;
346 }
347 }
348
349 // Sync early! Only sync file descriptor here, and leave the whole system sync
350 // outside cgpt because whole system sync would trigger tons of disk accesses
351 // and timeout tests.
352 fsync(drive->fd);
353
354 close(drive->fd);
355
356 return errors ? CGPT_FAILED : CGPT_OK;
357 }
358
359
360 /* GUID conversion functions. Accepted format:
361 *
362 * "C12A7328-F81F-11D2-BA4B-00A0C93EC93B"
363 *
364 * Returns CGPT_OK if parsing is successful; otherwise CGPT_FAILED.
365 */
StrToGuid(const char * str,Guid * guid)366 int StrToGuid(const char *str, Guid *guid) {
367 uint32_t time_low;
368 uint16_t time_mid;
369 uint16_t time_high_and_version;
370 unsigned int chunk[11];
371
372 if (11 != sscanf(str, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
373 chunk+0,
374 chunk+1,
375 chunk+2,
376 chunk+3,
377 chunk+4,
378 chunk+5,
379 chunk+6,
380 chunk+7,
381 chunk+8,
382 chunk+9,
383 chunk+10)) {
384 printf("FAILED\n");
385 return CGPT_FAILED;
386 }
387
388 time_low = chunk[0] & 0xffffffff;
389 time_mid = chunk[1] & 0xffff;
390 time_high_and_version = chunk[2] & 0xffff;
391
392 guid->u.Uuid.time_low = htole32(time_low);
393 guid->u.Uuid.time_mid = htole16(time_mid);
394 guid->u.Uuid.time_high_and_version = htole16(time_high_and_version);
395
396 guid->u.Uuid.clock_seq_high_and_reserved = chunk[3] & 0xff;
397 guid->u.Uuid.clock_seq_low = chunk[4] & 0xff;
398 guid->u.Uuid.node[0] = chunk[5] & 0xff;
399 guid->u.Uuid.node[1] = chunk[6] & 0xff;
400 guid->u.Uuid.node[2] = chunk[7] & 0xff;
401 guid->u.Uuid.node[3] = chunk[8] & 0xff;
402 guid->u.Uuid.node[4] = chunk[9] & 0xff;
403 guid->u.Uuid.node[5] = chunk[10] & 0xff;
404
405 return CGPT_OK;
406 }
GuidToStr(const Guid * guid,char * str,unsigned int buflen)407 void GuidToStr(const Guid *guid, char *str, unsigned int buflen) {
408 require(buflen >= GUID_STRLEN);
409 require(snprintf(str, buflen,
410 "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
411 le32toh(guid->u.Uuid.time_low),
412 le16toh(guid->u.Uuid.time_mid),
413 le16toh(guid->u.Uuid.time_high_and_version),
414 guid->u.Uuid.clock_seq_high_and_reserved,
415 guid->u.Uuid.clock_seq_low,
416 guid->u.Uuid.node[0], guid->u.Uuid.node[1],
417 guid->u.Uuid.node[2], guid->u.Uuid.node[3],
418 guid->u.Uuid.node[4], guid->u.Uuid.node[5]) == GUID_STRLEN-1);
419 }
420
421 /* Convert possibly unterminated UTF16 string to UTF8.
422 * Caller must prepare enough space for UTF8, which could be up to
423 * twice the byte length of UTF16 string plus the terminating '\0'.
424 * See the following table for encoding lengths.
425 *
426 * Code point UTF16 UTF8
427 * 0x0000-0x007F 2 bytes 1 byte
428 * 0x0080-0x07FF 2 bytes 2 bytes
429 * 0x0800-0xFFFF 2 bytes 3 bytes
430 * 0x10000-0x10FFFF 4 bytes 4 bytes
431 *
432 * This function uses a simple state meachine to convert UTF-16 char(s) to
433 * a code point. Once a code point is parsed out, the state machine throws
434 * out sequencial UTF-8 chars in one time.
435 *
436 * Return: CGPT_OK --- all character are converted successfully.
437 * CGPT_FAILED --- convert error, i.e. output buffer is too short.
438 */
UTF16ToUTF8(const uint16_t * utf16,unsigned int maxinput,uint8_t * utf8,unsigned int maxoutput)439 int UTF16ToUTF8(const uint16_t *utf16, unsigned int maxinput,
440 uint8_t *utf8, unsigned int maxoutput)
441 {
442 size_t s16idx, s8idx;
443 uint32_t code_point = 0;
444 int code_point_ready = 1; // code point is ready to output.
445 int retval = CGPT_OK;
446
447 if (!utf16 || !maxinput || !utf8 || !maxoutput)
448 return CGPT_FAILED;
449
450 maxoutput--; /* plan for termination now */
451
452 for (s16idx = s8idx = 0;
453 s16idx < maxinput && utf16[s16idx] && maxoutput;
454 s16idx++) {
455 uint16_t codeunit = le16toh(utf16[s16idx]);
456
457 if (code_point_ready) {
458 if (codeunit >= 0xD800 && codeunit <= 0xDBFF) {
459 /* high surrogate, need the low surrogate. */
460 code_point_ready = 0;
461 code_point = (codeunit & 0x03FF) + 0x0040;
462 } else {
463 /* BMP char, output it. */
464 code_point = codeunit;
465 }
466 } else {
467 /* expect the low surrogate */
468 if (codeunit >= 0xDC00 && codeunit <= 0xDFFF) {
469 code_point = (code_point << 10) | (codeunit & 0x03FF);
470 code_point_ready = 1;
471 } else {
472 /* the second code unit is NOT the low surrogate. Unexpected. */
473 code_point_ready = 0;
474 retval = CGPT_FAILED;
475 break;
476 }
477 }
478
479 /* If UTF code point is ready, output it. */
480 if (code_point_ready) {
481 require(code_point <= 0x10FFFF);
482 if (code_point <= 0x7F && maxoutput >= 1) {
483 maxoutput -= 1;
484 utf8[s8idx++] = code_point & 0x7F;
485 } else if (code_point <= 0x7FF && maxoutput >= 2) {
486 maxoutput -= 2;
487 utf8[s8idx++] = 0xC0 | (code_point >> 6);
488 utf8[s8idx++] = 0x80 | (code_point & 0x3F);
489 } else if (code_point <= 0xFFFF && maxoutput >= 3) {
490 maxoutput -= 3;
491 utf8[s8idx++] = 0xE0 | (code_point >> 12);
492 utf8[s8idx++] = 0x80 | ((code_point >> 6) & 0x3F);
493 utf8[s8idx++] = 0x80 | (code_point & 0x3F);
494 } else if (code_point <= 0x10FFFF && maxoutput >= 4) {
495 maxoutput -= 4;
496 utf8[s8idx++] = 0xF0 | (code_point >> 18);
497 utf8[s8idx++] = 0x80 | ((code_point >> 12) & 0x3F);
498 utf8[s8idx++] = 0x80 | ((code_point >> 6) & 0x3F);
499 utf8[s8idx++] = 0x80 | (code_point & 0x3F);
500 } else {
501 /* buffer underrun */
502 retval = CGPT_FAILED;
503 break;
504 }
505 }
506 }
507 utf8[s8idx++] = 0;
508 return retval;
509 }
510
511 /* Convert UTF8 string to UTF16. The UTF8 string must be null-terminated.
512 * Caller must prepare enough space for UTF16, including a terminating 0x0000.
513 * See the following table for encoding lengths. In any case, the caller
514 * just needs to prepare the byte length of UTF8 plus the terminating 0x0000.
515 *
516 * Code point UTF16 UTF8
517 * 0x0000-0x007F 2 bytes 1 byte
518 * 0x0080-0x07FF 2 bytes 2 bytes
519 * 0x0800-0xFFFF 2 bytes 3 bytes
520 * 0x10000-0x10FFFF 4 bytes 4 bytes
521 *
522 * This function converts UTF8 chars to a code point first. Then, convrts it
523 * to UTF16 code unit(s).
524 *
525 * Return: CGPT_OK --- all character are converted successfully.
526 * CGPT_FAILED --- convert error, i.e. output buffer is too short.
527 */
UTF8ToUTF16(const uint8_t * utf8,uint16_t * utf16,unsigned int maxoutput)528 int UTF8ToUTF16(const uint8_t *utf8, uint16_t *utf16, unsigned int maxoutput)
529 {
530 size_t s16idx, s8idx;
531 uint32_t code_point = 0;
532 unsigned int expected_units = 1;
533 unsigned int decoded_units = 1;
534 int retval = CGPT_OK;
535
536 if (!utf8 || !utf16 || !maxoutput)
537 return CGPT_FAILED;
538
539 maxoutput--; /* plan for termination */
540
541 for (s8idx = s16idx = 0;
542 utf8[s8idx] && maxoutput;
543 s8idx++) {
544 uint8_t code_unit;
545 code_unit = utf8[s8idx];
546
547 if (expected_units != decoded_units) {
548 /* Trailing bytes of multi-byte character */
549 if ((code_unit & 0xC0) == 0x80) {
550 code_point = (code_point << 6) | (code_unit & 0x3F);
551 ++decoded_units;
552 } else {
553 /* Unexpected code unit. */
554 retval = CGPT_FAILED;
555 break;
556 }
557 } else {
558 /* parsing a new code point. */
559 decoded_units = 1;
560 if (code_unit <= 0x7F) {
561 code_point = code_unit;
562 expected_units = 1;
563 } else if (code_unit <= 0xBF) {
564 /* 0x80-0xBF must NOT be the heading byte unit of a new code point. */
565 retval = CGPT_FAILED;
566 break;
567 } else if (code_unit >= 0xC2 && code_unit <= 0xDF) {
568 code_point = code_unit & 0x1F;
569 expected_units = 2;
570 } else if (code_unit >= 0xE0 && code_unit <= 0xEF) {
571 code_point = code_unit & 0x0F;
572 expected_units = 3;
573 } else if (code_unit >= 0xF0 && code_unit <= 0xF4) {
574 code_point = code_unit & 0x07;
575 expected_units = 4;
576 } else {
577 /* illegal code unit: 0xC0-0xC1, 0xF5-0xFF */
578 retval = CGPT_FAILED;
579 break;
580 }
581 }
582
583 /* If no more unit is needed, output the UTF16 unit(s). */
584 if ((retval == CGPT_OK) &&
585 (expected_units == decoded_units)) {
586 /* Check if the encoding is the shortest possible UTF-8 sequence. */
587 switch (expected_units) {
588 case 2:
589 if (code_point <= 0x7F) retval = CGPT_FAILED;
590 break;
591 case 3:
592 if (code_point <= 0x7FF) retval = CGPT_FAILED;
593 break;
594 case 4:
595 if (code_point <= 0xFFFF) retval = CGPT_FAILED;
596 break;
597 }
598 if (retval == CGPT_FAILED) break; /* leave immediately */
599
600 if ((code_point <= 0xD7FF) ||
601 (code_point >= 0xE000 && code_point <= 0xFFFF)) {
602 utf16[s16idx++] = code_point;
603 maxoutput -= 1;
604 } else if (code_point >= 0x10000 && code_point <= 0x10FFFF &&
605 maxoutput >= 2) {
606 utf16[s16idx++] = 0xD800 | ((code_point >> 10) - 0x0040);
607 utf16[s16idx++] = 0xDC00 | (code_point & 0x03FF);
608 maxoutput -= 2;
609 } else {
610 /* Three possibilities fall into here. Both are failure cases.
611 * a. surrogate pair (non-BMP characters; 0xD800~0xDFFF)
612 * b. invalid code point > 0x10FFFF
613 * c. buffer underrun
614 */
615 retval = CGPT_FAILED;
616 break;
617 }
618 }
619 }
620
621 /* A null-terminator shows up before the UTF8 sequence ends. */
622 if (expected_units != decoded_units) {
623 retval = CGPT_FAILED;
624 }
625
626 utf16[s16idx++] = 0;
627 return retval;
628 }
629
630 /* global types to compare against */
631 const Guid guid_chromeos_firmware = GPT_ENT_TYPE_CHROMEOS_FIRMWARE;
632 const Guid guid_chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
633 const Guid guid_chromeos_rootfs = GPT_ENT_TYPE_CHROMEOS_ROOTFS;
634 const Guid guid_linux_data = GPT_ENT_TYPE_LINUX_DATA;
635 const Guid guid_chromeos_reserved = GPT_ENT_TYPE_CHROMEOS_RESERVED;
636 const Guid guid_efi = GPT_ENT_TYPE_EFI;
637 const Guid guid_unused = GPT_ENT_TYPE_UNUSED;
638
639 const static struct {
640 const Guid *type;
641 char *name;
642 char *description;
643 } supported_types[] = {
644 {&guid_chromeos_firmware, "firmware", "ChromeOS firmware"},
645 {&guid_chromeos_kernel, "kernel", "ChromeOS kernel"},
646 {&guid_chromeos_rootfs, "rootfs", "ChromeOS rootfs"},
647 {&guid_linux_data, "data", "Linux data"},
648 {&guid_chromeos_reserved, "reserved", "ChromeOS reserved"},
649 {&guid_efi, "efi", "EFI System Partition"},
650 {&guid_unused, "unused", "Unused (nonexistent) partition"},
651 };
652
653 /* Resolves human-readable GPT type.
654 * Returns CGPT_OK if found.
655 * Returns CGPT_FAILED if no known type found. */
ResolveType(const Guid * type,char * buf)656 int ResolveType(const Guid *type, char *buf) {
657 int i;
658 for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
659 if (!memcmp(type, supported_types[i].type, sizeof(Guid))) {
660 strcpy(buf, supported_types[i].description);
661 return CGPT_OK;
662 }
663 }
664 return CGPT_FAILED;
665 }
666
SupportedType(const char * name,Guid * type)667 int SupportedType(const char *name, Guid *type) {
668 int i;
669 for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
670 if (!strcmp(name, supported_types[i].name)) {
671 memcpy(type, supported_types[i].type, sizeof(Guid));
672 return CGPT_OK;
673 }
674 }
675 return CGPT_FAILED;
676 }
677
PrintTypes(void)678 void PrintTypes(void) {
679 int i;
680 printf("The partition type may also be given as one of these aliases:\n\n");
681 for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
682 printf(" %-10s %s\n", supported_types[i].name,
683 supported_types[i].description);
684 }
685 printf("\n");
686 }
687
GetGptHeader(const GptData * gpt)688 static GptHeader* GetGptHeader(const GptData *gpt) {
689 if (gpt->valid_headers & MASK_PRIMARY)
690 return (GptHeader*)gpt->primary_header;
691 else if (gpt->valid_headers & MASK_SECONDARY)
692 return (GptHeader*)gpt->secondary_header;
693 else
694 return 0;
695 }
696
GetNumberOfEntries(const struct drive * drive)697 uint32_t GetNumberOfEntries(const struct drive *drive) {
698 GptHeader *header = GetGptHeader(&drive->gpt);
699 if (!header)
700 return 0;
701 return header->number_of_entries;
702 }
703
704
GetEntry(GptData * gpt,int secondary,uint32_t entry_index)705 GptEntry *GetEntry(GptData *gpt, int secondary, uint32_t entry_index) {
706 GptHeader *header = GetGptHeader(gpt);
707 uint8_t *entries;
708 uint32_t stride = header->size_of_entry;
709 require(stride);
710 require(entry_index < header->number_of_entries);
711
712 if (secondary == PRIMARY) {
713 entries = gpt->primary_entries;
714 } else if (secondary == SECONDARY) {
715 entries = gpt->secondary_entries;
716 } else { /* ANY_VALID */
717 require(secondary == ANY_VALID);
718 if (gpt->valid_entries & MASK_PRIMARY) {
719 entries = gpt->primary_entries;
720 } else {
721 require(gpt->valid_entries & MASK_SECONDARY);
722 entries = gpt->secondary_entries;
723 }
724 }
725
726 return (GptEntry*)(&entries[stride * entry_index]);
727 }
728
SetPriority(struct drive * drive,int secondary,uint32_t entry_index,int priority)729 void SetPriority(struct drive *drive, int secondary, uint32_t entry_index,
730 int priority) {
731 require(priority >= 0 && priority <= CGPT_ATTRIBUTE_MAX_PRIORITY);
732 GptEntry *entry;
733 entry = GetEntry(&drive->gpt, secondary, entry_index);
734 SetEntryPriority(entry, priority);
735 }
736
GetPriority(struct drive * drive,int secondary,uint32_t entry_index)737 int GetPriority(struct drive *drive, int secondary, uint32_t entry_index) {
738 GptEntry *entry;
739 entry = GetEntry(&drive->gpt, secondary, entry_index);
740 return GetEntryPriority(entry);
741 }
742
SetTries(struct drive * drive,int secondary,uint32_t entry_index,int tries)743 void SetTries(struct drive *drive, int secondary, uint32_t entry_index,
744 int tries) {
745 require(tries >= 0 && tries <= CGPT_ATTRIBUTE_MAX_TRIES);
746 GptEntry *entry;
747 entry = GetEntry(&drive->gpt, secondary, entry_index);
748 SetEntryTries(entry, tries);
749 }
750
GetTries(struct drive * drive,int secondary,uint32_t entry_index)751 int GetTries(struct drive *drive, int secondary, uint32_t entry_index) {
752 GptEntry *entry;
753 entry = GetEntry(&drive->gpt, secondary, entry_index);
754 return GetEntryTries(entry);
755 }
756
SetSuccessful(struct drive * drive,int secondary,uint32_t entry_index,int success)757 void SetSuccessful(struct drive *drive, int secondary, uint32_t entry_index,
758 int success) {
759 require(success >= 0 && success <= CGPT_ATTRIBUTE_MAX_SUCCESSFUL);
760 GptEntry *entry;
761 entry = GetEntry(&drive->gpt, secondary, entry_index);
762 SetEntrySuccessful(entry, success);
763 }
764
GetSuccessful(struct drive * drive,int secondary,uint32_t entry_index)765 int GetSuccessful(struct drive *drive, int secondary, uint32_t entry_index) {
766 GptEntry *entry;
767 entry = GetEntry(&drive->gpt, secondary, entry_index);
768 return GetEntrySuccessful(entry);
769 }
770
SetRaw(struct drive * drive,int secondary,uint32_t entry_index,uint32_t raw)771 void SetRaw(struct drive *drive, int secondary, uint32_t entry_index,
772 uint32_t raw) {
773 GptEntry *entry;
774 entry = GetEntry(&drive->gpt, secondary, entry_index);
775 entry->attrs.fields.gpt_att = (uint16_t)raw;
776 }
777
UpdateAllEntries(struct drive * drive)778 void UpdateAllEntries(struct drive *drive) {
779 RepairEntries(&drive->gpt, MASK_PRIMARY);
780 RepairHeader(&drive->gpt, MASK_PRIMARY);
781
782 drive->gpt.modified |= (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
783 GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2);
784 UpdateCrc(&drive->gpt);
785 }
786
IsUnused(struct drive * drive,int secondary,uint32_t index)787 int IsUnused(struct drive *drive, int secondary, uint32_t index) {
788 GptEntry *entry;
789 entry = GetEntry(&drive->gpt, secondary, index);
790 return GuidIsZero(&entry->type);
791 }
792
IsKernel(struct drive * drive,int secondary,uint32_t index)793 int IsKernel(struct drive *drive, int secondary, uint32_t index) {
794 GptEntry *entry;
795 entry = GetEntry(&drive->gpt, secondary, index);
796 return GuidEqual(&entry->type, &guid_chromeos_kernel);
797 }
798
799
800 #define TOSTRING(A) #A
GptError(int errnum)801 const char *GptError(int errnum) {
802 const char *error_string[] = {
803 TOSTRING(GPT_SUCCESS),
804 TOSTRING(GPT_ERROR_NO_VALID_KERNEL),
805 TOSTRING(GPT_ERROR_INVALID_HEADERS),
806 TOSTRING(GPT_ERROR_INVALID_ENTRIES),
807 TOSTRING(GPT_ERROR_INVALID_SECTOR_SIZE),
808 TOSTRING(GPT_ERROR_INVALID_SECTOR_NUMBER),
809 TOSTRING(GPT_ERROR_INVALID_UPDATE_TYPE)
810 };
811 if (errnum < 0 || errnum >= ARRAY_COUNT(error_string))
812 return "<illegal value>";
813 return error_string[errnum];
814 }
815
816 /* Update CRC value if necessary. */
UpdateCrc(GptData * gpt)817 void UpdateCrc(GptData *gpt) {
818 GptHeader *primary_header, *secondary_header;
819
820 primary_header = (GptHeader*)gpt->primary_header;
821 secondary_header = (GptHeader*)gpt->secondary_header;
822
823 if (gpt->modified & GPT_MODIFIED_ENTRIES1 &&
824 memcmp(primary_header, GPT_HEADER_SIGNATURE2,
825 GPT_HEADER_SIGNATURE_SIZE)) {
826 size_t entries_size = primary_header->size_of_entry *
827 primary_header->number_of_entries;
828 primary_header->entries_crc32 =
829 Crc32(gpt->primary_entries, entries_size);
830 }
831 if (gpt->modified & GPT_MODIFIED_ENTRIES2) {
832 size_t entries_size = secondary_header->size_of_entry *
833 secondary_header->number_of_entries;
834 secondary_header->entries_crc32 =
835 Crc32(gpt->secondary_entries, entries_size);
836 }
837 if (gpt->modified & GPT_MODIFIED_HEADER1) {
838 primary_header->header_crc32 = 0;
839 primary_header->header_crc32 = Crc32(
840 (const uint8_t *)primary_header, sizeof(GptHeader));
841 }
842 if (gpt->modified & GPT_MODIFIED_HEADER2) {
843 secondary_header->header_crc32 = 0;
844 secondary_header->header_crc32 = Crc32(
845 (const uint8_t *)secondary_header, sizeof(GptHeader));
846 }
847 }
848 /* Two headers are NOT bitwise identical. For example, my_lba pointers to header
849 * itself so that my_lba in primary and secondary is definitely different.
850 * Only the following fields should be identical.
851 *
852 * first_usable_lba
853 * last_usable_lba
854 * number_of_entries
855 * size_of_entry
856 * disk_uuid
857 *
858 * If any of above field are not matched, overwrite secondary with primary since
859 * we always trust primary.
860 * If any one of header is invalid, copy from another. */
IsSynonymous(const GptHeader * a,const GptHeader * b)861 int IsSynonymous(const GptHeader* a, const GptHeader* b) {
862 if ((a->first_usable_lba == b->first_usable_lba) &&
863 (a->last_usable_lba == b->last_usable_lba) &&
864 (a->number_of_entries == b->number_of_entries) &&
865 (a->size_of_entry == b->size_of_entry) &&
866 (!memcmp(&a->disk_uuid, &b->disk_uuid, sizeof(Guid))))
867 return 1;
868 return 0;
869 }
870
871 /* Primary entries and secondary entries should be bitwise identical.
872 * If two entries tables are valid, compare them. If not the same,
873 * overwrites secondary with primary (primary always has higher priority),
874 * and marks secondary as modified.
875 * If only one is valid, overwrites invalid one.
876 * If all are invalid, does nothing.
877 * This function returns bit masks for GptData.modified field.
878 * Note that CRC is NOT re-computed in this function.
879 */
RepairEntries(GptData * gpt,const uint32_t valid_entries)880 uint8_t RepairEntries(GptData *gpt, const uint32_t valid_entries) {
881 /* If we have an alternate GPT header signature, don't overwrite
882 * the secondary GPT with the primary one as that might wipe the
883 * partition table. Also don't overwrite the primary one with the
884 * secondary one as that will stop Windows from booting. */
885 GptHeader* h = (GptHeader*)(gpt->primary_header);
886 if (!memcmp(h->signature, GPT_HEADER_SIGNATURE2, GPT_HEADER_SIGNATURE_SIZE))
887 return 0;
888
889 if (gpt->valid_headers & MASK_PRIMARY) {
890 h = (GptHeader*)gpt->primary_header;
891 } else if (gpt->valid_headers & MASK_SECONDARY) {
892 h = (GptHeader*)gpt->secondary_header;
893 } else {
894 /* We cannot trust any header, don't update entries. */
895 return 0;
896 }
897
898 size_t entries_size = h->number_of_entries * h->size_of_entry;
899 if (valid_entries == MASK_BOTH) {
900 if (memcmp(gpt->primary_entries, gpt->secondary_entries, entries_size)) {
901 memcpy(gpt->secondary_entries, gpt->primary_entries, entries_size);
902 return GPT_MODIFIED_ENTRIES2;
903 }
904 } else if (valid_entries == MASK_PRIMARY) {
905 memcpy(gpt->secondary_entries, gpt->primary_entries, entries_size);
906 return GPT_MODIFIED_ENTRIES2;
907 } else if (valid_entries == MASK_SECONDARY) {
908 memcpy(gpt->primary_entries, gpt->secondary_entries, entries_size);
909 return GPT_MODIFIED_ENTRIES1;
910 }
911
912 return 0;
913 }
914
915 /* The above five fields are shared between primary and secondary headers.
916 * We can recover one header from another through copying those fields. */
CopySynonymousParts(GptHeader * target,const GptHeader * source)917 void CopySynonymousParts(GptHeader* target, const GptHeader* source) {
918 target->first_usable_lba = source->first_usable_lba;
919 target->last_usable_lba = source->last_usable_lba;
920 target->number_of_entries = source->number_of_entries;
921 target->size_of_entry = source->size_of_entry;
922 memcpy(&target->disk_uuid, &source->disk_uuid, sizeof(Guid));
923 }
924
925 /* This function repairs primary and secondary headers if possible.
926 * If both headers are valid (CRC32 is correct) but
927 * a) indicate inconsistent usable LBA ranges,
928 * b) inconsistent partition entry size and number,
929 * c) inconsistent disk_uuid,
930 * we will use the primary header to overwrite secondary header.
931 * If primary is invalid (CRC32 is wrong), then we repair it from secondary.
932 * If secondary is invalid (CRC32 is wrong), then we repair it from primary.
933 * This function returns the bitmasks for modified header.
934 * Note that CRC value is NOT re-computed in this function. UpdateCrc() will
935 * do it later.
936 */
RepairHeader(GptData * gpt,const uint32_t valid_headers)937 uint8_t RepairHeader(GptData *gpt, const uint32_t valid_headers) {
938 GptHeader *primary_header, *secondary_header;
939
940 primary_header = (GptHeader*)gpt->primary_header;
941 secondary_header = (GptHeader*)gpt->secondary_header;
942
943 if (valid_headers == MASK_BOTH) {
944 if (!IsSynonymous(primary_header, secondary_header)) {
945 CopySynonymousParts(secondary_header, primary_header);
946 return GPT_MODIFIED_HEADER2;
947 }
948 } else if (valid_headers == MASK_PRIMARY) {
949 memcpy(secondary_header, primary_header, sizeof(GptHeader));
950 secondary_header->my_lba = gpt->gpt_drive_sectors - 1; /* the last sector */
951 secondary_header->alternate_lba = primary_header->my_lba;
952 secondary_header->entries_lba = secondary_header->my_lba -
953 CalculateEntriesSectors(primary_header);
954 return GPT_MODIFIED_HEADER2;
955 } else if (valid_headers == MASK_SECONDARY) {
956 memcpy(primary_header, secondary_header, sizeof(GptHeader));
957 primary_header->my_lba = GPT_PMBR_SECTORS; /* the second sector on drive */
958 primary_header->alternate_lba = secondary_header->my_lba;
959 /* TODO (namnguyen): Preserve (header, entries) padding space. */
960 primary_header->entries_lba = primary_header->my_lba + GPT_HEADER_SECTORS;
961 return GPT_MODIFIED_HEADER1;
962 }
963
964 return 0;
965 }
966
CgptGetNumNonEmptyPartitions(CgptShowParams * params)967 int CgptGetNumNonEmptyPartitions(CgptShowParams *params) {
968 struct drive drive;
969 int gpt_retval;
970 int retval;
971
972 if (params == NULL)
973 return CGPT_FAILED;
974
975 if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDONLY,
976 params->drive_size))
977 return CGPT_FAILED;
978
979 if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
980 Error("GptSanityCheck() returned %d: %s\n",
981 gpt_retval, GptError(gpt_retval));
982 retval = CGPT_FAILED;
983 goto done;
984 }
985
986 params->num_partitions = 0;
987 int numEntries = GetNumberOfEntries(&drive);
988 int i;
989 for(i = 0; i < numEntries; i++) {
990 GptEntry *entry = GetEntry(&drive.gpt, ANY_VALID, i);
991 if (GuidIsZero(&entry->type))
992 continue;
993
994 params->num_partitions++;
995 }
996
997 retval = CGPT_OK;
998
999 done:
1000 DriveClose(&drive, 0);
1001 return retval;
1002 }
1003
GuidEqual(const Guid * guid1,const Guid * guid2)1004 int GuidEqual(const Guid *guid1, const Guid *guid2) {
1005 return (0 == memcmp(guid1, guid2, sizeof(Guid)));
1006 }
1007
GuidIsZero(const Guid * gp)1008 int GuidIsZero(const Guid *gp) {
1009 return GuidEqual(gp, &guid_unused);
1010 }
1011
PMBRToStr(struct pmbr * pmbr,char * str,unsigned int buflen)1012 void PMBRToStr(struct pmbr *pmbr, char *str, unsigned int buflen) {
1013 char buf[GUID_STRLEN];
1014 if (GuidIsZero(&pmbr->boot_guid)) {
1015 require(snprintf(str, buflen, "PMBR") < buflen);
1016 } else {
1017 GuidToStr(&pmbr->boot_guid, buf, sizeof(buf));
1018 require(snprintf(str, buflen, "PMBR (Boot GUID: %s)", buf) < buflen);
1019 }
1020 }
1021
1022 /* Optional */
__GenerateGuid(Guid * newguid)1023 int __GenerateGuid(Guid *newguid) { return CGPT_FAILED; };
1024 #ifndef HAVE_MACOS
1025 int GenerateGuid(Guid *newguid) __attribute__((weak, alias("__GenerateGuid")));
1026 #endif
1027