rizin/librz/flag/serialize_flag.c

// SPDX-FileCopyrightText: 2020 Florian Märkl <info@florianmaerkl.de>
// SPDX-License-Identifier: LGPL-3.0-only

#include <rz_util/rz_serialize.h>
#include <rz_flag.h>

/*
 * SDB Format:
 *
 * /
 *   base=<base>
 *   realnames=<realnames?"1":"0">
 *   /spaces
 *     see spaces.c
 *   /tags
 *     like RzFlag.tags
 *   /zones
 *     <zone name>={"from":<from>,"to":<to>}
 *   /flags
 *     <flag name>={"realname":<str>,"demangled":<bool>,"offset":<uint>,"size":<uint>,"space":<str>,"color":<str>,"comment":<str>,"alias":<str>}
 *
 */

RZ_API void rz_serialize_flag_zones_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzList /*<RzFlagZoneItem *>*/ *zones) {
	RzListIter *it;
	RzFlagZoneItem *item;
	rz_list_foreach (zones, it, item) {
		PJ *j = pj_new();
		if (!j) {
			return;
		}
		pj_o(j);
		pj_kn(j, "from", item->from);
		pj_kn(j, "to", item->to);
		pj_end(j);
		sdb_set(db, item->name, pj_string(j), 0);
		pj_free(j);
	}
}

static bool zone_load_cb(void *user, const char *k, const char *v) {
	RzList *list = user;
	char *json_str = strdup(v);
	if (!json_str) {
		return true;
	}
	RzJson *json = rz_json_parse(json_str);
	if (!json) {
		free(json_str);
		return true;
	}
	if (json->type != RZ_JSON_OBJECT) {
		goto beach;
	}
	const RzJson *child;
	RzFlagZoneItem *item = RZ_NEW0(RzFlagZoneItem);
	if (!item) {
		goto beach;
	}
	item->name = strdup(k);
	if (!item->name) {
		free(item);
		goto beach;
	}
	for (child = json->children.first; child; child = child->next) {
		if (child->type != RZ_JSON_INTEGER) {
			continue;
		}
		if (strcmp(child->key, "from") == 0) {
			item->from = child->num.u_value;
		} else if (strcmp(child->key, "to") == 0) {
			item->to = child->num.u_value;
		}
	}
	rz_list_append(list, item);
beach:
	rz_json_free(json);
	free(json_str);
	return true;
}

RZ_API bool rz_serialize_flag_zones_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzList /*<RzFlagZoneItem *>*/ *zones, RZ_NULLABLE RzSerializeResultInfo *res) {
	rz_return_val_if_fail(zones, false);
	rz_list_purge(zones);
	bool r = sdb_foreach(db, zone_load_cb, zones);
	if (!r) {
		RZ_SERIALIZE_ERR(res, "failed to parse a flag zone json");
	}
	return r;
}

static bool flag_save_cb(RzFlagItem *flag, void *user) {
	Sdb *db = user;
	PJ *j = pj_new();
	if (!j) {
		return false;
	}
	pj_o(j);
	if (flag->realname) {
		pj_ks(j, "realname", flag->realname);
	}
	pj_kb(j, "demangled", flag->demangled);
	pj_kn(j, "offset", flag->offset);
	pj_kn(j, "size", flag->size);
	if (flag->space) {
		pj_ks(j, "space", flag->space->name);
	}
	if (flag->color) {
		pj_ks(j, "color", flag->color);
	}
	if (flag->comment) {
		pj_ks(j, "comment", flag->comment);
	}
	if (flag->alias) {
		pj_ks(j, "alias", flag->alias);
	}
	pj_end(j);
	sdb_set(db, flag->name, pj_string(j), 0);
	pj_free(j);
	return true;
}

RZ_API void rz_serialize_flag_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzFlag *flag) {
	rz_serialize_spaces_save(sdb_ns(db, "spaces", true), &flag->spaces);
	char buf[32];
	if (snprintf(buf, sizeof(buf), "%" PFMT64d, flag->base) < 0) {
		return;
	}
	sdb_set(db, "base", buf, 0);
	sdb_set(db, "realnames", flag->realnames ? "1" : "0", 0);
	sdb_copy(flag->tags, sdb_ns(db, "tags", true));
	rz_serialize_flag_zones_save(sdb_ns(db, "zones", true), flag->zones);
	rz_flag_foreach(flag, flag_save_cb, sdb_ns(db, "flags", true));
}

typedef enum {
	FLAG_FIELD_REALNAME,
	FLAG_FIELD_DEMANGLED,
	FLAG_FIELD_OFFSET,
	FLAG_FIELD_SIZE,
	FLAG_FIELD_SPACE,
	FLAG_FIELD_COLOR,
	FLAG_FIELD_COMMENT,
	FLAG_FIELD_ALIAS
} FlagField;

typedef struct {
	RzFlag *flag;
	RzKeyParser *parser;
} FlagLoadCtx;

