Update for proplib(3) API changes.
This commit is contained in:
thorpej
parent
b3d9a749d9
commit
d147ce2226
@ -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_dictionary_t *type_dict)
|
||||
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_dictionary_t *type_dict)
|
||||
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;
|
||||
|
||||
@ -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, prop_dictionary_t mbr_dict, off_t last)
|
||||
(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 gpt_dict, void *secbuf, u_int gpt_size,
|
||||
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, int force)
|
||||
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, int force)
|
||||
|
||||
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, int force)
|
||||
|
||||
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, int force)
|
||||
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, int force)
|
||||
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, int force)
|
||||
gpt_warn(gpt, "Unable to seek/write MBR");
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
propiter = prop_array_iterator(gpt_array);
|
||||
PROP_ERR(propiter);
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
/* $NetBSD: main.c,v 1.17 2016/09/05 01:09:57 sevan Exp $ */
|
||||
/* $NetBSD: main.c,v 1.18 2020/06/07 05:49:05 thorpej Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 2008 The NetBSD Foundation, Inc.
|
||||
@ -28,7 +28,7 @@
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
#ifndef lint
|
||||
__RCSID("$NetBSD: main.c,v 1.17 2016/09/05 01:09:57 sevan Exp $");
|
||||
__RCSID("$NetBSD: main.c,v 1.18 2020/06/07 05:49:05 thorpej Exp $");
|
||||
#endif /* !lint */
|
||||
|
||||
#include <sys/module.h>
|
||||
@ -184,7 +184,6 @@ parse_bool_param(prop_dictionary_t props, const char *name,
|
||||
const char *value)
|
||||
{
|
||||
bool boolvalue;
|
||||
prop_object_t po;
|
||||
|
||||
assert(name != NULL);
|
||||
assert(value != NULL);
|
||||
@ -200,10 +199,8 @@ parse_bool_param(prop_dictionary_t props, const char *name,
|
||||
else
|
||||
errx(EXIT_FAILURE, "Invalid boolean value `%s'", value);
|
||||
|
||||
po = prop_bool_create(boolvalue);
|
||||
if (po == NULL)
|
||||
err(EXIT_FAILURE, "prop_bool_create");
|
||||
prop_dictionary_set(props, name, po);
|
||||
if (!prop_dictionary_set_bool(props, name, boolvalue))
|
||||
err(EXIT_FAILURE, "prop_dictionary_set_bool");
|
||||
}
|
||||
|
||||
static void
|
||||
@ -211,7 +208,6 @@ parse_int_param(prop_dictionary_t props, const char *name,
|
||||
const char *value)
|
||||
{
|
||||
int64_t intvalue;
|
||||
prop_object_t po;
|
||||
|
||||
assert(name != NULL);
|
||||
assert(value != NULL);
|
||||
@ -219,10 +215,8 @@ parse_int_param(prop_dictionary_t props, const char *name,
|
||||
if (dehumanize_number(value, &intvalue) != 0)
|
||||
err(EXIT_FAILURE, "Invalid integer value `%s'", value);
|
||||
|
||||
po = prop_number_create_integer(intvalue);
|
||||
if (po == NULL)
|
||||
err(EXIT_FAILURE, "prop_number_create_integer");
|
||||
prop_dictionary_set(props, name, po);
|
||||
if (!prop_dictionary_set_int64(props, name, intvalue))
|
||||
err(EXIT_FAILURE, "prop_dictionary_set_int64");
|
||||
}
|
||||
|
||||
static void
|
||||
@ -249,15 +243,12 @@ static void
|
||||
parse_string_param(prop_dictionary_t props, const char *name,
|
||||
const char *value)
|
||||
{
|
||||
prop_object_t po;
|
||||
|
||||
assert(name != NULL);
|
||||
assert(value != NULL);
|
||||
|
||||
po = prop_string_create_cstring(value);
|
||||
if (po == NULL)
|
||||
err(EXIT_FAILURE, "prop_string_create_cstring");
|
||||
prop_dictionary_set(props, name, po);
|
||||
if (!prop_dictionary_set_string(props, name, value))
|
||||
err(EXIT_FAILURE, "prop_dictionary_set_string");
|
||||
}
|
||||
|
||||
static void
|
||||
@ -288,7 +279,7 @@ merge_dicts(prop_dictionary_t existing_dict, const prop_dictionary_t new_dict)
|
||||
|
||||
while ((props_obj = prop_object_iterator_next(props_iter)) != NULL) {
|
||||
props_keysym = (prop_dictionary_keysym_t)props_obj;
|
||||
props_key = prop_dictionary_keysym_cstring_nocopy(props_keysym);
|
||||
props_key = prop_dictionary_keysym_value(props_keysym);
|
||||
props_obj = prop_dictionary_get_keysym(new_dict, props_keysym);
|
||||
if ((props_obj == NULL) || !prop_dictionary_set(existing_dict,
|
||||
props_key, props_obj)) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user