class_bin.h File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_bin.h>
#include <rz_demangler.h>
#include "class_attribute.h"
#include "class_const_pool.h"
#include "class_field.h"
#include "class_interface.h"
#include "class_method.h"

Go to the source code of this file.

Classes
struct	java_class_t

Macros
#define	ACCESS_FLAG_MASK_ALL   (0xFFFF)
#define	ACCESS_FLAG_MASK_ALL_NO_SUPER   ((~ACCESS_FLAG_SUPER) & ACCESS_FLAG_MASK_ALL)

Typedefs
typedef struct java_class_t	RzBinJavaClass

Enumerations
enum	ClassAccessFlag {   ACCESS_FLAG_PUBLIC = 0x0001 , ACCESS_FLAG_PRIVATE = 0x0002 , ACCESS_FLAG_PROTECTED = 0x0004 , ACCESS_FLAG_STATIC = 0x0008 ,   ACCESS_FLAG_FINAL = 0x0010 , ACCESS_FLAG_SUPER = 0x0020 , ACCESS_FLAG_BRIDGE = 0x0040 , ACCESS_FLAG_VARARGS = 0x0080 ,   ACCESS_FLAG_NATIVE = 0x0100 , ACCESS_FLAG_INTERFACE = 0x0200 , ACCESS_FLAG_ABSTRACT = 0x0400 , ACCESS_FLAG_STRICT = 0x0800 ,   ACCESS_FLAG_SYNTHETIC = 0x1000 , ACCESS_FLAG_ANNOTATION = 0x2000 , ACCESS_FLAG_ENUM = 0x4000 , ACCESS_FLAG_MODULE = 0x8000 }

Functions
RZ_API RZ_OWN RzBinJavaClass *	rz_bin_java_class_new (RZ_NONNULL RzBuffer *buf, ut64 offset, RZ_NONNULL Sdb *kv)
	Parses the java class file and returns a RzBinJavaClass struct. More...
RZ_API void	rz_bin_java_class_free (RZ_NULLABLE RzBinJavaClass *bin)
	Frees a RzBinJavaClass pointer. More...
RZ_API RZ_OWN char *	rz_bin_java_class_version (RZ_NONNULL RzBinJavaClass *bin)
	Parses the java class file and returns a RzBinJavaClass struct. More...
RZ_API ut64	rz_bin_java_class_debug_info (RZ_NONNULL RzBinJavaClass *bin)
RZ_API RZ_BORROW const char *	rz_bin_java_class_language (RZ_NONNULL RzBinJavaClass *bin)
RZ_API RZ_OWN char *	rz_bin_java_class_name (RZ_NONNULL RzBinJavaClass *bin)
	Returns the class name. More...
RZ_API RZ_OWN char *	rz_bin_java_class_super (RZ_NONNULL RzBinJavaClass *bin)
	Returns the class super name. More...
RZ_API ut32	rz_bin_java_class_access_flags (RZ_NONNULL RzBinJavaClass *bin)
RZ_API RZ_OWN char *	rz_bin_java_class_access_flags_readable (RZ_NONNULL RzBinJavaClass *bin, ut16 mask)
	Returns the readable class access flags. More...
RZ_API void	rz_bin_java_class_as_json (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j)
	Returns the class info as json. More...
