marshal.c File Reference

#include <rz_io.h>
#include <rz_bin.h>
#include "marshal.h"
#include "pyc_magic.h"

Go to the source code of this file.

Macros
#define	if_true_return(cond, ret)

Functions
static pyc_object *	get_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	copy_object (pyc_object *object)
static void	free_object (pyc_object *object)
static ut8	get_ut8 (RzBuffer *buffer, bool *error)
static ut16	get_ut16 (RzBuffer *buffer, bool *error)
static ut32	get_ut32 (RzBuffer *buffer, bool *error)
static st32	get_st32 (RzBuffer *buffer, bool *error)
static st64	get_st64 (RzBuffer *buffer, bool *error)
static double	get_float64 (RzBuffer *buffer, bool *error)
static ut8 *	get_bytes (RzBuffer *buffer, ut32 size)
static pyc_object *	get_none_object (void)
static pyc_object *	get_false_object (void)
static pyc_object *	get_true_object (void)
static pyc_object *	get_int_object (RzBuffer *buffer)
static pyc_object *	get_int64_object (RzBuffer *buffer)
static pyc_object *	get_long_object (RzBuffer *buffer)
static pyc_object *	get_stringref_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_float_object (RzBuffer *buffer)
static pyc_object *	get_binary_float_object (RzBuffer *buffer)
static pyc_object *	get_complex_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_binary_complex_object (RzBuffer *buffer)
static pyc_object *	get_string_object (RzBuffer *buffer)
static pyc_object *	get_unicode_object (RzBuffer *buffer)
static pyc_object *	get_interned_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_array_object_generic (RzBinPycObj *pyc, RzBuffer *buffer, ut32 size)
static pyc_object *	get_small_tuple_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_tuple_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_list_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_dict_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_set_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_ascii_object_generic (RzBuffer *buffer, ut32 size, bool interned)
static pyc_object *	get_ascii_object (RzBuffer *buffer)
static pyc_object *	get_ascii_interned_object (RzBuffer *buffer)
static pyc_object *	get_short_ascii_object (RzBuffer *buffer)
static pyc_object *	get_short_ascii_interned_object (RzBuffer *buffer)
static pyc_object *	get_ref_object (RzBinPycObj *pyc, RzBuffer *buffer)
static pyc_object *	get_code_object (RzBinPycObj *pyc, RzBuffer *buffer)
ut64	get_code_object_addr (RzBinPycObj *pyc, RzBuffer *buffer, ut32 magic)
static bool	extract_sections_symbols (RzBinPycObj *pyc, pyc_object *obj, RzList *sections, RzList *symbols, RzList *cobjs, char *prefix)
bool	get_sections_symbols_from_code_objects (RzBinPycObj *pyc, RzBuffer *buffer, RzList *sections, RzList *symbols, RzList *cobjs, ut32 magic)

Macro Definition Documentation

if_true_return

#define if_true_return	(		cond,
			ret
	)

Value:

    if (cond) { \
        return (ret); \
    }

Definition at line 12 of file marshal.c.

Function Documentation

copy_object()

static pyc_object * copy_object ( pyc_object *  object )

static

Definition at line 775 of file marshal.c.

                                                   {
    pyc_object *copy = RZ_NEW0(pyc_object);
    if (!copy || !object) {
        free(copy);
        return NULL;
    }
    copy->type = object->type;
    switch (object->type) {
    case TYPE_NULL:
        break;
    case TYPE_TUPLE:
    case TYPE_SMALL_TUPLE:
        copy->data = rz_list_clone(object->data);
        break;
    case TYPE_INT:
    case TYPE_INT64:
    case TYPE_NONE:
    case TYPE_TRUE:
    case TYPE_FALSE:
    case TYPE_STRING:
    case TYPE_ASCII:
    case TYPE_SHORT_ASCII:
    case TYPE_ASCII_INTERNED:
    case TYPE_SHORT_ASCII_INTERNED:
        copy->data = strdup(object->data);
        break;
    case TYPE_CODE_v0:
    case TYPE_CODE_v1: {
        pyc_code_object *src = object->data;
        pyc_code_object *dst = RZ_NEW0(pyc_code_object);
        if (!dst) {
            break;
        }
        memcpy(dst, src, sizeof(*dst));
        dst->code = copy_object(src->code);
        dst->consts = copy_object(src->consts);
        dst->names = copy_object(src->names);
        dst->varnames = copy_object(src->varnames);
        dst->freevars = copy_object(src->freevars);
        dst->cellvars = copy_object(src->cellvars);
        dst->filename = copy_object(src->filename);
        dst->name = copy_object(src->name);
        dst->lnotab = copy_object(src->lnotab);
        copy->data = dst;
    } break;
    case TYPE_REF:
        copy->data = copy_object(object->data);
        break;
    case TYPE_ELLIPSIS:
    case TYPE_STOPITER:
    case TYPE_BINARY_COMPLEX:
    case TYPE_BINARY_FLOAT:
    case TYPE_COMPLEX:
    case TYPE_STRINGREF:
    case TYPE_DICT:
    case TYPE_FLOAT:
    case TYPE_FROZENSET:
    case TYPE_INTERNED:
    case TYPE_LIST:
    case TYPE_LONG:
    case TYPE_SET:
    case TYPE_UNICODE:
    case TYPE_UNKNOWN:
        RZ_LOG_ERROR("Copy not implemented for type %x\n", object->type);
        break;
    default:
        RZ_LOG_ERROR("Undefined type in copy_object (%x)\n", object->type);
        break;
    }
    if (!copy->data) {
        RZ_FREE(copy);
    }
    return copy;
}