static bool flag_load_cb(void *user, const char *k, const char *v) {
	FlagLoadCtx *ctx = user;

	char *json_str = strdup(v);
	if (!json_str) {
		return true;
	}
	RzJson *json = rz_json_parse(json_str);
	if (!json || json->type != RZ_JSON_OBJECT) {
		free(json_str);
		return false;
	}

	RzFlagItem proto = { 0 };
	bool offset_set = false;
	bool size_set = false;

	RZ_KEY_PARSER_JSON(ctx->parser, json, child, {
		case FLAG_FIELD_REALNAME:
			if (child->type != RZ_JSON_STRING) {
				break;
			}
			proto.realname = (char *)child->str_value;
			break;
		case FLAG_FIELD_DEMANGLED:
			if (child->type != RZ_JSON_BOOLEAN) {
				break;
			}
			proto.demangled = child->num.u_value != 0;
			break;
		case FLAG_FIELD_OFFSET:
			if (child->type != RZ_JSON_INTEGER) {
				break;
			}
			proto.offset = child->num.u_value;
			offset_set = true;
			break;
		case FLAG_FIELD_SIZE:
			if (child->type != RZ_JSON_INTEGER) {
				break;
			}
			proto.size = child->num.u_value;
			size_set = true;
			break;
		case FLAG_FIELD_SPACE:
			if (child->type != RZ_JSON_STRING) {
				break;
			}
			proto.space = rz_flag_space_get(ctx->flag, child->str_value);
			break;
		case FLAG_FIELD_COLOR:
			if (child->type != RZ_JSON_STRING) {
				break;
			}
			proto.color = (char *)child->str_value;
			break;
		case FLAG_FIELD_COMMENT:
			if (child->type != RZ_JSON_STRING) {
				break;
			}
			proto.comment = (char *)child->str_value;
			break;
		case FLAG_FIELD_ALIAS:
			if (child->type != RZ_JSON_STRING) {
				break;
			}
			proto.alias = (char *)child->str_value;
			break;
		default:
			break;
	});

	bool res = true;
	if (!offset_set || !size_set) {
		res = false;
		goto beach;
	}

	RzFlagItem *item = rz_flag_set(ctx->flag, k, proto.offset - ctx->flag->base, proto.size);
	if (proto.realname) {
		rz_flag_item_set_realname(item, proto.realname);
	}
	item->demangled = proto.demangled;
	item->space = proto.space;
	if (proto.color) {
		rz_flag_item_set_color(item, proto.color);
	}
	if (proto.comment) {
		rz_flag_item_set_comment(item, proto.comment);
	}
	if (proto.alias) {
		rz_flag_item_set_alias(item, proto.alias);
	}

beach:
	rz_json_free(json);
	free(json_str);
	return res;
}

static bool load_flags(RZ_NONNULL Sdb *flags_db, RZ_NONNULL RzFlag *flag) {
	FlagLoadCtx ctx = { flag, rz_key_parser_new() };
	if (!ctx.parser) {
		return false;
	}
	rz_key_parser_add(ctx.parser, "realname", FLAG_FIELD_REALNAME);
	rz_key_parser_add(ctx.parser, "demangled", FLAG_FIELD_DEMANGLED);
	rz_key_parser_add(ctx.parser, "offset", FLAG_FIELD_OFFSET);
	rz_key_parser_add(ctx.parser, "size", FLAG_FIELD_SIZE);
	rz_key_parser_add(ctx.parser, "space", FLAG_FIELD_SPACE);
	rz_key_parser_add(ctx.parser, "color", FLAG_FIELD_COLOR);
	rz_key_parser_add(ctx.parser, "comment", FLAG_FIELD_COMMENT);
	rz_key_parser_add(ctx.parser, "alias", FLAG_FIELD_ALIAS);
	bool r = sdb_foreach(flags_db, flag_load_cb, &ctx);
	rz_key_parser_free(ctx.parser);
	return r;
}

RZ_API bool rz_serialize_flag_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzFlag *flag, RZ_NULLABLE RzSerializeResultInfo *res) {
	rz_flag_unset_all(flag);

	const char *str = sdb_const_get(db, "base", NULL);
	if (!str) {
		RZ_SERIALIZE_ERR(res, "flag base key is missing");
		return false;
	}
	flag->base = strtoll(str, NULL, 0);

	str = sdb_const_get(db, "realnames", 0);
	if (!str) {
		RZ_SERIALIZE_ERR(res, "flag realnames key is missing");
		return false;
	}
	flag->realnames = strtoul(str, NULL, 0) ? true : false;

	Sdb *spaces_db = sdb_ns(db, "spaces", false);
	if (!spaces_db) {
		RZ_SERIALIZE_ERR(res, "missing spaces namespace");
		return false;
	}
	if (!rz_serialize_spaces_load(spaces_db, &flag->spaces, false, res)) {
		return false;
	}

	Sdb *tags_db = sdb_ns(db, "tags", false);
	if (!tags_db) {
		RZ_SERIALIZE_ERR(res, "missing tags namespace");
		return false;
	}
	sdb_copy(tags_db, flag->tags);

	Sdb *zones_db = sdb_ns(db, "zones", false);
	if (!zones_db) {
		RZ_SERIALIZE_ERR(res, "missing zones namespace");
		return false;
	}
	rz_flag_zone_reset(flag);
	if (!rz_serialize_flag_zones_load(zones_db, flag->zones, res)) {
		return false;
	}

	Sdb *flags_db = sdb_ns(db, "flags", false);
	if (!flags_db) {
		RZ_SERIALIZE_ERR(res, "missing flags sub-namespace");
		return false;
	}
	if (!load_flags(flags_db, flag)) {
		RZ_SERIALIZE_ERR(res, "failed to parse a flag json");
		return false;
	}

	return true;
}