Module Name: src
Committed By: thorpej
Date: Sun Jun 7 05:42:25 UTC 2020
Modified Files:
src/sbin/gpt: backup.c restore.c
Log Message:
Update for proplib(3) API changes.
To generate a diff of this commit:
cvs rdiff -u -r1.18 -r1.19 src/sbin/gpt/backup.c
cvs rdiff -u -r1.19 -r1.20 src/sbin/gpt/restore.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sbin/gpt/backup.c
diff -u src/sbin/gpt/backup.c:1.18 src/sbin/gpt/backup.c:1.19
--- src/sbin/gpt/backup.c:1.18 Thu Sep 7 10:23:33 2017
+++ src/sbin/gpt/backup.c Sun Jun 7 05:42:25 2020
@@ -33,7 +33,7 @@
__FBSDID("$FreeBSD: src/sbin/gpt/show.c,v 1.14 2006/06/22 22:22:32 marcel Exp $");
#endif
#ifdef __RCSID
-__RCSID("$NetBSD: backup.c,v 1.18 2017/09/07 10:23:33 christos Exp $");
+__RCSID("$NetBSD: backup.c,v 1.19 2020/06/07 05:42:25 thorpej Exp $");
#endif
#include <sys/bootblock.h>
@@ -68,79 +68,46 @@ struct gpt_cmd c_backup = {
#define PROP_ERR(x) if (!(x)) goto cleanup
-#define prop_uint(a) prop_number_create_unsigned_integer(a)
-
static int
store_mbr(gpt_t gpt, unsigned int i, const struct mbr *mbr,
prop_array_t *mbr_array)
{
prop_dictionary_t mbr_dict;
- prop_number_t propnum;
const struct mbr_part *par = &mbr->mbr_part[i];
- bool rc;
if (mbr->mbr_part[i].part_typ == MBR_PTYPE_UNUSED)
return 0;
mbr_dict = prop_dictionary_create();
PROP_ERR(mbr_dict);
- propnum = prop_number_create_integer(i);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "index", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_flag);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "flag", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_shd);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "start_head", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_ssect);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "start_sector", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_scyl);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "start_cylinder", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_typ);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "type", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_ehd);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "end_head", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_esect);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "end_sector", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(par->part_ecyl);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "end_cylinder", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le16toh(par->part_start_lo));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "lba_start_low", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le16toh(par->part_start_hi));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "lba_start_high", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le16toh(par->part_size_lo));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "lba_size_low", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le16toh(par->part_size_hi));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(mbr_dict, "lba_size_high", propnum);
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "index", i));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "flag", par->part_flag));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "start_head",
+ par->part_shd));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "start_sector",
+ par->part_ssect));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "start_cylinder",
+ par->part_scyl));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "type", par->part_typ));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "end_head", par->part_ehd));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "end_sector",
+ par->part_esect));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "end_cylinder",
+ par->part_ecyl));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "lba_start_low",
+ le16toh(par->part_start_lo)));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "lba_start_high",
+ le16toh(par->part_start_hi)));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "lba_size_low",
+ le16toh(par->part_size_lo)));
+ PROP_ERR(prop_dictionary_set_uint(mbr_dict, "lba_size_high",
+ le16toh(par->part_size_hi)));
+
if (*mbr_array == NULL) {
*mbr_array = prop_array_create();
PROP_ERR(*mbr_array);
}
- rc = prop_array_add(*mbr_array, mbr_dict);
- PROP_ERR(rc);
+ PROP_ERR(prop_array_add_and_rel(*mbr_array, mbr_dict));
return 0;
cleanup:
if (mbr_dict)
@@ -152,26 +119,16 @@ cleanup:
static int
store_gpt(gpt_t gpt, const struct gpt_hdr *hdr, prop_dictionary_t *type_dict)
{
- prop_number_t propnum;
- prop_string_t propstr;
char buf[128];
- bool rc;
*type_dict = prop_dictionary_create();
PROP_ERR(type_dict);
- propnum = prop_uint(le32toh(hdr->hdr_revision));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(*type_dict, "revision", propnum);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_uint(*type_dict, "revision",
+ le32toh(hdr->hdr_revision)));
gpt_uuid_snprintf(buf, sizeof(buf), "%d", hdr->hdr_guid);
- propstr = prop_string_create_cstring(buf);
- PROP_ERR(propstr);
- rc = prop_dictionary_set(*type_dict, "guid", propstr);
- PROP_ERR(rc);
- propnum = prop_number_create_integer(le32toh(hdr->hdr_entries));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(*type_dict, "entries", propnum);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_string(*type_dict, "guid", buf));
+ PROP_ERR(prop_dictionary_set_uint(*type_dict, "entries",
+ le32toh(hdr->hdr_entries)));
return 0;
cleanup:
if (*type_dict)
@@ -186,8 +143,6 @@ store_tbl(gpt_t gpt, const map_t m, prop
unsigned int i;
prop_dictionary_t gpt_dict;
prop_array_t gpt_array;
- prop_number_t propnum;
- prop_string_t propstr;
char buf[128];
uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
bool rc;
@@ -206,45 +161,28 @@ store_tbl(gpt_t gpt, const map_t m, prop
m->map_size * gpt->secsz; i++, ent++) {
gpt_dict = prop_dictionary_create();
PROP_ERR(gpt_dict);
- propnum = prop_number_create_integer(i);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(gpt_dict, "index", propnum);
- PROP_ERR(propnum);
+ PROP_ERR(prop_dictionary_set_uint(gpt_dict, "index", i));
gpt_uuid_snprintf(buf, sizeof(buf), "%d", ent->ent_type);
- propstr = prop_string_create_cstring(buf);
- PROP_ERR(propstr);
- rc = prop_dictionary_set(gpt_dict, "type", propstr);
+ PROP_ERR(prop_dictionary_set_string(gpt_dict, "type", buf));
gpt_uuid_snprintf(buf, sizeof(buf), "%d", ent->ent_guid);
- propstr = prop_string_create_cstring(buf);
- PROP_ERR(propstr);
- rc = prop_dictionary_set(gpt_dict, "guid", propstr);
- PROP_ERR(propstr);
- propnum = prop_uint(le64toh(ent->ent_lba_start));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(gpt_dict, "start", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le64toh(ent->ent_lba_end));
- PROP_ERR(rc);
- rc = prop_dictionary_set(gpt_dict, "end", propnum);
- PROP_ERR(rc);
- propnum = prop_uint(le64toh(ent->ent_attr));
- PROP_ERR(propnum);
- rc = prop_dictionary_set(gpt_dict, "attributes", propnum);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_string(gpt_dict, "guid", buf));
+ PROP_ERR(prop_dictionary_set_uint64(gpt_dict, "start",
+ le64toh(ent->ent_lba_start)));
+ PROP_ERR(prop_dictionary_set_uint64(gpt_dict, "end",
+ le64toh(ent->ent_lba_end)));
+ PROP_ERR(prop_dictionary_set_uint64(gpt_dict, "attributes",
+ le64toh(ent->ent_attr)));
utf16_to_utf8(ent->ent_name, __arraycount(ent->ent_name),
utfbuf, __arraycount(utfbuf));
if (utfbuf[0] != '\0') {
- propstr = prop_string_create_cstring((char *)utfbuf);
- PROP_ERR(propstr);
- rc = prop_dictionary_set(gpt_dict, "name", propstr);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_string(gpt_dict, "name",
+ (char *)utfbuf));
}
rc = prop_array_add(gpt_array, gpt_dict);
PROP_ERR(rc);
}
- rc = prop_dictionary_set(*type_dict, "gpt_array", gpt_array);
+ rc = prop_dictionary_set_and_rel(*type_dict, "gpt_array", gpt_array);
PROP_ERR(rc);
- prop_object_release(gpt_array);
return 0;
cleanup:
if (*type_dict)
@@ -262,18 +200,13 @@ backup(gpt_t gpt, const char *outfile)
unsigned int i;
prop_dictionary_t props, type_dict;
prop_array_t mbr_array;
- prop_data_t propdata;
- prop_number_t propnum;
char *propext;
bool rc;
FILE *fp;
props = prop_dictionary_create();
PROP_ERR(props);
- propnum = prop_number_create_integer(gpt->secsz);
- PROP_ERR(propnum);
- rc = prop_dictionary_set(props, "sector_size", propnum);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_uint(props, "sector_size", gpt->secsz));
m = map_first(gpt);
while (m != NULL) {
switch (m->map_type) {
@@ -282,40 +215,36 @@ backup(gpt_t gpt, const char *outfile)
type_dict = prop_dictionary_create();
PROP_ERR(type_dict);
mbr = m->map_data;
- propdata = prop_data_create_data_nocopy(mbr->mbr_code,
- sizeof(mbr->mbr_code));
- PROP_ERR(propdata);
- rc = prop_dictionary_set(type_dict, "code", propdata);
- PROP_ERR(rc);
+ PROP_ERR(prop_dictionary_set_data_nocopy(type_dict,
+ "code", mbr->mbr_code, sizeof(mbr->mbr_code)));
mbr_array = NULL;
for (i = 0; i < 4; i++) {
if (store_mbr(gpt, i, mbr, &mbr_array) == -1)
goto cleanup;
}
if (mbr_array != NULL) {
- rc = prop_dictionary_set(type_dict,
+ rc = prop_dictionary_set_and_rel(type_dict,
"mbr_array", mbr_array);
PROP_ERR(rc);
- prop_object_release(mbr_array);
}
- rc = prop_dictionary_set(props, "MBR", type_dict);
+ rc = prop_dictionary_set_and_rel(props, "MBR",
+ type_dict);
PROP_ERR(rc);
- prop_object_release(type_dict);
break;
case MAP_TYPE_PRI_GPT_HDR:
if (store_gpt(gpt, m->map_data, &type_dict) == -1)
goto cleanup;
- rc = prop_dictionary_set(props, "GPT_HDR", type_dict);
+ rc = prop_dictionary_set_and_rel(props, "GPT_HDR",
+ type_dict);
PROP_ERR(rc);
- prop_object_release(type_dict);
break;
case MAP_TYPE_PRI_GPT_TBL:
if (store_tbl(gpt, m, &type_dict) == -1)
goto cleanup;
- rc = prop_dictionary_set(props, "GPT_TBL", type_dict);
+ rc = prop_dictionary_set_and_rel(props, "GPT_TBL",
+ type_dict);
PROP_ERR(rc);
- prop_object_release(type_dict);
break;
}
m = m->map_next;
Index: src/sbin/gpt/restore.c
diff -u src/sbin/gpt/restore.c:1.19 src/sbin/gpt/restore.c:1.20
--- src/sbin/gpt/restore.c:1.19 Thu May 14 08:34:17 2020
+++ src/sbin/gpt/restore.c Sun Jun 7 05:42:25 2020
@@ -33,7 +33,7 @@
__FBSDID("$FreeBSD: src/sbin/gpt/create.c,v 1.11 2005/08/31 01:47:19 marcel Exp $");
#endif
#ifdef __RCSID
-__RCSID("$NetBSD: restore.c,v 1.19 2020/05/14 08:34:17 msaitoh Exp $");
+__RCSID("$NetBSD: restore.c,v 1.20 2020/06/07 05:42:25 thorpej Exp $");
#endif
#include <sys/types.h>
@@ -72,53 +72,37 @@ struct gpt_cmd c_restore = {
return -1; \
}
-#define prop_uint(a) (u_int)prop_number_unsigned_integer_value(a)
-#define prop_uint16_t(a) (uint16_t)prop_number_unsigned_integer_value(a)
-#define prop_uint8_t(a) (uint8_t)prop_number_unsigned_integer_value(a)
-
static int
restore_mbr(gpt_t gpt, struct mbr *mbr, prop_dictionary_t mbr_dict, off_t last)
{
unsigned int i;
- prop_number_t propnum;
struct mbr_part *part;
- propnum = prop_dictionary_get(mbr_dict, "index");
- PROP_ERR(propnum);
-
- i = prop_uint(propnum);
- propnum = prop_dictionary_get(mbr_dict, "flag");
- PROP_ERR(propnum);
+ PROP_ERR(prop_dictionary_get_uint(mbr_dict, "index", &i));
part = &mbr->mbr_part[i];
- part->part_flag = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "start_head");
- PROP_ERR(propnum);
- part->part_shd = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "start_sector");
- PROP_ERR(propnum);
- part->part_ssect = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "start_cylinder");
- PROP_ERR(propnum);
- part->part_scyl = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "type");
- PROP_ERR(propnum);
- part->part_typ = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "end_head");
- PROP_ERR(propnum);
- part->part_ehd = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "end_sector");
- PROP_ERR(propnum);
- part->part_esect = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "end_cylinder");
- PROP_ERR(propnum);
- part->part_ecyl = prop_uint8_t(propnum);
- propnum = prop_dictionary_get(mbr_dict, "lba_start_low");
- PROP_ERR(propnum);
- part->part_start_lo = htole16(prop_uint16_t(propnum));
- propnum = prop_dictionary_get(mbr_dict, "lba_start_high");
- PROP_ERR(propnum);
- part->part_start_hi = htole16(prop_uint16_t(propnum));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "flag", &part->part_flag));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "start_head",
+ &part->part_shd));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "start_sector",
+ &part->part_ssect ));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "start_cylinder",
+ &part->part_scyl));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "type",
+ &part->part_typ));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "end_head",
+ &part->part_ehd));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "end_sector",
+ &part->part_esect));
+ PROP_ERR(prop_dictionary_get_uint8(mbr_dict, "end_cylinder",
+ &part->part_ecyl));
+ PROP_ERR(prop_dictionary_get_uint16(mbr_dict, "lba_start_low",
+ &part->part_start_lo));
+ part->part_start_lo = htole16(part->part_start_lo);
+ PROP_ERR(prop_dictionary_get_uint16(mbr_dict, "lba_start_high",
+ &part->part_start_hi));
+ part->part_start_hi = htole16(part->part_start_hi);
+
/* adjust PMBR size to size of device */
if (part->part_typ == MBR_PTYPE_PMBR) {
if (last > 0xffffffff) {
@@ -130,12 +114,12 @@ restore_mbr(gpt_t gpt, struct mbr *mbr,
(uint16_t)(last >> 16));
}
} else {
- propnum = prop_dictionary_get(mbr_dict, "lba_size_low");
- PROP_ERR(propnum);
- part->part_size_lo = htole16(prop_uint16_t(propnum));
- propnum = prop_dictionary_get(mbr_dict, "lba_size_high");
- PROP_ERR(propnum);
- part->part_size_hi = htole16(prop_uint16_t(propnum));
+ PROP_ERR(prop_dictionary_get_uint16(mbr_dict, "lba_size_low",
+ &part->part_size_lo));
+ part->part_size_lo = htole16(part->part_size_lo);
+ PROP_ERR(prop_dictionary_get_uint16(mbr_dict, "lba_size_high",
+ &part->part_size_hi));
+ part->part_size_hi = htole16(part->part_size_hi);
}
return 0;
}
@@ -147,42 +131,33 @@ restore_ent(gpt_t gpt, prop_dictionary_t
unsigned int i;
struct gpt_ent ent;
const char *s;
- prop_string_t propstr;
- prop_number_t propnum;
memset(&ent, 0, sizeof(ent));
- propstr = prop_dictionary_get(gpt_dict, "type");
- PROP_ERR(propstr);
- s = prop_string_cstring_nocopy(propstr);
+ PROP_ERR(prop_dictionary_get_string(gpt_dict, "type", &s));
if (gpt_uuid_parse(s, ent.ent_type) != 0) {
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
return -1;
}
- propstr = prop_dictionary_get(gpt_dict, "guid");
- PROP_ERR(propstr);
- s = prop_string_cstring_nocopy(propstr);
+ PROP_ERR(prop_dictionary_get_string(gpt_dict, "guid", &s));
if (gpt_uuid_parse(s, ent.ent_guid) != 0) {
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
return -1;
}
- propnum = prop_dictionary_get(gpt_dict, "start");
- PROP_ERR(propnum);
- ent.ent_lba_start = htole64(prop_uint(propnum));
- propnum = prop_dictionary_get(gpt_dict, "end");
- PROP_ERR(propnum);
- ent.ent_lba_end = htole64(prop_uint(propnum));
- propnum = prop_dictionary_get(gpt_dict, "attributes");
- PROP_ERR(propnum);
- ent.ent_attr = htole64(prop_uint(propnum));
- propstr = prop_dictionary_get(gpt_dict, "name");
- if (propstr != NULL) {
- s = prop_string_cstring_nocopy(propstr);
+ PROP_ERR(prop_dictionary_get_uint64(gpt_dict, "start",
+ &ent.ent_lba_start));
+ ent.ent_lba_start = htole64(ent.ent_lba_start);
+ PROP_ERR(prop_dictionary_get_uint64(gpt_dict, "end",
+ &ent.ent_lba_end));
+ ent.ent_lba_end = htole64(ent.ent_lba_end);
+ PROP_ERR(prop_dictionary_get_uint64(gpt_dict, "attributes",
+ &ent.ent_attr));
+ ent.ent_attr = htole64(ent.ent_attr);
+
+ if (prop_dictionary_get_string(gpt_dict, "name", &s)) {
utf8_to_utf16((const uint8_t *)s, ent.ent_name,
__arraycount(ent.ent_name));
}
- propnum = prop_dictionary_get(gpt_dict, "index");
- PROP_ERR(propnum);
- i = prop_uint(propnum);
+ PROP_ERR(prop_dictionary_get_uint(gpt_dict, "index", &i));
if (i > entries) {
gpt_warnx(gpt, "Entity index out of bounds %u > %u\n",
i, entries);
@@ -207,7 +182,6 @@ restore(gpt_t gpt, const char *infile, i
prop_data_t propdata;
prop_array_t mbr_array, gpt_array;
prop_number_t propnum;
- prop_string_t propstr;
unsigned int entries;
const char *s;
void *secbuf = NULL;
@@ -241,7 +215,7 @@ restore(gpt_t gpt, const char *infile, i
propnum = prop_dictionary_get(props, "sector_size");
PROP_ERR(propnum);
- if (!prop_number_equals_integer(propnum, gpt->secsz)) {
+ if (!prop_number_equals_signed(propnum, gpt->secsz)) {
gpt_warnx(gpt, "Sector size does not match backup");
prop_object_release(props);
return -1;
@@ -252,23 +226,20 @@ restore(gpt_t gpt, const char *infile, i
propnum = prop_dictionary_get(gpt_dict, "revision");
PROP_ERR(propnum);
- if (!prop_number_equals_unsigned_integer(propnum, 0x10000)) {
+ if (!prop_number_equals_unsigned(propnum, 0x10000)) {
gpt_warnx(gpt, "backup is not revision 1.0");
prop_object_release(gpt_dict);
prop_object_release(props);
return -1;
}
- propnum = prop_dictionary_get(gpt_dict, "entries");
- PROP_ERR(propnum);
- entries = prop_uint(propnum);
+ PROP_ERR(prop_dictionary_get_uint(gpt_dict, "entries", &entries));
+
gpt_size = (u_int)(entries * sizeof(struct gpt_ent) / gpt->secsz);
if (gpt_size * sizeof(struct gpt_ent) % gpt->secsz)
gpt_size++;
- propstr = prop_dictionary_get(gpt_dict, "guid");
- PROP_ERR(propstr);
- s = prop_string_cstring_nocopy(propstr);
+ PROP_ERR(prop_dictionary_get_string(gpt_dict, "guid", &s));
if (gpt_uuid_parse(s, gpt_guid) != 0) {
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
goto out;
@@ -283,21 +254,17 @@ restore(gpt_t gpt, const char *infile, i
propiter = prop_array_iterator(gpt_array);
PROP_ERR(propiter);
while ((gpt_dict = prop_object_iterator_next(propiter)) != NULL) {
- propstr = prop_dictionary_get(gpt_dict, "type");
- PROP_ERR(propstr);
- s = prop_string_cstring_nocopy(propstr);
+ PROP_ERR(prop_dictionary_get_string(gpt_dict, "type", &s));
if (gpt_uuid_parse(s, uuid) != 0) {
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
goto out;
}
if (gpt_uuid_is_nil(uuid))
continue;
- propnum = prop_dictionary_get(gpt_dict, "start");
- PROP_ERR(propnum);
- gpe_start = prop_uint(propnum);
- propnum = prop_dictionary_get(gpt_dict, "end");
- PROP_ERR(propnum);
- gpe_end = prop_uint(propnum);
+ PROP_ERR(prop_dictionary_get_int64(gpt_dict, "start",
+ &gpe_start));
+ PROP_ERR(prop_dictionary_get_int64(gpt_dict, "end",
+ &gpe_end));
if (gpe_start < firstdata || gpe_end > lastdata) {
gpt_warnx(gpt, "Backup GPT doesn't fit");
goto out;
@@ -337,7 +304,7 @@ restore(gpt_t gpt, const char *infile, i
PROP_ERR(type_dict);
propdata = prop_dictionary_get(type_dict, "code");
PROP_ERR(propdata);
- memcpy(mbr->mbr_code, prop_data_data_nocopy(propdata),
+ memcpy(mbr->mbr_code, prop_data_value(propdata),
sizeof(mbr->mbr_code));
mbr_array = prop_dictionary_get(type_dict, "mbr_array");
PROP_ERR(mbr_array);
@@ -355,7 +322,7 @@ restore(gpt_t gpt, const char *infile, i
gpt_warn(gpt, "Unable to seek/write MBR");
return -1;
}
-
+
propiter = prop_array_iterator(gpt_array);
PROP_ERR(propiter);