References pyc_object::data, dst, free(), memcpy(), NULL, RZ_FREE, rz_list_clone(), RZ_LOG_ERROR, RZ_NEW0, src, strdup(), pyc_object::type, TYPE_ASCII, TYPE_ASCII_INTERNED, TYPE_BINARY_COMPLEX, TYPE_BINARY_FLOAT, TYPE_CODE_v0, TYPE_CODE_v1, TYPE_COMPLEX, TYPE_DICT, TYPE_ELLIPSIS, TYPE_FALSE, TYPE_FLOAT, TYPE_FROZENSET, TYPE_INT, TYPE_INT64, TYPE_INTERNED, TYPE_LIST, TYPE_LONG, TYPE_NONE, TYPE_NULL, TYPE_REF, TYPE_SET, TYPE_SHORT_ASCII, TYPE_SHORT_ASCII_INTERNED, TYPE_SMALL_TUPLE, TYPE_STOPITER, TYPE_STRING, TYPE_STRINGREF, TYPE_TRUE, TYPE_TUPLE, TYPE_UNICODE, and TYPE_UNKNOWN.

Referenced by get_object(), and get_ref_object().

extract_sections_symbols()

static bool extract_sections_symbols ( RzBinPycObj *  pyc, pyc_object *  obj, RzList *  sections, RzList *  symbols, RzList *  cobjs, char *  prefix  )

static

Definition at line 1125 of file marshal.c.

                                                                                                                                        {
    pyc_code_object *cobj = NULL;
    RzBinSection *section = NULL;
    RzBinSymbol *symbol = NULL;
    RzListIter *i = NULL;
 
    // each code object is a section
    if_true_return(!obj || (obj->type != TYPE_CODE_v1 && obj->type != TYPE_CODE_v0), false);
 
    cobj = obj->data;
 
    if_true_return(!cobj || !cobj->name, false);
    if_true_return(cobj->name->type != TYPE_ASCII && cobj->name->type != TYPE_STRING && cobj->name->type != TYPE_INTERNED, false);
    if_true_return(!cobj->name->data, false);
    if_true_return(!cobj->consts, false);
 
    // add the cobj to objs list
    if (!rz_list_append(cobjs, cobj)) {
        goto fail;
    }
    section = RZ_NEW0(RzBinSection);
    symbol = RZ_NEW0(RzBinSymbol);
    prefix = rz_str_newf("%s%s%s", prefix ? prefix : "",
        prefix ? "." : "", (const char *)cobj->name->data);
    if (!prefix || !section || !symbol) {
        goto fail;
    }
    section->name = strdup(prefix);
    if (!section->name) {
        goto fail;
    }
    section->paddr = cobj->start_offset;
    section->vaddr = cobj->start_offset;
    section->size = cobj->end_offset - cobj->start_offset;
    section->vsize = cobj->end_offset - cobj->start_offset;
    if (!rz_list_append(sections, section)) {
        goto fail;
    }
    section = NULL;
    // start building symbol
    symbol->name = strdup(prefix);
    // symbol->bind;
    symbol->type = RZ_BIN_TYPE_FUNC_STR;
    symbol->size = cobj->end_offset - cobj->start_offset;
    symbol->vaddr = cobj->start_offset;
    symbol->paddr = cobj->start_offset;
    symbol->ordinal = pyc->symbols_ordinal++;
    if (cobj->consts->type != TYPE_TUPLE && cobj->consts->type != TYPE_SMALL_TUPLE) {
        goto fail;
    }
    if (!rz_list_append(symbols, symbol)) {
        goto fail;
    }
    rz_list_foreach (((RzList *)(cobj->consts->data)), i, obj)
        extract_sections_symbols(pyc, obj, sections, symbols, cobjs, prefix);
    free(prefix);
    return true;
fail:
 
    free(section);
    free(prefix);
    free(symbol);
    return false;
}

References pyc_code_object::consts, pyc_object::data, pyc_code_object::end_offset, fail, free(), i, if_true_return, pyc_code_object::name, rz_bin_symbol_t::name, NULL, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, prefix, RZ_BIN_TYPE_FUNC_STR, rz_list_append(), RZ_NEW0, rz_str_newf(), sections(), section::size, rz_bin_symbol_t::size, pyc_code_object::start_offset, strdup(), symbols(), pyc_context::symbols_ordinal, pyc_object::type, rz_bin_symbol_t::type, TYPE_ASCII, TYPE_CODE_v0, TYPE_CODE_v1, TYPE_INTERNED, TYPE_SMALL_TUPLE, TYPE_STRING, TYPE_TUPLE, and rz_bin_symbol_t::vaddr.

Referenced by get_sections_symbols_from_code_objects().

free_object()

static void free_object ( pyc_object *  object )

static

Definition at line 712 of file marshal.c.

                                            {
    if (!object) {
        return;
    }
    switch (object->type) {
    case TYPE_SMALL_TUPLE:
    case TYPE_TUPLE:
        rz_list_free(object->data);
        break;
    case TYPE_STRING:
    case TYPE_TRUE:
    case TYPE_FALSE:
    case TYPE_INT:
    case TYPE_NONE:
    case TYPE_NULL:
    case TYPE_ASCII_INTERNED:
    case TYPE_SHORT_ASCII:
    case TYPE_ASCII:
    case TYPE_SHORT_ASCII_INTERNED:
        free(object->data);
        break;
    case TYPE_CODE_v0:
    case TYPE_CODE_v1: {
        pyc_code_object *cobj = object->data;
        free_object(cobj->code);
        free_object(cobj->consts);
        free_object(cobj->names);
        free_object(cobj->varnames);
        free_object(cobj->freevars);
        free_object(cobj->cellvars);
        free_object(cobj->filename);
        free_object(cobj->name);
        free_object(cobj->lnotab);
        free(object->data);
    } break;
    case TYPE_REF:
        free_object(object->data);
        break;
    case TYPE_SET:
    case TYPE_FROZENSET:
    case TYPE_ELLIPSIS:
    case TYPE_STOPITER:
    case TYPE_BINARY_COMPLEX:
    case TYPE_BINARY_FLOAT:
    case TYPE_COMPLEX:
    case TYPE_STRINGREF:
    case TYPE_DICT:
    case TYPE_FLOAT:
    case TYPE_INT64:
    case TYPE_INTERNED:
    case TYPE_LIST:
    case TYPE_LONG:
    case TYPE_UNICODE:
    case TYPE_UNKNOWN:
        RZ_LOG_ERROR("Free not implemented for type %x\n", object->type);
        break;
    default:
        RZ_LOG_ERROR("Undefined type in free_object (%x)\n", object->type);
        break;
    }
    free(object);
}

