cmd_linux_heap_glibc.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021 Pulak Malhotra <pulakmalhotra2000@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_types.h>
#include <rz_core.h>
#include <rz_heap_glibc.h>
#include "cmd_descs.h"
#include "../linux_heap_glibc.h"
#include "../linux_heap_glibc64.h"
 
#define call_handler(fun, ...) \
    { \
        if (core->rasm->bits == 64) { \
            return fun##_64(core, ##__VA_ARGS__); \
        } else { \
            return fun##_32(core, ##__VA_ARGS__); \
        } \
    }
 
RZ_IPI RzCmdStatus rz_cmd_heap_chunks_print_handler(RzCore *core, int argc, const char **argv, RzCmdStateOutput *state) {
    call_handler(rz_cmd_heap_chunks_print_handler, argc, argv, state);
}
 
RZ_IPI RzCmdStatus rz_cmd_arena_print_handler(RzCore *core, int argc, const char **argv) {
    call_handler(rz_cmd_arena_print_handler, argc, argv);
}
 
RZ_IPI RzCmdStatus rz_cmd_main_arena_print_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
    call_handler(rz_cmd_main_arena_print_handler, argc, argv, mode);
}
 
RZ_IPI RzCmdStatus rz_cmd_heap_chunk_print_handler(RzCore *core, int argc, const char **argv) {
    call_handler(rz_cmd_heap_chunk_print_handler, argc, argv);
}
 
RZ_IPI RzCmdStatus rz_cmd_heap_chunks_graph_handler(RzCore *core, int argc, const char **argv) {
    // RZ_OUTPUT_MODE_LONG_JSON mode workaround for graph
    RzCmdStateOutput state = { 0 };
    if (!rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_LONG)) {
        return RZ_CMD_STATUS_ERROR;
    }
    RzCmdStatus res;
    if (core->rasm->bits == 64) {
        res = rz_cmd_heap_chunks_print_handler_64(core, argc, argv, &state);
    } else {
        res = rz_cmd_heap_chunks_print_handler_32(core, argc, argv, &state);
    }
    rz_cmd_state_output_print(&state);
    rz_cmd_state_output_fini(&state);
    return res;
}
 
RZ_IPI RzCmdStatus rz_cmd_heap_info_print_handler(RzCore *core, int argc, const char **argv) {
    call_handler(rz_cmd_heap_info_print_handler, argc, argv);
}
 
RZ_IPI RzCmdStatus rz_cmd_heap_tcache_print_handler(RzCore *core, int argc, const char **argv) {
    call_handler(rz_cmd_heap_tcache_print_handler, argc, argv);
}
 
RZ_IPI int rz_cmd_heap_bins_list_print(void *data, const char *input) {
    RzCore *core = (RzCore *)data;
    call_handler(rz_cmd_heap_bins_list_print, input);
}
 
RZ_IPI int rz_cmd_heap_fastbins_print(void *data, const char *input) {
    RzCore *core = (RzCore *)data;
    call_handler(rz_cmd_heap_fastbins_print, input);
}
 
RZ_IPI RzCmdStatus rz_cmd_heap_arena_bins_print_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
    call_handler(rz_cmd_heap_arena_bins_print_handler, argc, argv, mode);
}
 
/* API functions for Heap Viewer in Cutter */
 
RZ_API RzList /*<MallocState *>*/ *rz_heap_arenas_list(RzCore *core) {
    call_handler(rz_heap_arena_list_wrapper);
}
 
RZ_API RzList /*<RzHeapChunkListItem *>*/ *rz_heap_chunks_list(RzCore *core, ut64 m_arena) {
    call_handler(rz_heap_chunks_list_wrapper, m_arena);
}
 
RZ_API RzHeapChunkSimple *rz_heap_chunk(RzCore *core, ut64 addr) {
    call_handler(rz_heap_chunk_wrapper, addr);
}
 
RZ_API RzHeapBin *rz_heap_bin_content(RzCore *core, MallocState *arena, int bin_num, ut64 m_arena) {
    call_handler(rz_heap_bin_content, arena, bin_num, m_arena);
}
 
RZ_API RzHeapBin *rz_heap_fastbin_content(RzCore *core, MallocState *arena, int bin_num) {
    call_handler(rz_heap_fastbin_content, arena, bin_num);
}
 
RZ_API MallocState *rz_heap_get_arena(RzCore *core, ut64 m_state) {
    call_handler(rz_heap_get_arena, m_state);
}
 
RZ_API RzList /*<RzHeapBin *>*/ *rz_heap_tcache_content(RzCore *core, ut64 arena_base) {
    call_handler(rz_heap_tcache_content, arena_base);
}
 
RZ_API bool rz_heap_write_chunk(RzCore *core, RzHeapChunkSimple *chunk_simple) {
    call_handler(rz_heap_write_heap_chunk, chunk_simple);
}