Refactor use of `core->block` to the transparent IO access

[XVilka]

To avoid the need of manually keeping it in mind when using the API.

Should use the transparent RzIO and RzCore API without the need to work with block or blocksize

I propose the new API that will handle all reads and writes itself:

• RZ_API bool rz_core_io_read_at(RzCore *core, ut64 offset, ut64 len, ut64 *read)
• RZ_API bool rz_core_io_write_at(RzCore *core, ut64 offset, ut64 len, ut64 *written)

See #2694

$ rg "core->block[,\s\)]" | wc -l
     121

$ rg "core->block[,\s\)]"
test/unit/test_yank.c
20:	mu_assert_memeq(core->block, (const ut8 *)"\x44\x33\x22\x11", 4, "original bytes should be right at address 0");
29:	mu_assert_memeq(core->block, (const ut8 *)"\x44\x33\x22\x11", 4, "yanked bytes should be pasted at address 4");
46:	mu_assert_streq((const char *)core->block, "Hello World", "yanked bytes should be pasted at address 4");
48:	mu_assert_streq((const char *)core->block, "HellHello World", "yanked bytes should be pasted at address 4, original content there");

test/db/archos/linux-x64/dbg_bps
263:NAME=read core->block on short move

librz/core/rtr_http.c
438:	memcpy(newblk, core->block, core->blocksize);
440:	core->block = newblk;
452:		core->block = origblk;
468:		core->block = newblk;

librz/core/cprint.c
28:		value = rz_read_ble(core->block + pos, false, 8);
1093:	memcpy(buf, core->block, core->blocksize);

librz/core/cmp.c
187:			core->block + i, len - i);

librz/core/tui/visual.c
829:				q = core->block + i;
834:		q = rz_mem_mem(core->block + d, core->blocksize - d,
837:			q = rz_mem_mem(core->block, RZ_MIN(core->blocksize, d),
842:		core->print->cur = (int)(size_t)(q - core->block);
924:	p = rz_mem_mem(core->block + d, core->blocksize - d,
927:		core->print->cur = (int)(size_t)(p - core->block);
1005:		rz_asm_disassemble(core->rasm, &op, core->block, RZ_MIN(32, core->blocksize));
1603:				core->block + next_roff, 32);
1690:					core->block, 32);
1753:				&op, core->block, 32);
2675:							rz_asm_disassemble(core->rasm, &op, core->block, 32);
3642:		op, core->block, 32);