References pyc_code_object::cellvars, pyc_code_object::code, pyc_code_object::consts, pyc_object::data, pyc_code_object::filename, free(), pyc_code_object::freevars, pyc_code_object::lnotab, pyc_code_object::name, pyc_code_object::names, rz_list_free(), RZ_LOG_ERROR, pyc_object::type, TYPE_ASCII, TYPE_ASCII_INTERNED, TYPE_BINARY_COMPLEX, TYPE_BINARY_FLOAT, TYPE_CODE_v0, TYPE_CODE_v1, TYPE_COMPLEX, TYPE_DICT, TYPE_ELLIPSIS, TYPE_FALSE, TYPE_FLOAT, TYPE_FROZENSET, TYPE_INT, TYPE_INT64, TYPE_INTERNED, TYPE_LIST, TYPE_LONG, TYPE_NONE, TYPE_NULL, TYPE_REF, TYPE_SET, TYPE_SHORT_ASCII, TYPE_SHORT_ASCII_INTERNED, TYPE_SMALL_TUPLE, TYPE_STOPITER, TYPE_STRING, TYPE_STRINGREF, TYPE_TRUE, TYPE_TUPLE, TYPE_UNICODE, TYPE_UNKNOWN, and pyc_code_object::varnames.

Referenced by get_array_object_generic(), get_code_object(), get_code_object_addr(), get_dict_object(), get_object(), and get_sections_symbols_from_code_objects().

get_array_object_generic()

static pyc_object* get_array_object_generic ( RzBinPycObj *  pyc, RzBuffer *  buffer, ut32  size  )

static

Definition at line 479 of file marshal.c.

                                                                                           {
    pyc_object *tmp = NULL;
    pyc_object *ret = NULL;
    ut32 i = 0;
 
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->data = rz_list_newf((RzListFree)free_object);
    if (!ret->data) {
        free(ret);
        return NULL;
    }
    for (i = 0; i < size; i++) {
        tmp = get_object(pyc, buffer);
        if (!tmp) {
            rz_list_free(ret->data);
            RZ_FREE(ret);
            return NULL;
        }
        if (!rz_list_append(ret->data, tmp)) {
            free_object(tmp);
            rz_list_free(ret->data);
            free(ret);
            return NULL;
        }
    }
    return ret;
}

References pyc_object::data, free(), free_object(), get_object(), i, NULL, RZ_FREE, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, and autogen_x86imm::tmp.

Referenced by get_list_object(), get_set_object(), get_small_tuple_object(), and get_tuple_object().

get_ascii_interned_object()

static pyc_object* get_ascii_interned_object ( RzBuffer *  buffer )

static

Definition at line 658 of file marshal.c.

                                                               {
    bool error = false;
    ut32 n;
 
    n = get_ut32(buffer, &error);
    if (error) {
        return NULL;
    }
    return get_ascii_object_generic(buffer, n, true);
}

References error(), get_ascii_object_generic(), get_ut32(), n, and NULL.

Referenced by get_object().

get_ascii_object()

static pyc_object* get_ascii_object ( RzBuffer *  buffer )

static

Definition at line 647 of file marshal.c.

                                                      {
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (error) {
        return NULL;
    }
    return get_ascii_object_generic(buffer, n, true);
}

References error(), get_ascii_object_generic(), get_ut32(), n, and NULL.

Referenced by get_object().

get_ascii_object_generic()

static pyc_object* get_ascii_object_generic ( RzBuffer *  buffer, ut32  size, bool  interned  )

static