RZ_API void	rz_bin_java_class_as_text (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the class info as text. More...
RZ_API RZ_OWN char *	rz_bin_java_class_const_pool_resolve_index (RZ_NONNULL RzBinJavaClass *bin, st32 index)
	Returns the string linked to the class const pool index. More...
RZ_API void	rz_bin_java_class_as_source_code (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the class info as text source code. More...
RZ_API RZ_OWN RzBinAddr *	rz_bin_java_class_resolve_symbol (RZ_NONNULL RzBinJavaClass *bin, RzBinSpecialSymbol resolve)
	Resolves and returns the RzBinAddr struct linked to the input RzBinSpecialSymbol. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_strings (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinString*> containing the strings. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_entrypoints (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinAddr*> containing the entrypoints. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_methods_as_symbols (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinSymbol*> containing the class methods. More...
RZ_API void	rz_bin_java_class_methods_as_text (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the methods in text format via RzStrBuf arg. More...
RZ_API void	rz_bin_java_class_methods_as_json (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j)
	Returns the methods in json format via PJ arg. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_fields_as_symbols (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinSymbol*> containing the class fields. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_fields_as_binfields (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinField*> containing the class fields. More...
RZ_API void	rz_bin_java_class_fields_as_text (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the fields in text format via RzStrBuf arg. More...
RZ_API void	rz_bin_java_class_fields_as_json (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j)
	Returns the fields in json format via PJ arg. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_const_pool_as_symbols (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinSymbol*> containing the class const pool. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_const_pool_as_imports (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinImport*> containing the class const pool. More...
RZ_API void	rz_bin_java_class_const_pool_as_text (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the class const pool in text format via RzStrBuf arg. More...
RZ_API void	rz_bin_java_class_const_pool_as_json (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j)
	Returns the class const pool in json format via PJ arg. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_as_sections (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<RzBinSection*> containing the class sections. More...
RZ_API RZ_OWN RzList *	rz_bin_java_class_as_libraries (RZ_NONNULL RzBinJavaClass *bin)
	Returns a RzList<char*> containing the class libraries. More...
RZ_API void	rz_bin_java_class_interfaces_as_text (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL RzStrBuf *sb)
	Returns the class interfaces as text via RzStrBuf arg. More...
RZ_API void	rz_bin_java_class_interfaces_as_json (RZ_NONNULL RzBinJavaClass *bin, RZ_NONNULL PJ *j)
	Returns the class interfaces as json via PJ arg. More...

Macro Definition Documentation

ACCESS_FLAG_MASK_ALL

#define ACCESS_FLAG_MASK_ALL   (0xFFFF)

Definition at line 36 of file class_bin.h.

ACCESS_FLAG_MASK_ALL_NO_SUPER

#define ACCESS_FLAG_MASK_ALL_NO_SUPER   ((~ACCESS_FLAG_SUPER) & ACCESS_FLAG_MASK_ALL)

Definition at line 37 of file class_bin.h.

Typedef Documentation

RzBinJavaClass

typedef struct java_class_t RzBinJavaClass

Enumeration Type Documentation

ClassAccessFlag

enum ClassAccessFlag

Enumerator
ACCESS_FLAG_PUBLIC
ACCESS_FLAG_PRIVATE
ACCESS_FLAG_PROTECTED
ACCESS_FLAG_STATIC
ACCESS_FLAG_FINAL
ACCESS_FLAG_SUPER
ACCESS_FLAG_BRIDGE
ACCESS_FLAG_VARARGS
ACCESS_FLAG_NATIVE
ACCESS_FLAG_INTERFACE
ACCESS_FLAG_ABSTRACT
ACCESS_FLAG_STRICT
ACCESS_FLAG_SYNTHETIC
ACCESS_FLAG_ANNOTATION
ACCESS_FLAG_ENUM
ACCESS_FLAG_MODULE

Definition at line 17 of file class_bin.h.

             {
    ACCESS_FLAG_PUBLIC /*    */ = 0x0001,
    ACCESS_FLAG_PRIVATE /*   */ = 0x0002,
    ACCESS_FLAG_PROTECTED /* */ = 0x0004,
    ACCESS_FLAG_STATIC /*    */ = 0x0008,
    ACCESS_FLAG_FINAL /*     */ = 0x0010,
    ACCESS_FLAG_SUPER /*     */ = 0x0020,
    ACCESS_FLAG_BRIDGE /*    */ = 0x0040,
    ACCESS_FLAG_VARARGS /*   */ = 0x0080,
    ACCESS_FLAG_NATIVE /*    */ = 0x0100,
    ACCESS_FLAG_INTERFACE /* */ = 0x0200,
    ACCESS_FLAG_ABSTRACT /*  */ = 0x0400,
    ACCESS_FLAG_STRICT /*    */ = 0x0800,
    ACCESS_FLAG_SYNTHETIC /* */ = 0x1000,
    ACCESS_FLAG_ANNOTATION  = 0x2000,
    ACCESS_FLAG_ENUM /*      */ = 0x4000,
    ACCESS_FLAG_MODULE /*    */ = 0x8000
} ClassAccessFlag;

Function Documentation

rz_bin_java_class_access_flags()

RZ_API ut32 rz_bin_java_class_access_flags

(

RZ_NONNULL RzBinJavaClass *

bin

)

Definition at line 477 of file class_bin.c.

                                                                           {
    rz_return_val_if_fail(bin, 0xffffffff);
    return bin->access_flags;
}

References rz_return_val_if_fail.

Referenced by classes().

rz_bin_java_class_access_flags_readable()

RZ_API RZ_OWN char* rz_bin_java_class_access_flags_readable	(	RZ_NONNULL RzBinJavaClass *	bin,
		ut16	mask
	)

Returns the readable class access flags.

Definition at line 485 of file class_bin.c.

                                                                                                       {
    rz_return_val_if_fail(bin, NULL);
    RzStrBuf *sb = NULL;
    ut16 access_flags = bin->access_flags & mask;
 
    for (ut32 i = 0; i < CLASS_ACCESS_FLAGS_SIZE; ++i) {
        const AccessFlagsReadable *afr = &access_flags_list[i];
        if (access_flags & afr->flag) {
            if (!sb) {
                sb = rz_strbuf_new(afr->readable);
                if (!sb) {
                    return NULL;
                }
            } else {
                rz_strbuf_appendf(sb, " %s", afr->readable);
            }
        }
    }
 
    return sb ? rz_strbuf_drain(sb) : NULL;
}

References access_flags_list, CLASS_ACCESS_FLAGS_SIZE, access_flags_readable_t::flag, i, mask, NULL, access_flags_readable_t::readable, rz_return_val_if_fail, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), and sb.

Referenced by classes(), rz_bin_java_class_as_json(), rz_bin_java_class_as_source_code(), and rz_bin_java_class_as_text().

rz_bin_java_class_as_json()

RZ_API void rz_bin_java_class_as_json	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL PJ *	j
	)

Returns the class info as json.

Definition at line 521 of file class_bin.c.

                                                                                        {
    rz_return_if_fail(bin && j);
    char *tmp = NULL;
 
    pj_o(j);
 
    pj_ko(j, "version");
    {
        pj_kn(j, "minor", bin->minor_version);
        pj_kn(j, "major", bin->major_version);
        tmp = rz_bin_java_class_version(bin);
        pj_ks(j, "version", tmp ? tmp : "");
        free(tmp);
    }
    pj_end(j);
 
    pj_kn(j, "constant_pool_count", bin->constant_pool_count);
    pj_k(j, "constant_pool");
    rz_bin_java_class_const_pool_as_json(bin, j);
 
    pj_kn(j, "access_flags_n", bin->access_flags);
    tmp = rz_bin_java_class_access_flags_readable(bin, ACCESS_FLAG_MASK_ALL);
    pj_ks(j, "access_flags_s", tmp ? tmp : "");
    free(tmp);
 
    pj_kn(j, "class_n", bin->this_class);
    tmp = rz_bin_java_class_name(bin);
    pj_ks(j, "class_s", tmp ? tmp : "");
    free(tmp);
 
    pj_kn(j, "super_n", bin->super_class);
    tmp = rz_bin_java_class_super(bin);
    pj_ks(j, "super_s", tmp ? tmp : "");
    free(tmp);
 
    pj_kn(j, "interfaces_count", bin->interfaces_count);
    pj_k(j, "interfaces");
    rz_bin_java_class_interfaces_as_json(bin, j);
 
    pj_kn(j, "methods_count", bin->methods_count);
    pj_k(j, "methods");
    rz_bin_java_class_methods_as_json(bin, j);
 
    pj_kn(j, "fields_count", bin->fields_count);
    pj_k(j, "fields");
    rz_bin_java_class_fields_as_json(bin, j);
 
    pj_kn(j, "attributes_count", bin->attributes_count);
    pj_ka(j, "attributes");
    for (ut32 i = 0; i < bin->attributes_count; ++i) {
        Attribute *attr = bin->attributes[i];
        if (!attr) {
            continue;
        }
        pj_o(j);
        pj_kn(j, "offset", attr->offset);
        pj_kn(j, "size", attr->attribute_length);
        pj_kn(j, "name_n", attr->attribute_name_index);
        tmp = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
        pj_ks(j, "name_s", tmp ? tmp : "");
        free(tmp);
        pj_end(j);
    }
    pj_end(j);
    pj_end(j);
}

References ACCESS_FLAG_MASK_ALL, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, free(), i, java_class_constant_pool_stringify_at(), NULL, java_attribute_t::offset, pj_end(), pj_k(), pj_ka(), pj_kn(), pj_ko(), pj_ks(), pj_o(), rz_bin_java_class_access_flags_readable(), rz_bin_java_class_const_pool_as_json(), rz_bin_java_class_fields_as_json(), rz_bin_java_class_interfaces_as_json(), rz_bin_java_class_methods_as_json(), rz_bin_java_class_name(), rz_bin_java_class_super(), rz_bin_java_class_version(), rz_return_if_fail, and autogen_x86imm::tmp.

Referenced by rz_cmd_javac_handler().

rz_bin_java_class_as_libraries()

RZ_API RZ_OWN RzList* rz_bin_java_class_as_libraries

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<char*> containing the class libraries.

Definition at line 1846 of file class_bin.c.

                                                                                     {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf(free);
    if (!list) {
        return NULL;
    }
    ut16 arg0, arg1;
    char *tmp;
 
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            tmp = NULL;
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool) {
                continue;
            }
            if (cpool->tag == CONSTANT_POOL_CLASS) {
                if (java_constant_pool_resolve(cpool, &arg0, &arg1) != 1) {
                    RZ_LOG_ERROR("java bin: can't resolve library with constant pool index %u\n", i);
                    break;
                }
                // arg0 is name_index
                tmp = java_class_constant_pool_stringify_at(bin, arg0);
            } else if (java_constant_pool_is_import(cpool)) {
                if (java_constant_pool_resolve(cpool, &arg0, &arg1) != 2) {
                    RZ_LOG_ERROR("java bin: can't resolve library with constant pool index %u\n", i);
                    break;
                }
                // arg0 is name_and_type_index
                const ConstPool *nat = java_class_constant_pool_at(bin, arg0);
                if (!nat ||
                    java_constant_pool_resolve(nat, &arg0, &arg1) != 1) {
                    RZ_LOG_ERROR("java bin: can't resolve library with constant pool index %u\n", i);
                    break;
                }
                // arg0 is name_index
                tmp = java_class_constant_pool_stringify_at(bin, arg0);
            }
            if (tmp && !rz_list_find(list, tmp, compare_strings)) {
                rz_list_append(list, tmp);
            } else {
                free(tmp);
            }
        }
    }
    return list;
}

References compare_strings(), CONSTANT_POOL_CLASS, free(), i, java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_is_import(), java_constant_pool_resolve(), list(), NULL, rz_list_append(), rz_list_find(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, java_constant_pool_t::tag, and autogen_x86imm::tmp.

Referenced by libs(), and rz_bin_java_class_as_source_code().

rz_bin_java_class_as_sections()

RZ_API RZ_OWN RzList* rz_bin_java_class_as_sections

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinSection*> containing the class sections.

Definition at line 1718 of file class_bin.c.

                                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *sections = rz_list_newf(section_free);
    if (!sections) {
        return NULL;
    }
    ut32 iname;
    char *tmp;
    char secname[512];
    ut64 end_offset;
    if (bin->constant_pool) {
        rz_list_append(sections,
            new_section("class.constant_pool",
                bin->constant_pool_offset,
                bin->interfaces_offset,
                RZ_PERM_R));
    }
    if (bin->interfaces) {
        rz_list_append(sections,
            new_section("class.interfaces",
                bin->interfaces_offset,
                bin->fields_offset,
                RZ_PERM_R));
    }
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            Field *field = bin->fields[i];
            if (!field) {
                continue;
            }
            tmp = java_class_constant_pool_stringify_at(bin, field->name_index);
            if (!tmp) {
                rz_warn_if_reached();
                continue;
            }
            snprintf(secname, sizeof(secname), "class.fields.%s.attr", tmp);
            if ((i + 1) < bin->fields_count && bin->fields[i + 1]) {
                end_offset = bin->fields[i + 1]->offset;
            } else {
                end_offset = bin->methods_offset;
            }
            for (iname = 0; rz_list_find(sections, secname, compare_section_names); iname++) {
                snprintf(secname, sizeof(secname), "class.fields.%s_%d.attr", tmp, iname);
            }
            free(tmp);
            rz_list_append(sections, new_section(secname, field->offset, end_offset, RZ_PERM_R));
        }
        rz_list_append(sections,
            new_section("class.fields",
                bin->fields_offset,
                bin->methods_offset,
                RZ_PERM_R));
    }
    if (bin->methods) {
        rz_list_append(sections,
            new_section("class.methods",
                bin->methods_offset,
                bin->attributes_offset,
                RZ_PERM_R));
 
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            Method *method = bin->methods[i];
            if (!method || method->attributes_count < 1) {
                continue;
            }
            tmp = java_class_constant_pool_stringify_at(bin, method->name_index);
            if (!tmp) {
                rz_warn_if_reached();
                continue;
            }
            snprintf(secname, sizeof(secname), "class.methods.%s.attr", tmp);
            for (iname = 0; rz_list_find(sections, secname, compare_section_names); iname++) {
                snprintf(secname, sizeof(secname), "class.methods.%s_%d.attr", tmp, iname);
            }
 
            if ((i + 1) < bin->methods_count && bin->methods[i + 1]) {
                end_offset = bin->methods[i + 1]->offset;
            } else {
                end_offset = bin->attributes_offset;
            }
            if (iname > 0) {
                snprintf(secname, sizeof(secname), "class.methods.%s_%d.attr", tmp, iname);
            } else {
                snprintf(secname, sizeof(secname), "class.methods.%s.attr", tmp);
            }
            rz_list_append(sections, new_section(secname, method->offset, end_offset, RZ_PERM_R));
 
            if (!method->attributes) {
                free(tmp);
                continue;
            }
 
            for (ut32 k = 0; k < method->attributes_count; ++k) {
                Attribute *attr = method->attributes[k];
                if (attr && attr->type == ATTRIBUTE_TYPE_CODE) {
                    AttributeCode *ac = (AttributeCode *)attr->info;
                    if (iname > 0) {
                        snprintf(secname, sizeof(secname), "class.methods.%s_%d.attr.%d.code", tmp, iname, k);
                    } else {
                        snprintf(secname, sizeof(secname), "class.methods.%s.attr.%d.code", tmp, k);
                    }
                    ut64 size = ac->code_offset + attr->attribute_length;
                    rz_list_append(sections, new_section(secname, ac->code_offset, size, RZ_PERM_R | RZ_PERM_X));
                    break;
                }
            }
            free(tmp);
        }
    }
    if (bin->attributes) {
        rz_list_append(sections,
            new_section("class.attr",
                bin->attributes_offset,
                bin->class_end_offset,
                RZ_PERM_R));
    }
 
    return sections;
}

References java_attribute_t::attribute_length, ATTRIBUTE_TYPE_CODE, java_method_t::attributes, java_method_t::attributes_count, java_attribute_code_t::code_offset, compare_section_names(), free(), i, if(), java_attribute_t::info, java_class_constant_pool_stringify_at(), k, java_field_t::name_index, java_method_t::name_index, new_section(), NULL, java_field_t::offset, java_method_t::offset, rz_list_append(), rz_list_find(), rz_list_newf(), RZ_PERM_R, RZ_PERM_X, rz_return_val_if_fail, rz_warn_if_reached, section_free(), sections(), snprintf, autogen_x86imm::tmp, java_attribute_t::type, and ut64().

Referenced by sections().

rz_bin_java_class_as_source_code()

RZ_API void rz_bin_java_class_as_source_code	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the class info as text source code.

Definition at line 708 of file class_bin.c.

                                                                                                      {
    rz_return_if_fail(bin && sb);
 
    char *dem = NULL;
    char *tmp = NULL;
    ut16 index;
 
    RzListIter *iter;
    RzList *list = rz_bin_java_class_as_libraries(bin);
    rz_list_foreach (list, iter, tmp) {
        rz_str_replace_char(tmp, '/', '.');
        rz_strbuf_appendf(sb, "import %s;\n", tmp);
    }
    if (rz_list_length(list) > 0) {
        rz_strbuf_appendf(sb, "\n");
    }
    rz_list_free(list);
 
    rz_strbuf_append(sb, "class");
 
    tmp = rz_bin_java_class_access_flags_readable(bin, ACCESS_FLAG_MASK_SRC);
    if (tmp) {
        rz_strbuf_appendf(sb, " %s", tmp);
        free(tmp);
    }
 
    tmp = rz_bin_java_class_name(bin);
    dem = rz_demangler_java(tmp);
    if (dem) {
        rz_strbuf_appendf(sb, " %s", dem);
        RZ_FREE(dem);
    } else {
        rz_strbuf_appendf(sb, " %s", tmp);
    }
 
    free(tmp);
 
    if (bin->access_flags & ACCESS_FLAG_SUPER) {
        tmp = rz_bin_java_class_super(bin);
        if (strcmp(tmp, "java/lang/Object") != 0) {
            rz_str_replace_char(tmp, '/', '.');
            rz_strbuf_appendf(sb, " extends %s", tmp);
        }
        free(tmp);
    }
 
    if (bin->interfaces_count > 0) {
        rz_strbuf_append(sb, " implements ");
        ut32 k = 0;
        for (ut32 i = 0; i < bin->interfaces_count; ++i) {
            if (!bin->interfaces[i]) {
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, bin->interfaces[i]->index);
            if (!cpool || java_constant_pool_resolve(cpool, &index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve constant pool index %u\n", bin->interfaces[i]->index);
                break;
            }
            tmp = java_class_constant_pool_stringify_at(bin, index);
            if ((dem = rz_demangler_java(tmp))) {
                free(tmp);
                tmp = dem;
            }
            if (k > 0) {
                rz_strbuf_appendf(sb, ", %s", tmp);
            } else {
                rz_strbuf_append(sb, tmp);
            }
            free(tmp);
            k++;
        }
        if (k < 1) {
            rz_strbuf_append(sb, "?");
        }
    }
 
    rz_strbuf_append(sb, " {\n");
 
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                continue;
            }
            rz_strbuf_append(sb, "  ");
 
            tmp = java_method_access_flags_readable(method);
            if (tmp) {
                rz_strbuf_appendf(sb, "%s ", tmp);
                free(tmp);
            }
 
            char *name = java_class_constant_pool_stringify_at(bin, method->name_index);
            if (!name) {
                name = strdup("?");
            }
            char *desc = java_class_constant_pool_stringify_at(bin, method->descriptor_index);
            if (!desc) {
                desc = strdup("(?)V");
            }
 
            if (desc[0] == '(') {
                tmp = rz_str_newf("%s%s", name, desc);
            } else {
                tmp = strdup(name);
            }
            free(desc);
            free(name);
 
            dem = rz_demangler_java(tmp);
            if (!dem) {
                rz_strbuf_append(sb, tmp);
            } else {
                rz_strbuf_append(sb, dem);
                RZ_FREE(dem);
            }
            free(tmp);
            rz_strbuf_append(sb, ";\n");
        }
    }
 
    if (bin->methods_count > 0 && bin->fields_count) {
        rz_strbuf_append(sb, "\n");
    }
 
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            const Field *field = bin->fields[i];
            if (!field) {
                continue;
            }
            rz_strbuf_append(sb, "  ");
 
            tmp = java_field_access_flags_readable(field);
            if (tmp) {
                rz_strbuf_appendf(sb, "%s ", tmp);
                free(tmp);
            }
 
            tmp = java_class_constant_pool_stringify_at(bin, field->name_index);
            if (tmp) {
                rz_str_replace_char(tmp, '/', '.');
                rz_strbuf_appendf(sb, "%s ", tmp);
                free(tmp);
            }
 
            tmp = java_class_constant_pool_stringify_at(bin, field->descriptor_index);
            if (tmp) {
                rz_str_replace_char(tmp, '/', '.');
                rz_strbuf_append(sb, tmp);
                free(tmp);
            }
            rz_strbuf_append(sb, "\n");
        }
    }
 
    rz_strbuf_append(sb, "}\n");
}

References ACCESS_FLAG_MASK_SRC, ACCESS_FLAG_SUPER, desc, java_field_t::descriptor_index, java_method_t::descriptor_index, free(), i, java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_resolve(), java_field_access_flags_readable(), java_method_access_flags_readable(), k, list(), java_field_t::name_index, java_method_t::name_index, NULL, rz_bin_java_class_access_flags_readable(), rz_bin_java_class_as_libraries(), rz_bin_java_class_name(), rz_bin_java_class_super(), rz_demangler_java(), RZ_FREE, rz_list_free(), rz_list_length(), RZ_LOG_ERROR, rz_return_if_fail, rz_str_newf(), rz_str_replace_char(), rz_strbuf_append(), rz_strbuf_appendf(), sb, strdup(), and autogen_x86imm::tmp.

Referenced by rz_cmd_javas_handler().

rz_bin_java_class_as_text()

RZ_API void rz_bin_java_class_as_text	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the class info as text.

Definition at line 591 of file class_bin.c.

                                                                                               {
    rz_return_if_fail(bin && sb);
    char number[16];
    char *tmp = NULL;
    int padding;
 
    tmp = rz_bin_java_class_version(bin);
    rz_strbuf_appendf(sb, "Version: (%u.%u) %s\n", bin->major_version, bin->minor_version, tmp);
    free(tmp);
 
    tmp = rz_bin_java_class_access_flags_readable(bin, ACCESS_FLAG_MASK_ALL);
    rz_strbuf_appendf(sb, "Flags: (0x%04x) %s\n", bin->access_flags, tmp);
    free(tmp);
 
    tmp = rz_bin_java_class_name(bin);
    rz_strbuf_appendf(sb, "Class: (#%u) %s\n", bin->this_class, tmp);
    free(tmp);
 
    tmp = rz_bin_java_class_super(bin);
    rz_strbuf_appendf(sb, "Super: (#%u) %s\n", bin->super_class, tmp);
    free(tmp);
 
    rz_bin_java_class_const_pool_as_text(bin, sb);
    rz_bin_java_class_interfaces_as_text(bin, sb);
    rz_bin_java_class_methods_as_text(bin, sb);
    rz_bin_java_class_fields_as_text(bin, sb);
 
    rz_strbuf_appendf(sb, "Attributes: %u\n", bin->attributes_count);
    padding = calculate_padding_ut16(bin->attributes_count) + 1;
    for (ut32 i = 0; i < bin->attributes_count; ++i) {
        Attribute *attr = bin->attributes[i];
        if (!attr) {
            continue;
        }
        snprintf(number, sizeof(number), "#%u", i);
        tmp = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
        rz_strbuf_appendf(sb, "  %-*s = #%-5u size: %-5u %s\n", padding, number, attr->attribute_name_index, attr->attribute_length, tmp);
        free(tmp);
    }
}

References ACCESS_FLAG_MASK_ALL, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, calculate_padding_ut16(), free(), i, java_class_constant_pool_stringify_at(), NULL, rz_bin_java_class_access_flags_readable(), rz_bin_java_class_const_pool_as_text(), rz_bin_java_class_fields_as_text(), rz_bin_java_class_interfaces_as_text(), rz_bin_java_class_methods_as_text(), rz_bin_java_class_name(), rz_bin_java_class_super(), rz_bin_java_class_version(), rz_return_if_fail, rz_strbuf_appendf(), sb, snprintf, and autogen_x86imm::tmp.

Referenced by rz_cmd_javac_handler().

rz_bin_java_class_const_pool_as_imports()

RZ_API RZ_OWN RzList* rz_bin_java_class_const_pool_as_imports

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinImport*> containing the class const pool.

Definition at line 1509 of file class_bin.c.

                                                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *imports = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!imports) {
        return NULL;
    }
    bool is_main;
    ut16 class_index, name_and_type_index, name_index, descriptor_index, class_name_index;
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool || !java_constant_pool_is_import(cpool)) {
                continue;
            }
            if (java_constant_pool_resolve(cpool, &class_index, &name_and_type_index) != 2) {
                RZ_LOG_ERROR("java bin: can't resolve import with constant pool index %u\n", i);
                continue;
            }
            const ConstPool *nat = java_class_constant_pool_at(bin, name_and_type_index);
            if (!nat ||
                java_constant_pool_resolve(nat, &name_index, &descriptor_index) != 2) {
                RZ_LOG_ERROR("java bin: can't resolve import with constant pool index %u\n", i);
                continue;
            }
            const ConstPool *pclass = java_class_constant_pool_at(bin, class_index);
            if (!pclass ||
                java_constant_pool_resolve(pclass, &class_name_index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve import with constant pool index %u\n", i);
                continue;
            }
 
            char *object = java_class_constant_pool_stringify_at(bin, class_name_index);
            if (!object) {
                continue;
            }
 
            RzBinImport *import = RZ_NEW0(RzBinImport);
            if (!import) {
                rz_warn_if_reached();
                continue;
            }
 
            char *class_name = (char *)rz_str_rchr(object, NULL, '/');
            if (class_name) {
                class_name[0] = 0;
                class_name++;
            }
            rz_str_replace_ch(object, '/', '.', 1);
 
            import->classname = strdup(class_name ? class_name : object);
            import->libname = class_name ? strdup(object) : NULL;
            import->name = java_class_constant_pool_stringify_at(bin, name_index);
            is_main = import->name && !strcmp(import->name, "main");
            import->bind = is_main ? RZ_BIN_BIND_GLOBAL_STR : NULL;
            import->type = is_main ? RZ_BIN_TYPE_FUNC_STR : import_type(cpool);
            import->descriptor = java_class_constant_pool_stringify_at(bin, descriptor_index);
            import->ordinal = i;
            free(object);
            rz_list_append(imports, import);
        }
    }
 
    if (bin->interfaces) {
        for (ut32 i = 0; i < bin->interfaces_count; ++i) {
            if (!bin->interfaces[i]) {
                continue;
            }
 
            RzBinImport *import = RZ_NEW0(RzBinImport);
            if (!import) {
                rz_warn_if_reached();
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, bin->interfaces[i]->index);
            if (!cpool || java_constant_pool_resolve(cpool, &class_index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve interface with constant pool index %u\n", i);
                rz_bin_import_free(import);
                continue;
            }
 
            import->classname = java_class_constant_pool_stringify_at(bin, class_index);
            import->name = strdup("*");
            import->bind = RZ_BIN_BIND_WEAK_STR;
            import->type = RZ_BIN_TYPE_IFACE_STR;
            import->ordinal = i;
            rz_list_append(imports, import);
        }
    }
 
    return imports;
}