librz/core/cio.c
246:	if (core && core->block) {
247:		return rz_io_read_at(core->io, core->offset, core->block, core->blocksize);
379:	if (rz_analysis_op(core->analysis, &op, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC) < 1) {

librz/core/hack.c
293:		if (rz_analysis_op(core->analysis, &aop, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC) < 1) {

librz/core/seek.c
208:		if (rz_analysis_op(core->analysis, &aop, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC) > 0) {

librz/core/core.c
591:		rz_analysis_op(core->analysis, &op, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC);
2326:	core->block = (ut8 *)calloc(RZ_CORE_BLOCKSIZE + 1, 1);
2327:	if (!core->block) {
2796:	bump = realloc(core->block, bsize + 1);
2801:	core->block = bump;
2803:	memset(core->block, 0xff, core->blocksize);
2948:					memcpy(ptr + 5, core->block, i); // core->blocksize);

librz/core/cgraph.c
784:	if (rz_analysis_op(core->analysis, &op, core->offset, core->block, core->blocksize, flags) > 0) {

librz/core/canalysis.c
1048:		ptr = core->block + delta;

librz/core/tui/esil.c
51:	memcpy(buf, core->block, sizeof(ut64));

librz/core/tui/define.c
228:			core->block + off - core->offset, 32, RZ_ANALYSIS_OP_MASK_BASIC);
312:				if (rz_analysis_op(core->analysis, &op, off, core->block + delta,

librz/core/tui/panels.c
1544:				&op, core->block, 32);

librz/core/tui/biteditor.c
40:	memcpy(buf, core->block + cur, sizeof(ut64));

librz/core/disasm.c
6109:	if (buf != core->block) {

librz/core/cmd/cmd_magic.c
96:	str = rz_magic_buffer(ck, core->block + delta, core->blocksize - delta);

librz/core/cmd/cmd_search.c
2559:		int diff = memcmpdiff(core->block, block, core->blocksize);
2786:	memcpy(buf, core->block, bufsz);

librz/core/cmd/cmd_write.c
57:		rz_crypto_update(core->crypto, (const ut8 *)core->block, core->blocksize);

librz/core/cmd/cmd_print.c
1598:	if (data != core->block) {
1670:		handle_entropy(core, plugin->name, core->block, core->blocksize);
1672:		handle_ssdeep(core, plugin->name, core->block, core->blocksize);
1674:		handle_hash_cfg(core, plugin->name, core->block, core->blocksize);
2134:	const ut8 *buffer = core->block + offset;
2188:	if (*core->block & 0x1) { // "long" string
2189:		const ut8 *ptr = core->block + (bitness / 8) * 2;
2223:	if (rz_scan_strings_raw(core->block, found, &scan_opt, 0, core->blocksize, RZ_STRING_ENC_GUESS) < 0) {
2256:	if (rz_scan_strings_raw(core->block, found, &scan_opt, 0, core->blocksize, RZ_STRING_ENC_GUESS) < 0) {
2281:		string_len = rz_read_ble16(core->block, big_endian);
2284:		string_len = rz_read_ble32(core->block, big_endian);
2287:		string_len = rz_read_ble64(core->block, big_endian);
2303:		opt.buffer = core->block + offset;
2310:		print_json_string(core, core->block + offset, string_len, RZ_STRING_ENC_8BIT, true);
2545:	// TODO After core->block is removed, this should be changed to a block read.
2573:			if (core->blocksize < 4 || !memcmp(core->block, "\xff\xff\xff\xff", 4)) {
2576:				char *res = rz_print_json_indent((const char *)core->block, true, "  ", NULL);
2801:		print_json_string(core, core->block, core->blocksize, RZ_STRING_ENC_UTF16LE, true);
2815:		print_json_string(core, core->block, core->blocksize, RZ_STRING_ENC_UTF32LE, true);
2829:		print_json_string(core, core->block, core->blocksize, RZ_STRING_ENC_UTF16BE, true);
2843:		print_json_string(core, core->block, core->blocksize, RZ_STRING_ENC_UTF32BE, true);
2890:		rz_str_bits(buf, core->block + i, 8, NULL);
2900:			const ut8 *b = core->block + i - 3;
3015:			ut8 *p = (ut8 *)core->block + j;
3024:			ut8 *p = (ut8 *)core->block + j;
3038:	rz_print_hexii(core->print, core->offset, core->block,
3087:	rz_core_print_hexdump(core, core->offset, core->block, len, 16, 1, 1);
3105:	memcpy(block, core->block, len);
3115:		core->block, len, 8, 1, 1);
3138:	int len = (int)rz_str_nlen((const char *)core->block, core->blocksize);
3142:	rz_print_bytes(core->print, core->block, len, "%02x");
3204:		char *code = rz_lang_byte_array(core->block, size, type); \
3216:		char *code = rz_lang_byte_array(core->block, core->blocksize, big_endian ? type##_BE : type##_LE); \
3256:	char *code = rz_core_print_bytes_with_inst(core, core->block, core->offset, size);
3629:	rz_core_analysis_bytes_il(core, core->block, size, 0, false);
3694:	core->num->value = rz_core_print_disasm(core, core->offset, core->block, core->blocksize, RZ_ABS(n_instrs), state, &disasm_options);
3754:		ret = rz_asm_disassemble(core->rasm, &asm_op, core->block + i, core->blocksize - i);
3987:		int ret = rz_analysis_op(core->analysis, &aop, offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC);
4066:	char *buf = rz_base64_encode_dyn((const unsigned char *)core->block, core->blocksize);
4077:	ut8 *buf = rz_base64_decode_dyn((const char *)core->block, core->blocksize);
4100:	rz_str_bits(buf, core->block, len + skip, NULL);
4130:	RzASN1Object *asn1 = rz_asn1_object_parse(core->block, core->blocksize);
4146:	char *s = rz_protobuf_decode(core->block, core->blocksize, false);
4157:	char *s = rz_protobuf_decode(core->block, core->blocksize, true);
4169:	RzCMS *cms = rz_pkcs7_cms_parse(core->block, core->blocksize);
4193:	RzX509Certificate *x509 = rz_x509_certificate_parse2(core->block, core->blocksize);
4223:	char *s = rz_axml_decode(core->block, core->blocksize);
4306:	ut8 *block_end = core->block + blocksize;
4635:	char *s = rz_hash_cfg_randomart(core->block, len, core->offset);
4663:			rz_io_read_at(core->io, core->offset, core->block, len);
4664:			s = rz_hash_cfg_randomart(core->block, len, core->offset);
4671:	rz_io_read_at(core->io, offset0, core->block, len);
6609:	colordump(core, core->block, len);
6617:	out = rz_inflate(core->block, core->blocksize, &inConsumed, &outlen);

librz/core/cmd/cmd_cmp.c
190:		rz_core_print_hexdiff(core, core->offset, core->block, addr, b, core->blocksize, col);
206:		rz_core_print_hexdiff(core, core->offset, core->block, addr, b, core->blocksize, col);
326:	ret = rz_hex_bin2str(core->block, strlen(input) / 2, (char *)buf);

librz/core/cmd/cmd_seek.c
52:			rz_asm_disassemble(core->rasm, &op, core->block, 32);
73:		ret = rz_analysis_op(core->analysis, &op, core->offset, core->block,

librz/core/cmd/cmd_analysis.c
375:		ut32 n = rz_read_ble32(core->block + i, big_endian);
5535:		core_analysis_bytes_json(core, core->block, core->blocksize, 0, state->d.pj);
5538:		core_analysis_bytes_standard(core, core->block, core->blocksize, 0);
5549:	core_analysis_bytes_esil(core, core->block, core->blocksize, 0);
5554:	core_analysis_bytes_desc(core, core->block, core->blocksize, 0);
5559:	core_analysis_bytes_size(core, core->block, core->blocksize, 0);
5583:		core_analysis_bytes_json(core, core->block, core->blocksize, count, state->d.pj);
5586:		core_analysis_bytes_standard(core, core->block, core->blocksize, count);
5616:	core_analysis_bytes_size(core, core->block, core->blocksize, count);
5641:	core_analysis_bytes_esil(core, core->block, core->blocksize, count);
5758:	rz_core_analysis_bytes_il(core, core->block, core->blocksize, count, false);
5782:	rz_core_analysis_bytes_il(core, core->block, core->blocksize, count, true);
5796:		core_analysis_bytes_desc(core, core->block + cur, core->blocksize, 1);
6602:		core->offset, core->block, core->blocksize);

$ rg rz_core_block_read -l
librz/main/rizin.c
librz/include/rz_core.h
librz/core/cio.c
librz/core/seek.c
librz/core/core.c
librz/core/yank.c
librz/core/cfile.c
librz/core/cbin.c
librz/core/disasm.c
librz/core/tui/visual.c
librz/core/tui/panels.c
librz/core/cconfig.c
librz/core/cmd/cmd_write.c
librz/core/cmd/cmd.c
librz/core/cmd/cmd_print.c
librz/core/cmd/cmd_open.c
test/unit/test_yank.c

[wargio]

i agree, but do we also need api for switching bins etc.. ?

[PeiweiHu]

I am a little bit confused before getting to it and I would really appreciate the further explaination. We are not going to remove the concept of core->block, right? Just wanna make the access of core->block more easily. For example, for the proposed API RZ_API bool rz_core_io_read_at(RzCore *core, ut64 offset, ut64 *read), offset means the offset against the start of current core->block and read is a buf to store all content of core->block from the offset to the end of core->block?

Or RZ_API bool rz_core_io_read_at(RzCore *core, ut64 offset, ut64 *read) is used to directly read the binary under test? But how to decide the length of reading? @XVilka

[XVilka]

@PeiweiHu idea is to not expose core->block or similar APIs to 99% of those API users - both external and internal. Splitting into blocks, caching reads, etc, should be done opaquely under the hood. We could only keep the way to change the block size and or/cache size via separate APIs, but that's it.
So, for example, if we have a 64Gb file, the user should be able to read/write to any address via single API call without understanding the current block, the local cache content, etc.

But how to decide the length of reading?

Sorry, I forgot to add ut64 len parameter to both functions, my bad.