bin_ningb.c File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include <string.h>
#include "../format/nin/nin.h"

Go to the source code of this file.

Functions
static bool	check_buffer (RzBuffer *b)
static bool	load_buffer (RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb)
static ut64	baddr (RzBinFile *bf)
static RzBinAddr *	binsym (RzBinFile *bf, RzBinSpecialSymbol type)
static RzList *	entries (RzBinFile *bf)
static RzList *	sections (RzBinFile *bf)
static RzList *	symbols (RzBinFile *bf)
static RzBinInfo *	info (RzBinFile *bf)
RzList *	mem (RzBinFile *bf)

Variables
RzBinPlugin	rz_bin_plugin_ningb
RZ_API RzLibStruct	rizin_plugin

Function Documentation

baddr()

static ut64 baddr ( RzBinFile *  bf )

static

Definition at line 23 of file bin_ningb.c.

                                 {
    return 0LL;
}

binsym()

static RzBinAddr* binsym ( RzBinFile *  bf, RzBinSpecialSymbol  type  )

static

Definition at line 27 of file bin_ningb.c.

                                                                 {
    if (type == RZ_BIN_SPECIAL_SYMBOL_MAIN && bf && bf->buf) {
        ut8 init_jmp[4];
        RzBinAddr *ret = RZ_NEW0(RzBinAddr);
        if (!ret) {
            return NULL;
        }
        rz_buf_read_at(bf->buf, 0x100, init_jmp, 4);
        if (init_jmp[1] == 0xc3) {
            ret->paddr = ret->vaddr = init_jmp[3] * 0x100 + init_jmp[2];
            return ret;
        }
        free(ret);
    }
    return NULL;
}

References rz_bin_file_t::buf, free(), NULL, rz_bin_addr_t::paddr, RZ_BIN_SPECIAL_SYMBOL_MAIN, rz_buf_read_at(), RZ_NEW0, type, and rz_bin_addr_t::vaddr.

check_buffer()

static bool check_buffer ( RzBuffer *  b )

static

Definition at line 11 of file bin_ningb.c.

                                      {
    ut8 lict[sizeof(lic)];
    if (rz_buf_read_at(b, 0x104, lict, sizeof(lict)) == sizeof(lict)) {
        return !memcmp(lict, lic, sizeof(lict));
    }
    return false;
}

References b, lic, and rz_buf_read_at().

Referenced by load_buffer().

entries()

static RzList* entries ( RzBinFile *  bf )

static

Definition at line 44 of file bin_ningb.c.

                                      {
    RzList *ret = rz_list_new();
    RzBinAddr *ptr = NULL;
 
    if (bf && bf->buf != NULL) {
        if (!ret) {
            return NULL;
        }
        ret->free = free;
        if (!(ptr = RZ_NEW0(RzBinAddr))) {
            return ret;
        }
        ptr->paddr = ptr->vaddr = ptr->hpaddr = 0x100;
        rz_list_append(ret, ptr);
    }
    return ret;
}

References rz_bin_file_t::buf, rz_list_t::free, free(), rz_bin_addr_t::hpaddr, NULL, rz_bin_addr_t::paddr, rz_list_append(), rz_list_new(), RZ_NEW0, and rz_bin_addr_t::vaddr.

info()

static RzBinInfo* info ( RzBinFile *  bf )

static

Definition at line 158 of file bin_ningb.c.

                                      {
    ut8 rom_header[76];
    RzBinInfo *ret = RZ_NEW0(RzBinInfo);
    if (!ret || !bf || !bf->buf) {
        free(ret);
        return NULL;
    }
    rz_buf_read_at(bf->buf, 0x104, rom_header, 76);
    ret->file = rz_str_ndup((const char *)&rom_header[48], 16);
    ret->type = malloc(128);
    ret->type[0] = 0;
    gb_get_gbtype(ret->type, rom_header[66], rom_header[63]);
    gb_add_cardtype(ret->type, rom_header[67]); // XXX
    ret->machine = strdup("Gameboy");
    ret->os = strdup("any");
    ret->arch = strdup("gb");
    ret->has_va = true;
    ret->bits = 16;
    ret->big_endian = 0;
    ret->dbg_info = 0;
    return ret;
}