References free(), i, import_type(), imports(), java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_is_import(), java_constant_pool_resolve(), NULL, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_WEAK_STR, rz_bin_import_free(), RZ_BIN_TYPE_FUNC_STR, RZ_BIN_TYPE_IFACE_STR, rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, rz_str_rchr(), rz_str_replace_ch(), rz_warn_if_reached, and strdup().

Referenced by imports().

rz_bin_java_class_const_pool_as_json()

RZ_API void rz_bin_java_class_const_pool_as_json	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL PJ *	j
	)

Returns the class const pool in json format via PJ arg.

Definition at line 1650 of file class_bin.c.

                                                                                                   {
    rz_return_if_fail(bin && j);
    const char *tag;
    char *text, *rtext;
    pj_a(j);
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            rtext = NULL;
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool) {
                continue;
            }
            tag = java_constant_pool_tag_name(cpool);
            if (!tag) {
                RZ_LOG_ERROR("java bin: invalid tag name for constant pool at index %u\n", i);
                continue;
            }
            text = java_constant_pool_stringify(cpool);
            pj_o(j);
            pj_kn(j, "index", i);
            pj_kn(j, "tag_n", cpool->tag);
            pj_ks(j, "tag_s", tag);
            pj_ks(j, "value", text ? text : "");
            if (i > 0 && !java_constant_pool_is_string(cpool) &&
                !java_constant_pool_is_number(cpool)) {
                rtext = rz_bin_java_class_const_pool_resolve_index(bin, i);
                pj_ks(j, "resolved", rtext ? rtext : "");
            }
            pj_end(j);
            free(text);
            free(rtext);
        }
    }
    pj_end(j);
}