Definition at line 632 of file marshal.c.

                                                                                        {
    pyc_object *ret = NULL;
 
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_ASCII;
    ret->data = get_bytes(buffer, size);
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, get_bytes(), NULL, RZ_FREE, RZ_NEW0, pyc_object::type, and TYPE_ASCII.

Referenced by get_ascii_interned_object(), get_ascii_object(), get_short_ascii_interned_object(), and get_short_ascii_object().

get_binary_complex_object()

static pyc_object* get_binary_complex_object ( RzBuffer *  buffer )

static

Definition at line 379 of file marshal.c.

                                                               {
    pyc_object *ret = NULL;
    bool error = false;
    double a, b;
 
    // a + bj
    a = get_float64(buffer, &error);
    b = get_float64(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_BINARY_COMPLEX;
    ret->data = rz_str_newf("%.15g+%.15gj", a, b);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References a, b, pyc_object::data, error(), get_float64(), NULL, RZ_FREE, RZ_NEW0, rz_str_newf(), pyc_object::type, and TYPE_BINARY_COMPLEX.

Referenced by get_object().

get_binary_float_object()

static pyc_object* get_binary_float_object ( RzBuffer *  buffer )

static

Definition at line 291 of file marshal.c.

                                                             {
    pyc_object *ret = NULL;
    bool error = false;
    double f;
 
    f = get_float64(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_FLOAT;
    ret->data = rz_str_newf("%.15g", f);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References pyc_object::data, error(), f, get_float64(), NULL, RZ_FREE, RZ_NEW0, rz_str_newf(), pyc_object::type, and TYPE_FLOAT.

Referenced by get_object().

get_bytes()

static ut8* get_bytes ( RzBuffer *  buffer, ut32  size  )

static

Definition at line 71 of file marshal.c.

                                                   {
    ut8 *ret = RZ_NEWS0(ut8, size + 1);
    if (!ret) {
        return NULL;
    }
    if (rz_buf_read(buffer, ret, size) < size) {
        free(ret);
        return NULL;
    }
    return ret;
}

References free(), NULL, rz_buf_read(), and RZ_NEWS0.

Referenced by get_ascii_object_generic(), get_interned_object(), get_string_object(), and get_unicode_object().

get_code_object()

static pyc_object* get_code_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 850 of file marshal.c.

                                                                       {
    bool error = false;
 
    pyc_object *ret = RZ_NEW0(pyc_object);
    pyc_code_object *cobj = RZ_NEW0(pyc_code_object);
    if (!ret || !cobj) {
        free(ret);
        free(cobj);
        return NULL;
    }
 
    // ret->type = TYPE_CODE_v1;
    //  support start from v1.0
    ret->data = cobj;
 
    bool v10_to_12 = magic_int_within(pyc->magic_int, 39170, 16679, &error); // 1.0.1 - 1.2
    bool v13_to_22 = magic_int_within(pyc->magic_int, 11913, 60718, &error); // 1.3b1 - 2.2a1
    bool v11_to_14 = magic_int_within(pyc->magic_int, 39170, 20117, &error); // 1.0.1 - 1.4
    bool v15_to_22 = magic_int_within(pyc->magic_int, 20121, 60718, &error); // 1.5a1 - 2.2a1
    bool v13_to_20 = magic_int_within(pyc->magic_int, 11913, 50824, &error); // 1.3b1 - 2.0b1
    // bool v21_to_27 = (!v13_to_20) && magic_int_within (magic_int, 60124, 62212, &error);
    bool has_posonlyargcount = magic_int_within(pyc->magic_int, 3410, 3424, &error); // v3.8.0a4 - latest
    if (error) {
        free(ret);
        free(cobj);
        return NULL;
    }
 
    if (v13_to_22) {
        cobj->argcount = get_ut16(buffer, &error);
    } else if (v10_to_12) {
        cobj->argcount = 0;
    } else {
        cobj->argcount = get_ut32(buffer, &error);
    }
 
    if (has_posonlyargcount) {
        cobj->posonlyargcount = get_ut32(buffer, &error); // Included in argcount
    } else {
        cobj->posonlyargcount = 0; // None
    }
 
    if (((3020 < (pyc->magic_int & 0xffff)) && ((pyc->magic_int & 0xffff) < 20121)) && (!v11_to_14)) {
        cobj->kwonlyargcount = get_ut32(buffer, &error); // Not included in argcount
    } else {
        cobj->kwonlyargcount = 0;
    }
 
    if (v13_to_22) {
        cobj->nlocals = get_ut16(buffer, &error);
    } else if (v10_to_12) {
        cobj->nlocals = 0;
    } else {
        cobj->nlocals = get_ut32(buffer, &error);
    }
 
    if (v15_to_22) {
        cobj->stacksize = get_ut16(buffer, &error);
    } else if (v11_to_14 || v10_to_12) {
        cobj->stacksize = 0;
    } else {
        cobj->stacksize = get_ut32(buffer, &error);
    }
 
    if (v13_to_22) {
        cobj->flags = get_ut16(buffer, &error);
    } else if (v10_to_12) {
        cobj->flags = 0;
    } else {
        cobj->flags = get_ut32(buffer, &error);
    }
 
    // to help disassemble the code
    cobj->start_offset = rz_buf_tell(buffer) + 5; // 1 from get_object() and 4 from get_string_object()
    if (!pyc->refs) {
        return ret; // return for entried part to get the root object of this file
    }
    cobj->code = get_object(pyc, buffer);
    cobj->end_offset = rz_buf_tell(buffer);
 
    cobj->consts = get_object(pyc, buffer);
    cobj->names = get_object(pyc, buffer);
 
    if (v10_to_12) {
        cobj->varnames = NULL;
    } else {
        cobj->varnames = get_object(pyc, buffer);
    }
 
    if (!(v10_to_12 || v13_to_20)) {
        cobj->freevars = get_object(pyc, buffer);
        cobj->cellvars = get_object(pyc, buffer);
    } else {
        cobj->freevars = NULL;
        cobj->cellvars = NULL;
    }
 
    cobj->filename = get_object(pyc, buffer);
    cobj->name = get_object(pyc, buffer);
 
    if (v15_to_22) {
        cobj->firstlineno = get_ut16(buffer, &error);
    } else if (v11_to_14) {
        cobj->firstlineno = 0;
    } else {
        cobj->firstlineno = get_ut32(buffer, &error);
    }
 
    if (v11_to_14) {
        cobj->lnotab = NULL;
    } else {
        cobj->lnotab = get_object(pyc, buffer);
    }
 
    if (error) {
        free_object(cobj->code);
        free_object(cobj->consts);
        free_object(cobj->names);
        free_object(cobj->varnames);
        free_object(cobj->freevars);
        free_object(cobj->cellvars);
        free_object(cobj->filename);
        free_object(cobj->name);
        free_object(cobj->lnotab);
        free(cobj);
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References pyc_code_object::argcount, pyc_code_object::cellvars, pyc_code_object::code, pyc_code_object::consts, pyc_object::data, pyc_code_object::end_offset, error(), pyc_code_object::filename, pyc_code_object::firstlineno, pyc_code_object::flags, free(), free_object(), pyc_code_object::freevars, get_object(), get_ut16(), get_ut32(), pyc_code_object::kwonlyargcount, pyc_code_object::lnotab, pyc_context::magic_int, magic_int_within(), pyc_code_object::name, pyc_code_object::names, pyc_code_object::nlocals, NULL, pyc_code_object::posonlyargcount, pyc_context::refs, rz_buf_tell(), RZ_FREE, RZ_NEW0, pyc_code_object::stacksize, pyc_code_object::start_offset, and pyc_code_object::varnames.

Referenced by get_code_object_addr(), and get_object().

get_code_object_addr()

ut64 get_code_object_addr	(	RzBinPycObj *	pyc,
		RzBuffer *	buffer,
		ut32	magic
	)

Definition at line 981 of file marshal.c.

                                                                          {
    pyc->magic_int = magic;
    pyc_object *co = get_code_object(pyc, buffer);
    ut64 result = 0;
    if (!co) {
        return 0;
    }
 
    pyc_code_object *cobj = co->data;
    result = cobj->start_offset;
    free_object(co);
 
    return result;
}

References pyc_object::data, free_object(), get_code_object(), pyc_context::magic_int, pyc_code_object::start_offset, and ut64().

Referenced by get_entrypoint().

get_complex_object()

static pyc_object* get_complex_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 313 of file marshal.c.

                                                                          {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 size = 0;
    ut32 n1 = 0;
    ut32 n2 = 0;
 
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
 
    if ((pyc->magic_int & 0xffff) <= 62061) {
        n1 = get_ut8(buffer, &error);
    } else {
        n1 = get_st32(buffer, &error);
    }
    if (error) {
        free(ret);
        return NULL;
    }
    ut8 *s1 = malloc(n1 + 1);
    if (!s1) {
        return NULL;
    }
    /* object contain string representation of the number */
    size = rz_buf_read(buffer, s1, n1);
    if (size != n1) {
        RZ_FREE(s1);
        RZ_FREE(ret);
        return NULL;
    }
    s1[n1] = '\0';
 
    if ((pyc->magic_int & 0xffff) <= 62061) {
        n2 = get_ut8(buffer, &error);
    } else
        n2 = get_st32(buffer, &error);
    if (error) {
        return NULL;
    }
    ut8 *s2 = malloc(n2 + 1);
    if (!s2) {
        return NULL;
    }
    /* object contain string representation of the number */
    size = rz_buf_read(buffer, s2, n2);
    if (size != n2) {
        RZ_FREE(s1);
        RZ_FREE(s2);
        RZ_FREE(ret);
        return NULL;
    }
    s2[n2] = '\0';
 
    ret->type = TYPE_COMPLEX;
    ret->data = rz_str_newf("%s+%sj", s1, s2);
    RZ_FREE(s1);
    RZ_FREE(s2);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References pyc_object::data, error(), free(), get_st32(), get_ut8(), pyc_context::magic_int, malloc(), NULL, rz_buf_read(), RZ_FREE, RZ_NEW0, rz_str_newf(), s1, s2, pyc_object::type, and TYPE_COMPLEX.

Referenced by get_object().

get_dict_object()

static pyc_object* get_dict_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 571 of file marshal.c.

                                                                       {
    pyc_object *ret = NULL,
           *key = NULL,
           *val = NULL;
 
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->data = rz_list_newf((RzListFree)free_object);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    for (;;) {
        key = get_object(pyc, buffer);
        if (!key) {
            break;
        }
        if (!rz_list_append(ret->data, key)) {
            rz_list_free(ret->data);
            RZ_FREE(ret);
            free_object(key);
            return NULL;
        }
        val = get_object(pyc, buffer);
        if (!val) {
            break;
        }
        if (!rz_list_append(ret->data, val)) {
            rz_list_free(ret->data);
            RZ_FREE(ret);
            free_object(val);
            return NULL;
        }
    }
    ret->type = TYPE_DICT;
    return ret;
}

References pyc_object::data, free_object(), get_object(), key, NULL, RZ_FREE, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, pyc_object::type, TYPE_DICT, and val.

Referenced by get_object().

get_false_object()

static pyc_object* get_false_object ( void  )

static

Definition at line 98 of file marshal.c.

                                          {
    pyc_object *ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_FALSE;
    ret->data = strdup("False");
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, NULL, RZ_FREE, RZ_NEW0, strdup(), pyc_object::type, and TYPE_FALSE.

Referenced by get_object().

get_float64()

static double get_float64 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 63 of file marshal.c.

                                                         {
    double ret = 0;
    if (!rz_buf_read_le64(buffer, (ut64 *)&ret)) {
        *error = true;
    }
    return ret;
}

References error(), rz_buf_read_le64, and ut64().

Referenced by get_binary_complex_object(), and get_binary_float_object().

get_float_object()

static pyc_object* get_float_object ( RzBuffer *  buffer )

static

Definition at line 259 of file marshal.c.

                                                      {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 size = 0;
    ut8 n = 0;
 
    n = get_ut8(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ut8 *s = malloc(n + 1);
    if (!s) {
        free(ret);
        return NULL;
    }
    /* object contain string representation of the number */
    size = rz_buf_read(buffer, s, n);
    if (size != n) {
        RZ_FREE(s);
        RZ_FREE(ret);
        return NULL;
    }
    s[n] = '\0';
    ret->type = TYPE_FLOAT;
    ret->data = s;
    return ret;
}

References pyc_object::data, error(), free(), get_ut8(), malloc(), n, NULL, rz_buf_read(), RZ_FREE, RZ_NEW0, s, pyc_object::type, and TYPE_FLOAT.

Referenced by get_object().

get_int64_object()

static pyc_object* get_int64_object ( RzBuffer *  buffer )

static

Definition at line 144 of file marshal.c.

                                                      {
    pyc_object *ret = NULL;
    bool error = false;
    st64 i;
 
    i = get_st64(buffer, &error);
 
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_INT64;
    ret->data = rz_str_newf("%lld", i);
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, error(), get_st64(), i, NULL, RZ_FREE, RZ_NEW0, rz_str_newf(), st64, pyc_object::type, and TYPE_INT64.

Referenced by get_object().

get_int_object()

static pyc_object* get_int_object ( RzBuffer *  buffer )

static

Definition at line 124 of file marshal.c.

                                                    {
    bool error = false;
    pyc_object *ret = NULL;
 
    st32 i = get_st32(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_INT;
    ret->data = rz_str_newf("%d", i);
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, error(), get_st32(), i, NULL, RZ_FREE, RZ_NEW0, rz_str_newf(), st32, pyc_object::type, and TYPE_INT.

Referenced by get_object().

get_interned_object()

static pyc_object* get_interned_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 452 of file marshal.c.

                                                                           {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (string size out of range)");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_INTERNED;
    ret->data = get_bytes(buffer, n);
    /* add data pointer to interned table */
    rz_list_append(pyc->interned_table, ret->data);
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, error(), get_bytes(), get_ut32(), pyc_context::interned_table, n, NULL, RZ_FREE, rz_list_append(), RZ_LOG_ERROR, RZ_NEW0, ST32_MAX, pyc_object::type, and TYPE_INTERNED.

Referenced by get_object().

get_list_object()

static pyc_object* get_list_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 550 of file marshal.c.

                                                                       {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (list size out of range)\n");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = get_array_object_generic(pyc, buffer, n);
    if (ret) {
        ret->type = TYPE_LIST;
        return ret;
    }
    return NULL;
}

References error(), get_array_object_generic(), get_ut32(), n, NULL, RZ_LOG_ERROR, ST32_MAX, pyc_object::type, and TYPE_LIST.

Referenced by get_object().

get_long_object()

static pyc_object* get_long_object ( RzBuffer *  buffer )

static

Definition at line 167 of file marshal.c.

                                                     {
    pyc_object *ret = NULL;
    bool error = false;
    bool neg = false;
    ut32 tmp = 0;
    size_t size;
    size_t i, j = 0, left = 0;
    ut32 n;
    char *hexstr;
    char digist2hex[] = "0123456789abcdef";
 
    st32 ndigits = get_st32(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_LONG;
    if (ndigits < 0) {
        ndigits = -ndigits;
        neg = true;
    }
    if (ndigits == 0) {
        ret->data = strdup("0x0");
    } else {
        // the explicit cast is safe since ndigits is positive
        size = (size_t)ndigits * 15;
        size = (size - 1) / 4 + 1;
        size += 4 + (neg ? 1 : 0);
        hexstr = malloc(size);
        if (!hexstr) {
            free(ret);
            return NULL;
        }
        memset(hexstr, 0x20, size);
        j = size - 1;
        hexstr[j] = 0;
        for (i = 0; i < ndigits; i++) {
            n = get_ut16(buffer, &error);
            tmp |= n << left;
            left += 15;
 
            while (left >= 4) {
                hexstr[--j] = digist2hex[tmp & 0xf];
                tmp >>= 4;
                left -= 4;
            }
        }
 
        if (tmp) {
            hexstr[--j] = digist2hex[tmp & 0xf];
        }
 
        hexstr[--j] = 'x';
        hexstr[--j] = '0';
        if (neg) {
            hexstr[--j] = '-';
        }
 
        rz_str_trim(hexstr);
        ret->data = hexstr;
    }
    return ret;
}

References pyc_object::data, error(), free(), get_st32(), get_ut16(), i, malloc(), memset(), n, neg(), NULL, RZ_NEW0, rz_str_trim(), st32, strdup(), autogen_x86imm::tmp, pyc_object::type, and TYPE_LONG.

Referenced by get_object().

get_none_object()

static pyc_object* get_none_object ( void  )

static

Definition at line 83 of file marshal.c.

                                         {
    pyc_object *ret;
 
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_NONE;
    ret->data = strdup("None");
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, NULL, RZ_FREE, RZ_NEW0, strdup(), pyc_object::type, and TYPE_NONE.

Referenced by get_object().

get_object()

static pyc_object * get_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 996 of file marshal.c.

                                                                  {
    bool error = false;
    pyc_object *ret = NULL;
    ut8 code = get_ut8(buffer, &error);
    ut8 flag = code & FLAG_REF;
    RzListIter *ref_idx = NULL;
    ut8 type = code & ~FLAG_REF;
 
    if (error) {
        return NULL;
    }
 
    if (flag) {
        ret = get_none_object();
        if (!ret) {
            return NULL;
        }
        ref_idx = rz_list_append(pyc->refs, ret);
        if (!ref_idx) {
            free_object(ret);
            return NULL;
        }
    }
 
    switch (type) {
    case TYPE_NULL:
        return NULL;
    case TYPE_TRUE:
        return get_true_object();
    case TYPE_FALSE:
        return get_false_object();
    case TYPE_NONE:
        return get_none_object();
    case TYPE_REF:
        return get_ref_object(pyc, buffer);
    case TYPE_SMALL_TUPLE:
        ret = get_small_tuple_object(pyc, buffer);
        break;
    case TYPE_TUPLE:
        ret = get_tuple_object(pyc, buffer);
        break;
    case TYPE_STRING:
        ret = get_string_object(buffer);
        break;
    case TYPE_CODE_v0:
        ret = get_code_object(pyc, buffer);
        if (ret) {
            ret->type = TYPE_CODE_v0;
        }
        break;
    case TYPE_CODE_v1:
        ret = get_code_object(pyc, buffer);
        if (ret) {
            ret->type = TYPE_CODE_v1;
        }
        break;
    case TYPE_INT:
        ret = get_int_object(buffer);
        break;
    case TYPE_ASCII_INTERNED:
        ret = get_ascii_interned_object(buffer);
        break;
    case TYPE_SHORT_ASCII:
        ret = get_short_ascii_object(buffer);
        break;
    case TYPE_ASCII:
        ret = get_ascii_object(buffer);
        break;
    case TYPE_SHORT_ASCII_INTERNED:
        ret = get_short_ascii_interned_object(buffer);
        break;
    case TYPE_INT64:
        ret = get_int64_object(buffer);
        break;
    case TYPE_INTERNED:
        ret = get_interned_object(pyc, buffer);
        break;
    case TYPE_STRINGREF:
        ret = get_stringref_object(pyc, buffer);
        break;
    case TYPE_FLOAT:
        ret = get_float_object(buffer);
        break;
    case TYPE_BINARY_FLOAT:
        ret = get_binary_float_object(buffer);
        break;
    case TYPE_COMPLEX:
        ret = get_complex_object(pyc, buffer); // behaviour depends on Python version
        break;
    case TYPE_BINARY_COMPLEX:
        ret = get_binary_complex_object(buffer);
        break;
    case TYPE_LIST:
        ret = get_list_object(pyc, buffer);
        break;
    case TYPE_LONG:
        ret = get_long_object(buffer);
        break;
    case TYPE_UNICODE:
        ret = get_unicode_object(buffer);
        break;
    case TYPE_DICT:
        ret = get_dict_object(pyc, buffer);
        break;
    case TYPE_FROZENSET:
    case TYPE_SET:
        ret = get_set_object(pyc, buffer);
        break;
    case TYPE_STOPITER:
        ret = RZ_NEW0(pyc_object);
        break;
    case TYPE_ELLIPSIS:
        ret = RZ_NEW0(pyc_object);
        break;
    case TYPE_UNKNOWN:
        RZ_LOG_ERROR("Get not implemented for type 0x%x\n", type);
        return NULL;
    default:
        RZ_LOG_ERROR("Undefined type in get_object (0x%x)\n", type);
        return NULL;
    }
 
    if (flag && ref_idx) {
        free_object(ref_idx->data);
        ref_idx->data = copy_object(ret);
    }
    return ret;
}

References copy_object(), rz_list_iter_t::data, error(), FLAG_REF, free_object(), get_ascii_interned_object(), get_ascii_object(), get_binary_complex_object(), get_binary_float_object(), get_code_object(), get_complex_object(), get_dict_object(), get_false_object(), get_float_object(), get_int64_object(), get_int_object(), get_interned_object(), get_list_object(), get_long_object(), get_none_object(), get_ref_object(), get_set_object(), get_short_ascii_interned_object(), get_short_ascii_object(), get_small_tuple_object(), get_string_object(), get_stringref_object(), get_true_object(), get_tuple_object(), get_unicode_object(), get_ut8(), NULL, pyc_context::refs, rz_list_append(), RZ_LOG_ERROR, RZ_NEW0, type, pyc_object::type, TYPE_ASCII, TYPE_ASCII_INTERNED, TYPE_BINARY_COMPLEX, TYPE_BINARY_FLOAT, TYPE_CODE_v0, TYPE_CODE_v1, TYPE_COMPLEX, TYPE_DICT, TYPE_ELLIPSIS, TYPE_FALSE, TYPE_FLOAT, TYPE_FROZENSET, TYPE_INT, TYPE_INT64, TYPE_INTERNED, TYPE_LIST, TYPE_LONG, TYPE_NONE, TYPE_NULL, TYPE_REF, TYPE_SET, TYPE_SHORT_ASCII, TYPE_SHORT_ASCII_INTERNED, TYPE_SMALL_TUPLE, TYPE_STOPITER, TYPE_STRING, TYPE_STRINGREF, TYPE_TRUE, TYPE_TUPLE, TYPE_UNICODE, and TYPE_UNKNOWN.

Referenced by get_array_object_generic(), get_code_object(), get_dict_object(), and get_sections_symbols_from_code_objects().

get_ref_object()

static pyc_object* get_ref_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 691 of file marshal.c.

                                                                      {
    bool error = false;
    pyc_object *ret;
    pyc_object *obj;
    ut32 index;
 
    index = get_ut32(buffer, &error);
    if (error) {
        return NULL;
    }
    if (index >= rz_list_length(pyc->refs)) {
        return NULL;
    }
    obj = rz_list_get_n(pyc->refs, index);
    if (!obj) {
        return NULL;
    }
    ret = copy_object(obj);
    return ret;
}

References copy_object(), error(), get_ut32(), NULL, pyc_context::refs, rz_list_get_n(), and rz_list_length().

Referenced by get_object().

get_sections_symbols_from_code_objects()

bool get_sections_symbols_from_code_objects	(	RzBinPycObj *	pyc,
		RzBuffer *	buffer,
		RzList *	sections,
		RzList *	symbols,
		RzList *	cobjs,
		ut32	magic
	)

Definition at line 1190 of file marshal.c.

                                                                                                                                              {
    bool ret;
    pyc->magic_int = magic;
    pyc->refs = rz_list_newf((RzListFree)free_object);
    if (!pyc->refs) {
        return false;
    }
    ret = extract_sections_symbols(pyc, get_object(pyc, buffer), sections, symbols, cobjs, NULL);
    rz_list_free(pyc->refs);
    return ret;
}

References extract_sections_symbols(), free_object(), get_object(), pyc_context::magic_int, NULL, pyc_context::refs, rz_list_free(), rz_list_newf(), sections(), and symbols().

Referenced by pyc_get_sections_symbols().

get_set_object()

static pyc_object* get_set_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 611 of file marshal.c.

                                                                      {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (set size out of range)\n");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = get_array_object_generic(pyc, buffer, n);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_SET;
    return ret;
}

References error(), get_array_object_generic(), get_ut32(), n, NULL, RZ_LOG_ERROR, ST32_MAX, pyc_object::type, and TYPE_SET.

Referenced by get_object().

get_short_ascii_interned_object()

static pyc_object* get_short_ascii_interned_object ( RzBuffer *  buffer )

static

Definition at line 680 of file marshal.c.

                                                                     {
    bool error = false;
    ut8 n;
 
    n = get_ut8(buffer, &error);
    if (error) {
        return NULL;
    }
    return get_ascii_object_generic(buffer, n, true);
}

References error(), get_ascii_object_generic(), get_ut8(), n, and NULL.

Referenced by get_object().

get_short_ascii_object()

static pyc_object* get_short_ascii_object ( RzBuffer *  buffer )

static

Definition at line 669 of file marshal.c.

                                                            {
    bool error = false;
    ut8 n;
 
    n = get_ut8(buffer, &error);
    if (error) {
        return NULL;
    }
    return get_ascii_object_generic(buffer, n, false);
}

References error(), get_ascii_object_generic(), get_ut8(), n, and NULL.

Referenced by get_object().

get_small_tuple_object()

static pyc_object* get_small_tuple_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 512 of file marshal.c.

                                                                              {
    pyc_object *ret = NULL;
    bool error = false;
    ut8 n = 0;
 
    n = get_ut8(buffer, &error);
    if (error) {
        return NULL;
    }
    ret = get_array_object_generic(pyc, buffer, n);
    if (ret) {
        ret->type = TYPE_SMALL_TUPLE;
        return ret;
    }
    return NULL;
}

References error(), get_array_object_generic(), get_ut8(), n, NULL, pyc_object::type, and TYPE_SMALL_TUPLE.

Referenced by get_object().

get_st32()

static st32 get_st32 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 47 of file marshal.c.

                                                    {
    st32 ret = 0;
    if (!rz_buf_read_le32(buffer, (ut32 *)&ret)) {
        *error = true;
    }
    return ret;
}

References error(), rz_buf_read_le32, and st32.

Referenced by get_complex_object(), get_int_object(), get_long_object(), and get_stringref_object().

get_st64()

static st64 get_st64 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 55 of file marshal.c.

                                                    {
    st64 ret = 0;
    if (!rz_buf_read_le64(buffer, (ut64 *)&ret)) {
        *error = true;
    }
    return ret;
}

References error(), rz_buf_read_le64, st64, and ut64().

Referenced by get_int64_object().

get_string_object()

static pyc_object* get_string_object ( RzBuffer *  buffer )

static

Definition at line 403 of file marshal.c.

                                                       {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (string size out of range)");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_STRING;
    ret->data = get_bytes(buffer, n);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References pyc_object::data, error(), get_bytes(), get_ut32(), n, NULL, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, ST32_MAX, pyc_object::type, and TYPE_STRING.

Referenced by get_object().

get_stringref_object()

static pyc_object* get_stringref_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 234 of file marshal.c.

                                                                            {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_st32(buffer, &error);
    if (n >= rz_list_length(pyc->interned_table)) {
        RZ_LOG_ERROR("bad marshal data (string ref out of range)");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_STRINGREF;
    ret->data = rz_list_get_n(pyc->interned_table, n);
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, error(), get_st32(), pyc_context::interned_table, n, NULL, RZ_FREE, rz_list_get_n(), rz_list_length(), RZ_LOG_ERROR, RZ_NEW0, pyc_object::type, and TYPE_STRINGREF.

Referenced by get_object().

get_true_object()

static pyc_object* get_true_object ( void  )

static

Definition at line 111 of file marshal.c.

                                         {
    pyc_object *ret = RZ_NEW0(pyc_object);
    if (!ret) {
        return NULL;
    }
    ret->type = TYPE_TRUE;
    ret->data = strdup("True");
    if (!ret->data) {
        RZ_FREE(ret);
    }
    return ret;
}

References pyc_object::data, NULL, RZ_FREE, RZ_NEW0, strdup(), pyc_object::type, and TYPE_TRUE.

Referenced by get_object().

get_tuple_object()

static pyc_object* get_tuple_object ( RzBinPycObj *  pyc, RzBuffer *  buffer  )

static

Definition at line 529 of file marshal.c.

                                                                        {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (tuple size out of range)\n");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = get_array_object_generic(pyc, buffer, n);
    if (ret) {
        ret->type = TYPE_TUPLE;
        return ret;
    }
    return NULL;
}

References error(), get_array_object_generic(), get_ut32(), n, NULL, RZ_LOG_ERROR, ST32_MAX, pyc_object::type, and TYPE_TUPLE.

Referenced by get_object().

get_unicode_object()

static pyc_object* get_unicode_object ( RzBuffer *  buffer )

static

Definition at line 429 of file marshal.c.

                                                        {
    pyc_object *ret = NULL;
    bool error = false;
    ut32 n = 0;
 
    n = get_ut32(buffer, &error);
    if (n > ST32_MAX) {
        RZ_LOG_ERROR("bad marshal data (unicode size out of range)");
        return NULL;
    }
    if (error) {
        return NULL;
    }
    ret = RZ_NEW0(pyc_object);
    ret->type = TYPE_UNICODE;
    ret->data = get_bytes(buffer, n);
    if (!ret->data) {
        RZ_FREE(ret);
        return NULL;
    }
    return ret;
}

References pyc_object::data, error(), get_bytes(), get_ut32(), n, NULL, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, ST32_MAX, pyc_object::type, and TYPE_UNICODE.

Referenced by get_object().

get_ut16()

static ut16 get_ut16 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 30 of file marshal.c.

                                                    {
    ut16 ret = 0;
 
    if (!rz_buf_read_le16(buffer, &ret)) {
        *error = true;
    }
    return ret;
}

References error(), and rz_buf_read_le16.

Referenced by get_code_object(), and get_long_object().

get_ut32()

static ut32 get_ut32 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 39 of file marshal.c.

                                                    {
    ut32 ret = 0;
    if (!rz_buf_read_le32(buffer, &ret)) {
        *error = true;
    }
    return ret;
}

References error(), and rz_buf_read_le32.

Referenced by get_ascii_interned_object(), get_ascii_object(), get_code_object(), get_interned_object(), get_list_object(), get_ref_object(), get_set_object(), get_string_object(), get_tuple_object(), and get_unicode_object().

get_ut8()

static ut8 get_ut8 ( RzBuffer *  buffer, bool *  error  )

static

Definition at line 21 of file marshal.c.

                                                  {
    ut8 ret = 0;
    int size = rz_buf_read(buffer, &ret, sizeof(ret));
    if (size < sizeof(ret)) {
        *error = true;
    }
    return ret;
}

References error(), and rz_buf_read().

Referenced by get_complex_object(), get_float_object(), get_object(), get_short_ascii_interned_object(), get_short_ascii_object(), and get_small_tuple_object().