References rz_bin_info_t::arch, rz_bin_info_t::big_endian, rz_bin_info_t::bits, rz_bin_file_t::buf, rz_bin_info_t::dbg_info, rz_bin_info_t::file, free(), gb_add_cardtype(), gb_get_gbtype(), rz_bin_info_t::has_va, rz_bin_info_t::machine, malloc(), NULL, rz_bin_info_t::os, rz_buf_read_at(), RZ_NEW0, rz_str_ndup(), strdup(), and rz_bin_info_t::type.

load_buffer()

static bool load_buffer ( RzBinFile *  bf, RzBinObject *  obj, RzBuffer *  buf, Sdb *  sdb  )

static

Definition at line 19 of file bin_ningb.c.

                                                                                  {
    return check_buffer(buf);
}

References check_buffer().

mem()

RzList* mem

(

RzBinFile *

bf

)

Definition at line 181 of file bin_ningb.c.

                           {
    RzList *ret;
    RzBinMem *m, *n;
    if (!(ret = rz_list_new())) {
        return NULL;
    }
    ret->free = free;
    if (!(m = RZ_NEW0(RzBinMem))) {
        rz_list_free(ret);
        return NULL;
    }
    m->name = strdup("fastram");
    m->addr = 0xff80LL;
    m->size = 0x80;
    m->perms = rz_str_rwx("rwx");
    rz_list_append(ret, m);
 
    if (!(m = RZ_NEW0(RzBinMem))) {
        return ret;
    }
    m->name = strdup("ioports");
    m->addr = 0xff00LL;
    m->size = 0x4c;
    m->perms = rz_str_rwx("rwx");
    rz_list_append(ret, m);
 
    if (!(m = RZ_NEW0(RzBinMem))) {
        return ret;
    }
    m->name = strdup("oam");
    m->addr = 0xfe00LL;
    m->size = 0xa0;
    m->perms = rz_str_rwx("rwx");
    rz_list_append(ret, m);
 
    if (!(m = RZ_NEW0(RzBinMem))) {
        return ret;
    }
    m->name = strdup("videoram");
    m->addr = 0x8000LL;
    m->size = 0x2000;
    m->perms = rz_str_rwx("rwx");
    rz_list_append(ret, m);
 
    if (!(m = RZ_NEW0(RzBinMem))) {
        return ret;
    }
    m->name = strdup("iram");
    m->addr = 0xc000LL;
    m->size = 0x2000;
    m->perms = rz_str_rwx("rwx");
    rz_list_append(ret, m);
    if (!(m->mirrors = rz_list_new())) {
        return ret;
    }
    if (!(n = RZ_NEW0(RzBinMem))) {
        rz_list_free(m->mirrors);
        m->mirrors = NULL;
        return ret;
    }
    n->name = strdup("iram_echo");
    n->addr = 0xe000LL;
    n->size = 0x1e00;
    n->perms = rz_str_rwx("rx");
    rz_list_append(m->mirrors, n);
 
    return ret;
}

References rz_list_t::free, free(), regress::m, n, NULL, rz_list_append(), rz_list_free(), rz_list_new(), RZ_NEW0, rz_str_rwx(), and strdup().

sections()

static RzList* sections ( RzBinFile *  bf )

static

Definition at line 62 of file bin_ningb.c.

                                       {
    if (!bf || !bf->buf) {
        return NULL;
    }
    RzList *ret = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!ret) {
        return NULL;
    }
    ut8 bank_id;
    rz_buf_read_at(bf->buf, 0x148, &bank_id, 1);
    int banks_count = gb_get_rombanks(bank_id);
    for (size_t i = 0; i < banks_count; i++) {
        RzBinSection *section = RZ_NEW0(RzBinSection);
        section->name = rz_str_newf("rombank%02x", (unsigned int)i);
        section->paddr = i * 0x4000;
        section->vaddr = i ? (i * 0x10000 - 0xc000) : 0;
        section->size = section->vsize = 0x4000;
        section->perm = rz_str_rwx("rx");
        rz_list_append(ret, section);
    }
    return ret;
}