References free(), i, java_constant_pool_is_number(), java_constant_pool_is_string(), java_constant_pool_stringify(), java_constant_pool_tag_name(), NULL, pj_a(), pj_end(), pj_kn(), pj_ks(), pj_o(), rz_bin_java_class_const_pool_resolve_index(), RZ_LOG_ERROR, rz_return_if_fail, java_constant_pool_t::tag, test-lz4-versions::tag, and create_tags_rz::text.

Referenced by rz_bin_java_class_as_json(), and rz_cmd_javap_handler().

rz_bin_java_class_const_pool_as_symbols()

RZ_API RZ_OWN RzList* rz_bin_java_class_const_pool_as_symbols

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinSymbol*> containing the class const pool.

Definition at line 1435 of file class_bin.c.

                                                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!list) {
        return NULL;
    }
    char *method_name, *classname;
    bool is_main;
    ut16 class_index, name_and_type_index, name_index, descriptor_index, class_name_index;
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool || !java_constant_pool_is_import(cpool)) {
                continue;
            }
            if (java_constant_pool_resolve(cpool, &class_index, &name_and_type_index) != 2) {
                RZ_LOG_ERROR("java bin: can't resolve symbol with constant pool index %u\n", i);
                break;
            }
            const ConstPool *nat = java_class_constant_pool_at(bin, name_and_type_index);
            if (!nat ||
                java_constant_pool_resolve(nat, &name_index, &descriptor_index) != 2) {
                RZ_LOG_ERROR("java bin: can't resolve symbol with constant pool index %u\n", i);
                break;
            }
            const ConstPool *pclass = java_class_constant_pool_at(bin, class_index);
            if (!pclass ||
                java_constant_pool_resolve(pclass, &class_name_index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve symbol with constant pool index %u\n", i);
                break;
            }
            RzBinSymbol *symbol = rz_bin_symbol_new(NULL, cpool->offset, cpool->offset);
            if (!symbol) {
                rz_warn_if_reached();
                break;
            }
 
            char *desc = java_class_constant_pool_stringify_at(bin, descriptor_index);
            if (!desc) {
                desc = strdup("(?)V");
            }
 
            method_name = java_class_constant_pool_stringify_at(bin, name_index);
            if (!method_name) {
                method_name = strdup("unknown_method");
            }
            is_main = !strcmp(method_name, "main");
            classname = java_class_constant_pool_stringify_at(bin, class_name_index);
            symbol->name = add_class_name_to_name(method_name, symbol->classname);
            if (desc[0] == '(') {
                symbol->dname = rz_str_newf("%s%s", method_name, desc);
            } else {
                symbol->dname = strdup(method_name);
            }
            symbol->classname = rz_str_newf("L%s;", classname);
            symbol->libname = classname;
            rz_str_replace_ch(symbol->libname, '/', '.', 1);
            symbol->bind = RZ_BIN_BIND_IMPORT_STR;
            symbol->type = is_main ? RZ_BIN_TYPE_FUNC_STR : import_type(cpool);
            symbol->ordinal = i;
            symbol->is_imported = true;
            free(desc);
            free(method_name);
            rz_list_append(list, symbol);
        }
    }
 
    return list;
}

References add_class_name_to_name(), rz_bin_symbol_t::bind, rz_bin_symbol_t::classname, desc, rz_bin_symbol_t::dname, free(), i, import_type(), rz_bin_symbol_t::is_imported, java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_is_import(), java_constant_pool_resolve(), rz_bin_symbol_t::libname, list(), rz_bin_symbol_t::name, NULL, java_constant_pool_t::offset, rz_bin_symbol_t::ordinal, RZ_BIN_BIND_IMPORT_STR, rz_bin_symbol_free(), rz_bin_symbol_new(), RZ_BIN_TYPE_FUNC_STR, rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_newf(), rz_str_replace_ch(), rz_warn_if_reached, strdup(), and rz_bin_symbol_t::type.

Referenced by symbols().

rz_bin_java_class_const_pool_as_text()

RZ_API void rz_bin_java_class_const_pool_as_text	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the class const pool in text format via RzStrBuf arg.

Definition at line 1605 of file class_bin.c.

                                                                                                          {
    rz_return_if_fail(bin && sb);
 
    char number[16];
    const char *tag;
    char *text, *rtext;
    rz_strbuf_appendf(sb, "Constant pool: %u\n", bin->constant_pool_count);
    if (bin->constant_pool) {
        int padding = calculate_padding_ut16(bin->constant_pool_count) + 1;
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            rtext = NULL;
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool) {
                continue;
            }
            tag = java_constant_pool_tag_name(cpool);
            if (!tag) {
                RZ_LOG_ERROR("java bin: invalid tag name for constant pool at index %u\n", i);
                continue;
            }
            snprintf(number, sizeof(number), "#%u", i);
            text = java_constant_pool_stringify(cpool);
            if (i > 0 && !java_constant_pool_is_string(cpool) &&
                !java_constant_pool_is_number(cpool)) {
                rtext = rz_bin_java_class_const_pool_resolve_index(bin, i);
            }
            if (rtext) {
                char *dem = rz_demangler_java(rtext);
                if (dem) {
                    free(rtext);
                    rtext = dem;
                }
                rz_strbuf_appendf(sb, "  %*s = %-19s %-14s // %s\n", padding, number, tag, text, rtext);
            } else {
                rz_strbuf_appendf(sb, "  %*s = %-19s %s\n", padding, number, tag, text);
            }
            free(text);
            free(rtext);
        }
    }
}

References calculate_padding_ut16(), free(), i, java_constant_pool_is_number(), java_constant_pool_is_string(), java_constant_pool_stringify(), java_constant_pool_tag_name(), NULL, rz_bin_java_class_const_pool_resolve_index(), rz_demangler_java(), RZ_LOG_ERROR, rz_return_if_fail, rz_strbuf_appendf(), sb, snprintf, test-lz4-versions::tag, and create_tags_rz::text.

Referenced by rz_bin_java_class_as_text(), and rz_cmd_javap_handler().

rz_bin_java_class_const_pool_resolve_index()

RZ_API RZ_OWN char* rz_bin_java_class_const_pool_resolve_index	(	RZ_NONNULL RzBinJavaClass *	bin,
		st32	index
	)

Returns the string linked to the class const pool index.

Definition at line 644 of file class_bin.c.

                                                                                                           {
    rz_return_val_if_fail(bin && index >= 0, NULL);
    ut16 arg0, arg1;
    char *tmp;
    const ConstPool *cpool = java_class_constant_pool_at(bin, index);
 
    if (!cpool || !index) {
        return NULL;
    }
    if (java_constant_pool_is_string(cpool) ||
        java_constant_pool_is_number(cpool)) {
        return java_constant_pool_stringify(cpool);
    } else if (cpool->tag == CONSTANT_POOL_CLASS) {
        if (java_constant_pool_resolve(cpool, &arg0, NULL) != 1) {
            RZ_LOG_ERROR("java bin: can't resolve constant pool index %u\n", index);
            return NULL;
        }
        tmp = rz_bin_java_class_const_pool_resolve_index(bin, arg0);
        if (tmp[0] == '[' && tmp[1] == 'L') {
            return tmp;
        }
        char *res = rz_str_newf("L%s;", tmp);
        free(tmp);
        return res;
    } else if (cpool->tag == CONSTANT_POOL_STRING) {
        if (java_constant_pool_resolve(cpool, &arg0, NULL) != 1) {
            RZ_LOG_ERROR("java bin: can't resolve constant pool index %u\n", index);
            return NULL;
        }
        char *s0 = rz_bin_java_class_const_pool_resolve_index(bin, arg0);
        tmp = rz_str_newf("\"%s\"", s0);
        free(s0);
        return tmp;
    } else if (is_dual_index(cpool)) {
        if (java_constant_pool_resolve(cpool, &arg0, &arg1) != 2) {
            RZ_LOG_ERROR("java bin: can't resolve constant pool index %u\n", index);
            return NULL;
        }
        char *s0 = arg0 ? rz_bin_java_class_const_pool_resolve_index(bin, arg0) : NULL;
        char *s1 = rz_bin_java_class_const_pool_resolve_index(bin, arg1);
        if ((arg0 && !s0) || !s1) {
            RZ_LOG_ERROR("java bin: can't resolve constant pool index %u\n", index);
            free(s0);
            free(s1);
            return NULL;
        }
        if (!arg0) {
            return s1;
        }
        if (s1[0] == '(') {
            tmp = rz_str_newf("%s%s", s0, s1);
        } else {
            tmp = rz_str_newf("%s.%s", s0, s1);
        }
        free(s0);
        free(s1);
        return tmp;
    }
    return NULL;
}

References CONSTANT_POOL_CLASS, CONSTANT_POOL_STRING, free(), is_dual_index(), java_class_constant_pool_at(), java_constant_pool_is_number(), java_constant_pool_is_string(), java_constant_pool_resolve(), java_constant_pool_stringify(), NULL, RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_newf(), s0, s1, java_constant_pool_t::tag, and autogen_x86imm::tmp.

Referenced by enrich_asm(), rz_bin_java_class_const_pool_as_json(), rz_bin_java_class_const_pool_as_text(), and rz_cmd_javar_handler().

rz_bin_java_class_debug_info()

RZ_API ut64 rz_bin_java_class_debug_info

(

RZ_NONNULL RzBinJavaClass *

bin

)

Definition at line 351 of file class_bin.c.

                                                                         {
    if (!bin) {
        return 0;
    }
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            Method *method = bin->methods[i];
            if (!method || method->attributes_count < 1) {
                continue;
            }
            for (ut32 k = 0; k < method->attributes_count; ++k) {
                Attribute *attr = method->attributes[k];
                if (attr && attr->type == ATTRIBUTE_TYPE_CODE) {
                    AttributeCode *ac = (AttributeCode *)attr->info;
                    for (ut32 k = 0; k < ac->attributes_count; k++) {
                        Attribute *cattr = ac->attributes[k];
                        if (cattr && cattr->type == ATTRIBUTE_TYPE_LINENUMBERTABLE) {
                            return RZ_BIN_DBG_LINENUMS | RZ_BIN_DBG_SYMS;
                        }
                    }
                }
            }
        }
    }
    return RZ_BIN_DBG_SYMS;
}

References ATTRIBUTE_TYPE_CODE, ATTRIBUTE_TYPE_LINENUMBERTABLE, java_attribute_code_t::attributes, java_method_t::attributes, java_attribute_code_t::attributes_count, java_method_t::attributes_count, i, java_attribute_t::info, k, RZ_BIN_DBG_LINENUMS, RZ_BIN_DBG_SYMS, and java_attribute_t::type.

Referenced by info().

rz_bin_java_class_entrypoints()

RZ_API RZ_OWN RzList* rz_bin_java_class_entrypoints

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinAddr*> containing the entrypoints.

Definition at line 927 of file class_bin.c.

                                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf(free);
    if (!list) {
        return NULL;
    }
 
    char *name = NULL;
    bool is_static;
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                rz_warn_if_reached();
                continue;
            }
            is_static = method->access_flags & METHOD_ACCESS_FLAG_STATIC;
            if (!is_static) {
                name = java_class_constant_pool_stringify_at(bin, method->name_index);
                if (!name) {
                    continue;
                }
                if (strcmp(name, "main") != 0 && strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
                    free(name);
                    continue;
                }
                free(name);
            }
 
            ut64 addr = UT64_MAX;
            for (ut32 i = 0; i < method->attributes_count; ++i) {
                Attribute *attr = method->attributes[i];
                if (attr && attr->type == ATTRIBUTE_TYPE_CODE) {
                    AttributeCode *ac = (AttributeCode *)attr->info;
                    addr = ac->code_offset;
                    break;
                }
            }
            if (addr == UT64_MAX) {
                RZ_LOG_ERROR("java bin: can't resolve entrypoint address\n");
                continue;
            }
 
            RzBinAddr *entrypoint = RZ_NEW0(RzBinAddr);
            if (!entrypoint) {
                rz_warn_if_reached();
                continue;
            }
            entrypoint->vaddr = entrypoint->paddr = addr;
            rz_list_append(list, entrypoint);
        }
    }
    return list;
}

References java_method_t::access_flags, addr, ATTRIBUTE_TYPE_CODE, java_method_t::attributes, java_method_t::attributes_count, java_attribute_code_t::code_offset, free(), i, java_attribute_t::info, java_class_constant_pool_stringify_at(), list(), METHOD_ACCESS_FLAG_STATIC, java_method_t::name_index, NULL, rz_bin_addr_t::paddr, rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, rz_warn_if_reached, java_attribute_t::type, ut64(), UT64_MAX, and rz_bin_addr_t::vaddr.

Referenced by entrypoints().

rz_bin_java_class_fields_as_binfields()

RZ_API RZ_OWN RzList* rz_bin_java_class_fields_as_binfields

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinField*> containing the class fields.

Definition at line 1277 of file class_bin.c.

                                                                                            {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf((RzListFree)rz_bin_field_free);
    if (!list) {
        return NULL;
    }
 
    char *name = NULL;
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            const Field *field = bin->fields[i];
            if (!field) {
                rz_warn_if_reached();
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, field->name_index);
            if (!cpool || !java_constant_pool_is_string(cpool)) {
                RZ_LOG_ERROR("java bin: can't resolve field with constant pool index %u\n", field->name_index);
                continue;
            }
            name = java_constant_pool_stringify(cpool);
            if (!name) {
                continue;
            }
            RzBinField *bf = rz_bin_field_new(field->offset, field->offset, 0, name, NULL, NULL, false);
            if (bf) {
                bf->visibility = field->access_flags;
                bf->flags = java_access_flags_to_bin_flags(field->access_flags);
                bf->type = java_class_constant_pool_stringify_at(bin, field->descriptor_index);
                rz_list_append(list, bf);
            }
            free(name);
        }
    }
    return list;
}

References java_field_t::access_flags, java_field_t::descriptor_index, rz_bin_field_t::flags, free(), i, java_access_flags_to_bin_flags(), java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_is_string(), java_constant_pool_stringify(), list(), java_field_t::name_index, NULL, java_field_t::offset, rz_bin_field_free(), rz_bin_field_new(), rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_warn_if_reached, rz_bin_field_t::type, and rz_bin_field_t::visibility.

Referenced by classes(), and fields().

rz_bin_java_class_fields_as_json()

RZ_API void rz_bin_java_class_fields_as_json	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL PJ *	j
	)

Returns the fields in json format via PJ arg.