References rz_bin_file_t::buf, gb_get_rombanks(), i, NULL, rz_bin_section_free(), rz_buf_read_at(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_str_newf(), rz_str_rwx(), and section::size.

symbols()

static RzList* symbols ( RzBinFile *  bf )

static

Definition at line 85 of file bin_ningb.c.

                                      {
    RzList *ret = NULL;
    RzBinSymbol *ptr[13];
    int i;
    if (!(ret = rz_list_newf((RzListFree)rz_bin_symbol_free))) {
        return NULL;
    }
 
    for (i = 0; i < 8; i++) {
        if (!(ptr[i] = RZ_NEW0(RzBinSymbol))) {
            ret->free(ret);
            return NULL;
        }
        ptr[i]->name = rz_str_newf("rst_%i", i * 8);
        ptr[i]->paddr = ptr[i]->vaddr = i * 8;
        ptr[i]->size = 1;
        ptr[i]->ordinal = i;
        rz_list_append(ret, ptr[i]);
    }
 
    if (!(ptr[8] = RZ_NEW0(RzBinSymbol))) {
        return ret;
    }
 
    ptr[8]->name = strdup("Interrupt_Vblank");
    ptr[8]->paddr = ptr[8]->vaddr = 64;
    ptr[8]->size = 1;
    ptr[8]->ordinal = 8;
    rz_list_append(ret, ptr[8]);
 
    if (!(ptr[9] = RZ_NEW0(RzBinSymbol))) {
        return ret;
    }
 
    ptr[9]->name = strdup("Interrupt_LCDC-Status");
    ptr[9]->paddr = ptr[9]->vaddr = 72;
    ptr[9]->size = 1;
    ptr[9]->ordinal = 9;
    rz_list_append(ret, ptr[9]);
 
    if (!(ptr[10] = RZ_NEW0(RzBinSymbol))) {
        return ret;
    }
 
    ptr[10]->name = strdup("Interrupt_Timer-Overflow");
    ptr[10]->paddr = ptr[10]->vaddr = 80;
    ptr[10]->size = 1;
    ptr[10]->ordinal = 10;
    rz_list_append(ret, ptr[10]);
 
    if (!(ptr[11] = RZ_NEW0(RzBinSymbol))) {
        return ret;
    }
 
    ptr[11]->name = strdup("Interrupt_Serial-Transfere");
    ptr[11]->paddr = ptr[11]->vaddr = 88;
    ptr[11]->size = 1;
    ptr[11]->ordinal = 11;
    rz_list_append(ret, ptr[11]);
 
    if (!(ptr[12] = RZ_NEW0(RzBinSymbol))) {
        return ret;
    }
 
    ptr[12]->name = strdup("Interrupt_Joypad");
    ptr[12]->paddr = ptr[12]->vaddr = 96;
    ptr[12]->size = 1;
    ptr[12]->ordinal = 12;
    rz_list_append(ret, ptr[12]);
 
    return ret;
}

References rz_list_t::free, i, rz_bin_symbol_t::name, NULL, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, rz_bin_symbol_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_str_newf(), rz_bin_symbol_t::size, strdup(), and rz_bin_symbol_t::vaddr.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_BIN,
    .data = &rz_bin_plugin_ningb,
    .version = RZ_VERSION
}

Definition at line 267 of file bin_ningb.c.

rz_bin_plugin_ningb

RzBinPlugin rz_bin_plugin_ningb

Initial value:

= {
    .name = "ningb",
    .desc = "Gameboy format rz_bin plugin",
    .license = "LGPL3",
    .load_buffer = &load_buffer,
    .check_buffer = &check_buffer,
    .baddr = &baddr,
    .binsym = &binsym,
    .entries = &entries,
    .maps = &rz_bin_maps_of_file_sections,
    .sections = &sections,
    .symbols = &symbols,
    .info = &info,
    .mem = &mem,
}

Definition at line 250 of file bin_ningb.c.