Definition at line 1366 of file class_bin.c.

                                                                                               {
    rz_return_if_fail(bin && j);
 
    pj_a(j);
 
    char *tmp;
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            const Field *field = bin->fields[i];
            if (!field) {
                rz_warn_if_reached();
                continue;
            }
            pj_o(j); // {
 
            pj_kn(j, "offset", field->offset);
 
            pj_kn(j, "access_flags_n", field->access_flags);
            tmp = java_field_access_flags_readable(field);
            pj_ks(j, "access_flags_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "name_n", field->name_index);
            tmp = java_class_constant_pool_stringify_at(bin, field->name_index);
            pj_ks(j, "name_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "descriptor_n", field->descriptor_index);
            tmp = java_class_constant_pool_stringify_at(bin, field->descriptor_index);
            pj_ks(j, "descriptor_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "attributes_count", field->attributes_count);
            pj_ka(j, "attributes"); // [
            for (ut32 i = 0; i < field->attributes_count; ++i) {
                Attribute *attr = field->attributes[i];
                if (!attr) {
                    continue;
                }
                pj_o(j);
                pj_kn(j, "offset", attr->offset);
                pj_kn(j, "size", attr->attribute_length);
                pj_kn(j, "name_n", attr->attribute_name_index);
                tmp = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
                pj_ks(j, "name_s", tmp ? tmp : "");
                free(tmp);
                pj_end(j);
            }
            pj_end(j); // ]
            pj_end(j); // }
        }
    }
    pj_end(j);
}

References java_field_t::access_flags, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, java_field_t::attributes, java_field_t::attributes_count, java_field_t::descriptor_index, free(), i, java_class_constant_pool_stringify_at(), java_field_access_flags_readable(), java_field_t::name_index, java_attribute_t::offset, java_field_t::offset, pj_a(), pj_end(), pj_ka(), pj_kn(), pj_ks(), pj_o(), rz_return_if_fail, rz_warn_if_reached, and autogen_x86imm::tmp.

Referenced by rz_bin_java_class_as_json(), and rz_cmd_javaf_handler().

rz_bin_java_class_fields_as_symbols()

RZ_API RZ_OWN RzList* rz_bin_java_class_fields_as_symbols

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinSymbol*> containing the class fields.

Definition at line 1227 of file class_bin.c.

                                                                                          {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!list) {
        return NULL;
    }
 
    char *field_name = NULL;
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            const Field *field = bin->fields[i];
            if (!field) {
                rz_warn_if_reached();
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, field->name_index);
            if (!cpool || !java_constant_pool_is_string(cpool)) {
                RZ_LOG_ERROR("java bin: can't resolve field with constant pool index %u\n", field->name_index);
                continue;
            }
            field_name = java_constant_pool_stringify(cpool);
            if (!field_name) {
                continue;
            }
            RzBinSymbol *symbol = rz_bin_symbol_new(NULL, field->offset, field->offset);
            if (!symbol) {
                rz_warn_if_reached();
                free(field_name);
                continue;
            }
            symbol->classname = rz_bin_java_class_name(bin);
            symbol->name = add_class_name_to_name(field_name, symbol->classname);
            symbol->size = 0;
            symbol->bind = java_field_is_global(field) ? RZ_BIN_BIND_GLOBAL_STR : RZ_BIN_BIND_LOCAL_STR;
            symbol->type = RZ_BIN_TYPE_OBJECT_STR;
            symbol->ordinal = i;
            symbol->visibility = field->access_flags;
            symbol->visibility_str = java_field_access_flags_readable(field);
            symbol->method_flags = java_access_flags_to_bin_flags(field->access_flags);
            free(field_name);
            rz_list_append(list, symbol);
        }
    }
    return list;
}

References java_field_t::access_flags, add_class_name_to_name(), rz_bin_symbol_t::bind, rz_bin_symbol_t::classname, field_name, free(), i, java_access_flags_to_bin_flags(), java_class_constant_pool_at(), java_constant_pool_is_string(), java_constant_pool_stringify(), java_field_access_flags_readable(), java_field_is_global(), list(), rz_bin_symbol_t::method_flags, rz_bin_symbol_t::name, java_field_t::name_index, NULL, java_field_t::offset, rz_bin_symbol_t::ordinal, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_LOCAL_STR, rz_bin_java_class_name(), rz_bin_symbol_free(), rz_bin_symbol_new(), RZ_BIN_TYPE_OBJECT_STR, rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_warn_if_reached, rz_bin_symbol_t::size, rz_bin_symbol_t::type, rz_bin_symbol_t::visibility, and rz_bin_symbol_t::visibility_str.

Referenced by symbols().

rz_bin_java_class_fields_as_text()

RZ_API void rz_bin_java_class_fields_as_text	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the fields in text format via RzStrBuf arg.

Definition at line 1318 of file class_bin.c.

                                                                                                      {
    rz_return_if_fail(bin && sb);
 
    rz_strbuf_appendf(sb, "Fields: %u\n", bin->fields_count);
    char number[16];
    char *flags, *name, *descr;
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            const Field *field = bin->fields[i];
            if (!field) {
                rz_warn_if_reached();
                continue;
            }
            flags = java_field_access_flags_readable(field);
            name = java_class_constant_pool_stringify_at(bin, field->name_index);
            descr = java_class_constant_pool_stringify_at(bin, field->descriptor_index);
 
            if (flags) {
                rz_strbuf_appendf(sb, "  %s %s%s;\n", flags, name, descr);
            } else {
                rz_strbuf_appendf(sb, "  %s%s;\n", name, descr);
            }
            rz_strbuf_appendf(sb, "    name: %s\n", name);
            rz_strbuf_appendf(sb, "    descriptor: %s\n", descr);
            rz_strbuf_appendf(sb, "    flags: (0x%04x) %s\n", field->access_flags, flags);
 
            free(flags);
            free(name);
            free(descr);
            rz_strbuf_appendf(sb, "    attributes: %u\n", field->attributes_count);
            int padding = calculate_padding_ut16(field->attributes_count) + 1;
            for (ut32 i = 0; i < field->attributes_count; ++i) {
                Attribute *attr = field->attributes[i];
                if (!attr) {
                    continue;
                }
                snprintf(number, sizeof(number), "#%u", i);
                name = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
                rz_strbuf_appendf(sb, "      %*s = #%-5u size: %-5u %s\n", padding, number, attr->attribute_name_index, attr->attribute_length, name);
                free(name);
            }
        }
    }
}

References java_field_t::access_flags, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, java_field_t::attributes, java_field_t::attributes_count, calculate_padding_ut16(), java_field_t::descriptor_index, flags, free(), i, java_class_constant_pool_stringify_at(), java_field_access_flags_readable(), name, java_field_t::name_index, rz_return_if_fail, rz_strbuf_appendf(), rz_warn_if_reached, sb, and snprintf.

Referenced by rz_bin_java_class_as_text(), and rz_cmd_javaf_handler().

rz_bin_java_class_free()

RZ_API void rz_bin_java_class_free

(

RZ_NULLABLE RzBinJavaClass *

bin

)

Frees a RzBinJavaClass pointer.

Definition at line 407 of file class_bin.c.

                                                                    {
    if (!bin) {
        return;
    }
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            java_constant_pool_free(bin->constant_pool[i]);
        }
        free(bin->constant_pool);
    }
    if (bin->interfaces) {
        for (ut32 i = 0; i < bin->interfaces_count; ++i) {
            java_interface_free(bin->interfaces[i]);
        }
        free(bin->interfaces);
    }
    if (bin->fields) {
        for (ut32 i = 0; i < bin->fields_count; ++i) {
            java_field_free(bin->fields[i]);
        }
        free(bin->fields);
    }
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            java_method_free(bin->methods[i]);
        }
        free(bin->methods);
    }
    if (bin->attributes) {
        for (ut32 i = 0; i < bin->attributes_count; ++i) {
            java_attribute_free(bin->attributes[i]);
        }
        free(bin->attributes);
    }
    free(bin);
}

References free(), i, java_attribute_free(), java_constant_pool_free(), java_field_free(), java_interface_free, and java_method_free().

Referenced by destroy(), and java_class_parse().

rz_bin_java_class_interfaces_as_json()

RZ_API void rz_bin_java_class_interfaces_as_json	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL PJ *	j
	)

Returns the class interfaces as json via PJ arg.

Definition at line 1928 of file class_bin.c.

                                                                                                   {
    rz_return_if_fail(bin && j);
    pj_a(j);
    char *tmp = NULL;
    ut16 index;
    if (bin->interfaces) {
        for (ut32 i = 0; i < bin->interfaces_count; ++i) {
            if (!bin->interfaces[i]) {
                continue;
            }
 
            const ConstPool *cpool = java_class_constant_pool_at(bin, bin->interfaces[i]->index);
            if (!cpool || java_constant_pool_resolve(cpool, &index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve interface with constant pool index %u\n", i);
                continue;
            }
            pj_o(j);
            pj_kn(j, "offset", bin->interfaces[i]->offset);
            pj_kn(j, "name_n", bin->interfaces[i]->index);
            tmp = java_class_constant_pool_stringify_at(bin, index);
            rz_str_replace_char(tmp, '/', '.');
            pj_ks(j, "name_s", tmp ? tmp : "");
            free(tmp);
            pj_end(j);
        }
    }
    pj_end(j);
}

References free(), i, java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_resolve(), NULL, pj_a(), pj_end(), pj_kn(), pj_ks(), pj_o(), RZ_LOG_ERROR, rz_return_if_fail, rz_str_replace_char(), and autogen_x86imm::tmp.

Referenced by rz_bin_java_class_as_json(), and rz_cmd_javai_handler().

rz_bin_java_class_interfaces_as_text()

RZ_API void rz_bin_java_class_interfaces_as_text	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the class interfaces as text via RzStrBuf arg.

Definition at line 1898 of file class_bin.c.

                                                                                                          {
    rz_return_if_fail(bin && sb);
 
    ut16 index;
    char number[16];
    char *tmp = NULL;
    rz_strbuf_appendf(sb, "Interfaces: %u\n", bin->interfaces_count);
    if (bin->interfaces) {
        int padding = calculate_padding_ut16(bin->constant_pool_count) + 1;
        for (ut32 i = 0; i < bin->interfaces_count; ++i) {
            if (!bin->interfaces[i]) {
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, bin->interfaces[i]->index);
            if (!cpool || java_constant_pool_resolve(cpool, &index, NULL) != 1) {
                RZ_LOG_ERROR("java bin: can't resolve interface with constant pool index %u\n", i);
                break;
            }
            snprintf(number, sizeof(number), "#%u", i);
            tmp = java_class_constant_pool_stringify_at(bin, index);
            rz_str_replace_char(tmp, '/', '.');
            rz_strbuf_appendf(sb, "  %*s = #%-5u %s\n", padding, number, index, tmp);
            free(tmp);
        }
    }
}

References calculate_padding_ut16(), free(), i, java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_resolve(), NULL, RZ_LOG_ERROR, rz_return_if_fail, rz_str_replace_char(), rz_strbuf_appendf(), sb, snprintf, and autogen_x86imm::tmp.

Referenced by rz_bin_java_class_as_text(), and rz_cmd_javai_handler().

rz_bin_java_class_language()

RZ_API RZ_BORROW const char* rz_bin_java_class_language

(

RZ_NONNULL RzBinJavaClass *

bin

)

Definition at line 378 of file class_bin.c.

                                                                                        {
    rz_return_val_if_fail(bin, NULL);
    const char *language = "java";
    char *string = NULL;
    if (bin->constant_pool) {
        for (ut32 i = 0; i < bin->constant_pool_count; ++i) {
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool || !java_constant_pool_is_string(cpool)) {
                continue;
            }
            string = java_constant_pool_stringify(cpool);
            if (string && !strncmp(string, "kotlin/jvm", 10)) {
                language = "kotlin";
                break;
            } else if (string && !strncmp(string, "org/codehaus/groovy/runtime", 27)) {
                language = "groovy";
                break;
            }
            free(string);
            string = NULL;
        }
    }
    free(string);
    return language;
}

References free(), i, java_constant_pool_is_string(), java_constant_pool_stringify(), NULL, and rz_return_val_if_fail.

Referenced by info().

rz_bin_java_class_methods_as_json()

RZ_API void rz_bin_java_class_methods_as_json	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL PJ *	j
	)

Returns the methods in json format via PJ arg.

Definition at line 1169 of file class_bin.c.

                                                                                                {
    rz_return_if_fail(bin && j);
 
    pj_a(j);
 
    char *tmp;
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                rz_warn_if_reached();
                continue;
            }
            pj_o(j); // {
            pj_kn(j, "offset", method->offset);
 
            pj_kn(j, "access_flags_n", method->access_flags);
            tmp = java_method_access_flags_readable(method);
            pj_ks(j, "access_flags_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "name_n", method->name_index);
            tmp = java_class_constant_pool_stringify_at(bin, method->name_index);
            pj_ks(j, "name_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "descriptor_n", method->descriptor_index);
            tmp = java_class_constant_pool_stringify_at(bin, method->descriptor_index);
            pj_ks(j, "descriptor_s", tmp ? tmp : "");
            free(tmp);
 
            pj_kn(j, "attributes_count", method->attributes_count);
            pj_ka(j, "attributes"); // [
            for (ut32 i = 0; i < method->attributes_count; ++i) {
                Attribute *attr = method->attributes[i];
                if (!attr) {
                    rz_warn_if_reached();
                    continue;
                }
                pj_o(j);
                pj_kn(j, "offset", attr->offset);
                pj_kn(j, "size", attr->attribute_length);
                pj_kn(j, "name_n", attr->attribute_name_index);
                tmp = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
                pj_ks(j, "name_s", tmp ? tmp : "");
                free(tmp);
                pj_end(j);
            }
            pj_end(j); // ]
            pj_end(j); // }
        }
    }
    pj_end(j);
}

References java_method_t::access_flags, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, java_method_t::attributes, java_method_t::attributes_count, java_method_t::descriptor_index, free(), i, java_class_constant_pool_stringify_at(), java_method_access_flags_readable(), java_method_t::name_index, java_attribute_t::offset, java_method_t::offset, pj_a(), pj_end(), pj_ka(), pj_kn(), pj_ks(), pj_o(), rz_return_if_fail, rz_warn_if_reached, and autogen_x86imm::tmp.

Referenced by rz_bin_java_class_as_json(), and rz_cmd_javam_handler().

rz_bin_java_class_methods_as_symbols()

RZ_API RZ_OWN RzList* rz_bin_java_class_methods_as_symbols

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinSymbol*> containing the class methods.

Definition at line 1052 of file class_bin.c.

                                                                                           {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!list) {
        return NULL;
    }
 
    char *method_name = NULL;
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                rz_warn_if_reached();
                continue;
            }
            const ConstPool *cpool = java_class_constant_pool_at(bin, method->name_index);
            if (!cpool || !java_constant_pool_is_string(cpool)) {
                RZ_LOG_ERROR("java bin: can't resolve method with constant pool index %u\n", method->name_index);
                continue;
            }
            method_name = java_constant_pool_stringify(cpool);
            if (!method_name) {
                continue;
            }
            ut64 size = 0;
            ut64 addr = UT64_MAX;
            for (ut32 i = 0; i < method->attributes_count; ++i) {
                Attribute *attr = method->attributes[i];
                if (attr && attr->type == ATTRIBUTE_TYPE_CODE) {
                    AttributeCode *ac = (AttributeCode *)attr->info;
                    addr = ac->code_offset;
                    size = attr->attribute_length;
                    break;
                }
            }
            RzBinSymbol *symbol = rz_bin_symbol_new(NULL, addr, addr);
            if (!symbol) {
                rz_warn_if_reached();
                free(method_name);
                continue;
            }
            char *desc = java_class_constant_pool_stringify_at(bin, method->descriptor_index);
            if (!desc) {
                desc = strdup("(?)V");
            }
 
            symbol->classname = rz_bin_java_class_name(bin);
            symbol->dname = rz_str_newf("%s%s", method_name, desc);
            symbol->name = add_class_name_to_name(method_name, symbol->classname);
            symbol->size = size;
            symbol->bind = java_method_is_global(method) ? RZ_BIN_BIND_GLOBAL_STR : RZ_BIN_BIND_LOCAL_STR;
            symbol->type = RZ_BIN_TYPE_FUNC_STR;
            symbol->ordinal = rz_list_length(list);
            symbol->visibility = method->access_flags;
            symbol->visibility_str = java_method_access_flags_readable(method);
            symbol->libname = rz_demangler_java(symbol->classname);
            symbol->method_flags = java_access_flags_to_bin_flags(method->access_flags);
            free(desc);
            free(method_name);
            rz_list_append(list, symbol);
        }
    }
    return list;
}

References java_method_t::access_flags, add_class_name_to_name(), addr, java_attribute_t::attribute_length, ATTRIBUTE_TYPE_CODE, java_method_t::attributes, java_method_t::attributes_count, rz_bin_symbol_t::bind, rz_bin_symbol_t::classname, java_attribute_code_t::code_offset, desc, java_method_t::descriptor_index, rz_bin_symbol_t::dname, free(), i, java_attribute_t::info, java_access_flags_to_bin_flags(), java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_is_string(), java_constant_pool_stringify(), java_method_access_flags_readable(), java_method_is_global(), rz_bin_symbol_t::libname, list(), rz_bin_symbol_t::method_flags, rz_bin_symbol_t::name, java_method_t::name_index, NULL, rz_bin_symbol_t::ordinal, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_LOCAL_STR, rz_bin_java_class_name(), rz_bin_symbol_free(), rz_bin_symbol_new(), RZ_BIN_TYPE_FUNC_STR, rz_demangler_java(), rz_list_append(), rz_list_length(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_newf(), rz_warn_if_reached, rz_bin_symbol_t::size, strdup(), java_attribute_t::type, rz_bin_symbol_t::type, ut64(), UT64_MAX, rz_bin_symbol_t::visibility, and rz_bin_symbol_t::visibility_str.

Referenced by classes(), and symbols().

rz_bin_java_class_methods_as_text()

RZ_API void rz_bin_java_class_methods_as_text	(	RZ_NONNULL RzBinJavaClass *	bin,
		RZ_NONNULL RzStrBuf *	sb
	)

Returns the methods in text format via RzStrBuf arg.

Definition at line 1121 of file class_bin.c.

                                                                                                       {
    rz_return_if_fail(bin && sb);
 
    rz_strbuf_appendf(sb, "Methods: %u\n", bin->methods_count);
    char number[16];
    char *flags, *name, *descr;
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                rz_warn_if_reached();
                continue;
            }
            flags = java_method_access_flags_readable(method);
            name = java_class_constant_pool_stringify_at(bin, method->name_index);
            descr = java_class_constant_pool_stringify_at(bin, method->descriptor_index);
 
            if (flags) {
                rz_strbuf_appendf(sb, "  %s %s%s;\n", flags, name, descr);
            } else {
                rz_strbuf_appendf(sb, "  %s%s;\n", name, descr);
            }
            rz_strbuf_appendf(sb, "    name: %s\n", name);
            rz_strbuf_appendf(sb, "    descriptor: %s\n", descr);
            rz_strbuf_appendf(sb, "    flags: (0x%04x) %s\n", method->access_flags, flags ? flags : "");
 
            free(flags);
            free(name);
            free(descr);
            rz_strbuf_appendf(sb, "    attributes: %u\n", method->attributes_count);
            int padding = calculate_padding_ut16(method->attributes_count) + 1;
            for (ut32 i = 0; i < method->attributes_count; ++i) {
                Attribute *attr = method->attributes[i];
                if (!attr) {
                    continue;
                }
                snprintf(number, sizeof(number), "#%u", i);
                name = java_class_constant_pool_stringify_at(bin, attr->attribute_name_index);
                rz_strbuf_appendf(sb, "      %-*s = #%-5u size: %-5u %s\n", padding, number, attr->attribute_name_index, attr->attribute_length, name);
                free(name);
            }
        }
    }
}

References java_method_t::access_flags, java_attribute_t::attribute_length, java_attribute_t::attribute_name_index, java_method_t::attributes, java_method_t::attributes_count, calculate_padding_ut16(), java_method_t::descriptor_index, flags, free(), i, java_class_constant_pool_stringify_at(), java_method_access_flags_readable(), name, java_method_t::name_index, rz_return_if_fail, rz_strbuf_appendf(), rz_warn_if_reached, sb, and snprintf.

Referenced by rz_bin_java_class_as_text(), and rz_cmd_javam_handler().

rz_bin_java_class_name()

RZ_API RZ_OWN char* rz_bin_java_class_name

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns the class name.

Definition at line 447 of file class_bin.c.

                                                                           {
    ut16 index;
    rz_return_val_if_fail(bin, NULL);
    const ConstPool *cpool = java_class_constant_pool_at(bin, bin->this_class);
 
    if (!cpool || java_constant_pool_resolve(cpool, &index, NULL) != 1) {
        RZ_LOG_ERROR("java bin: unknown class name at constant pool index %u\n", bin->this_class);
        return strdup("unknown_class");
    }
 
    char *tmp = java_class_constant_pool_stringify_at(bin, index);
    char *class_name = rz_str_newf("L%s;", tmp);
    free(tmp);
    return class_name;
}

References free(), java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_resolve(), NULL, RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_newf(), strdup(), and autogen_x86imm::tmp.

Referenced by classes(), rz_bin_java_class_as_json(), rz_bin_java_class_as_source_code(), rz_bin_java_class_as_text(), rz_bin_java_class_fields_as_symbols(), and rz_bin_java_class_methods_as_symbols().

rz_bin_java_class_new()

RZ_API RZ_OWN RzBinJavaClass* rz_bin_java_class_new	(	RZ_NONNULL RzBuffer *	buf,
		ut64	offset,
		RZ_NONNULL Sdb *	kv
	)

Parses the java class file and returns a RzBinJavaClass struct.

Definition at line 289 of file class_bin.c.

                                                                                                               {
    RzBinJavaClass *bin = (RzBinJavaClass *)RZ_NEW0(RzBinJavaClass);
    rz_return_val_if_fail(bin, NULL);
 
    ut64 size;
    if (!java_class_parse(bin, offset, kv, buf, &size)) {
        return NULL;
    }
 
    java_set_sdb(kv, bin, offset, size);
 
    return bin;
}

References java_class_parse(), java_set_sdb(), NULL, RZ_NEW0, rz_return_val_if_fail, and ut64().

Referenced by load_buffer().

rz_bin_java_class_resolve_symbol()

RZ_API RZ_OWN RzBinAddr* rz_bin_java_class_resolve_symbol	(	RZ_NONNULL RzBinJavaClass *	bin,
		RzBinSpecialSymbol	resolve
	)

Resolves and returns the RzBinAddr struct linked to the input RzBinSpecialSymbol.

Definition at line 870 of file class_bin.c.

                                                                                                                      {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinAddr *ret = RZ_NEW0(RzBinAddr);
    if (!ret) {
        return NULL;
    }
    ret->paddr = UT64_MAX;
 
    char *name = NULL;
    if (bin->methods) {
        for (ut32 i = 0; i < bin->methods_count; ++i) {
            const Method *method = bin->methods[i];
            if (!method) {
                continue;
            }
 
            name = java_class_constant_pool_stringify_at(bin, method->name_index);
            if (!name) {
                continue;
            }
 
            if (resolve == RZ_BIN_SPECIAL_SYMBOL_ENTRY || resolve == RZ_BIN_SPECIAL_SYMBOL_INIT) {
                if (strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
                    free(name);
                    continue;
                }
            } else if (resolve == RZ_BIN_SPECIAL_SYMBOL_MAIN) {
                if (strcmp(name, "main") != 0) {
                    free(name);
                    continue;
                }
            }
            free(name);
            ut64 addr = UT64_MAX;
            for (ut32 i = 0; i < method->attributes_count; ++i) {
                Attribute *attr = method->attributes[i];
                if (attr && attr->type == ATTRIBUTE_TYPE_CODE) {
                    AttributeCode *ac = (AttributeCode *)attr->info;
                    addr = ac->code_offset;
                    break;
                }
            }
            if (addr == UT64_MAX) {
                RZ_LOG_ERROR("java bin: can't resolve symbol address\n");
                continue;
            }
            ret->paddr = addr;
            break;
        }
    }
    return ret;
}

References addr, ATTRIBUTE_TYPE_CODE, java_method_t::attributes, java_method_t::attributes_count, java_attribute_code_t::code_offset, free(), i, java_attribute_t::info, java_class_constant_pool_stringify_at(), java_method_t::name_index, NULL, rz_bin_addr_t::paddr, resolve(), RZ_BIN_SPECIAL_SYMBOL_ENTRY, RZ_BIN_SPECIAL_SYMBOL_INIT, RZ_BIN_SPECIAL_SYMBOL_MAIN, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, java_attribute_t::type, ut64(), and UT64_MAX.

Referenced by binsym().

rz_bin_java_class_strings()

RZ_API RZ_OWN RzList* rz_bin_java_class_strings

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns a RzList<RzBinString*> containing the strings.

Definition at line 986 of file class_bin.c.

                                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    RzList *list = rz_list_newf(rz_bin_string_free);
    if (!list) {
        return NULL;
    }
 
    char *string;
    if (bin->constant_pool_count > 0) {
        for (ut32 i = 1; i < bin->constant_pool_count; ++i) {
            const ConstPool *cpool = bin->constant_pool[i];
            if (!cpool || !java_constant_pool_is_string(cpool) || cpool->size < 1) {
                continue;
            }
            string = java_constant_pool_stringify(cpool);
            if (!string) {
                RZ_LOG_ERROR("java bin: expecting a string, got NULL\n");
                continue;
            }
            RzBinString *bstr = RZ_NEW0(RzBinString);
            if (!bstr) {
                free(string);
                rz_warn_if_reached();
                continue;
            }
            bstr->paddr = cpool->offset;
            bstr->ordinal = i;
            bstr->length = cpool->size;
            bstr->size = cpool->size;
            bstr->string = string;
            bstr->type = RZ_STRING_ENC_MUTF8;
            rz_list_append(list, bstr);
        }
    }
 
    for (ut32 i = 0; i < bin->attributes_count; ++i) {
        Attribute *attr = bin->attributes[i];
        if (attr && attr->type == ATTRIBUTE_TYPE_SOURCEDEBUGEXTENSION) {
            RzBinString *bstr = RZ_NEW0(RzBinString);
            if (!bstr) {
                rz_warn_if_reached();
                continue;
            }
            bstr->paddr = attr->offset;
            bstr->ordinal = i;
            bstr->length = attr->attribute_length;
            bstr->size = attr->attribute_length;
            bstr->string = strdup(attr->info);
            bstr->type = RZ_STRING_ENC_UTF8;
            rz_list_append(list, bstr);
        }
    }
    return list;
}

References java_attribute_t::attribute_length, ATTRIBUTE_TYPE_SOURCEDEBUGEXTENSION, free(), i, java_attribute_t::info, java_constant_pool_is_string(), java_constant_pool_stringify(), rz_bin_string_t::length, list(), NULL, java_attribute_t::offset, java_constant_pool_t::offset, rz_bin_string_t::ordinal, rz_bin_string_t::paddr, rz_bin_string_free(), rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, RZ_STRING_ENC_MUTF8, RZ_STRING_ENC_UTF8, rz_warn_if_reached, java_constant_pool_t::size, rz_bin_string_t::size, strdup(), rz_bin_string_t::string, java_attribute_t::type, and rz_bin_string_t::type.

Referenced by strings().

rz_bin_java_class_super()

RZ_API RZ_OWN char* rz_bin_java_class_super

(

RZ_NONNULL RzBinJavaClass *

bin

)

Returns the class super name.

Definition at line 466 of file class_bin.c.

                                                                            {
    ut16 index;
    rz_return_val_if_fail(bin, NULL);
    const ConstPool *cpool = java_class_constant_pool_at(bin, bin->super_class);
    if (!cpool || java_constant_pool_resolve(cpool, &index, NULL) != 1) {
        RZ_LOG_ERROR("java bin: unknown super name at constant pool index %u\n", bin->this_class);
        return strdup("unknown_super");
    }
    return java_class_constant_pool_stringify_at(bin, index);
}

References java_class_constant_pool_at(), java_class_constant_pool_stringify_at(), java_constant_pool_resolve(), NULL, RZ_LOG_ERROR, rz_return_val_if_fail, and strdup().

Referenced by classes(), rz_bin_java_class_as_json(), rz_bin_java_class_as_source_code(), and rz_bin_java_class_as_text().

rz_bin_java_class_version()

RZ_API RZ_OWN char* rz_bin_java_class_version

(

RZ_NONNULL RzBinJavaClass *

bin

)

Parses the java class file and returns a RzBinJavaClass struct.

Definition at line 306 of file class_bin.c.

                                                                              {
    if (!bin) {
        return NULL;
    }
#define is_version(bin, major, minor) ((bin)->major_version == (major) && (bin)->minor_version >= (minor))
    if (bin->major_version < 45 ||
        (bin->major_version == 45 && bin->minor_version < 3)) {
        return strdup("Java SE 1.0.2"); // old format
    } else if (is_version(bin, 45, 3)) {
        return strdup("Java SE 1.1");
    } else if (is_version(bin, 46, 0)) {
        return strdup("Java SE 1.2");
    } else if (is_version(bin, 47, 0)) {
        return strdup("Java SE 1.3");
    } else if (is_version(bin, 48, 0)) {
        return strdup("Java SE 1.4");
    } else if (is_version(bin, 49, 0)) {
        return strdup("Java SE 1.5"); // enum, generics, annotations
    } else if (is_version(bin, 50, 0)) {
        return strdup("Java SE 1.6"); // stackmaps
    } else if (is_version(bin, 51, 0)) {
        return strdup("Java SE 1.7");
    } else if (is_version(bin, 52, 0)) {
        return strdup("Java SE 1.8"); // lambda, type annos, param names
    } else if (is_version(bin, 53, 0)) {
        return strdup("Java SE 1.9"); // modules, indy string concat
    } else if (is_version(bin, 54, 0)) {
        return strdup("Java SE 10");
    } else if (is_version(bin, 55, 0)) {
        return strdup("Java SE 11"); // constant dynamic, nest mates
    } else if (is_version(bin, 56, 0)) {
        return strdup("Java SE 12");
    } else if (is_version(bin, 57, 0)) {
        return strdup("Java SE 13");
    } else if (is_version(bin, 58, 0)) {
        return strdup("Java SE 14");
    } else if (is_version(bin, 59, 0)) {
        return strdup("Java SE 15");
    } else if (is_version(bin, 60, 0)) {
        return strdup("Java SE 16");
    }
#undef is_version
    return strdup("unknown");
}

References is_version, NULL, and strdup().

Referenced by info(), java_set_sdb(), rz_bin_java_class_as_json(), and rz_bin_java_class_as_text().