428 lines
24 KiB
C
428 lines
24 KiB
C
#ifndef _MAGIC_ANALYSIS_H
|
|
#define _MAGIC_ANALYSIS_H
|
|
|
|
#include <magic.h>
|
|
#include <magic_mem.h>
|
|
|
|
/* Special convenience types. */
|
|
#define MAGIC_TYPE_SPECIAL_INIT(STR) { 0, STR, NULL, 0, STR, 0, 0, 0, 0, 0, 0, \
|
|
0, MAGIC_TYPE_FUNCTION, MAGIC_TYPE_EXTERNAL, 0 }
|
|
EXTERN char magic_ne_str[];
|
|
EXTERN char magic_enf_str[];
|
|
EXTERN char magic_bo_str[];
|
|
EXTERN char magic_be_str[];
|
|
EXTERN char magic_bv_str[];
|
|
EXTERN char magic_vf_str[];
|
|
EXTERN const struct _magic_type magic_NULL_ENTRY_TYPE;
|
|
EXTERN const struct _magic_type magic_ENTRY_NOT_FOUND_TYPE;
|
|
EXTERN const struct _magic_type magic_BAD_OFFSET_TYPE;
|
|
EXTERN const struct _magic_type magic_BAD_ENTRY_TYPE;
|
|
EXTERN const struct _magic_type magic_BAD_VALUE_TYPE;
|
|
EXTERN const struct _magic_type magic_VALUE_FOUND;
|
|
#define MAGIC_TYPE_NULL_ENTRY (&magic_NULL_ENTRY_TYPE)
|
|
#define MAGIC_TYPE_ENTRY_NOT_FOUND (&magic_ENTRY_NOT_FOUND_TYPE)
|
|
#define MAGIC_TYPE_BAD_OFFSET (&magic_BAD_OFFSET_TYPE)
|
|
#define MAGIC_TYPE_BAD_ENTRY (&magic_BAD_ENTRY_TYPE)
|
|
#define MAGIC_TYPE_BAD_VALUE (&magic_BAD_VALUE_TYPE)
|
|
#define MAGIC_TYPE_VALUE_FOUND (&magic_VALUE_FOUND)
|
|
#define MAGIC_TYPE_IS_SPECIAL(T) (T == MAGIC_TYPE_NULL_ENTRY \
|
|
|| T == MAGIC_TYPE_ENTRY_NOT_FOUND || T == MAGIC_TYPE_BAD_OFFSET \
|
|
|| T == MAGIC_TYPE_BAD_ENTRY || T == MAGIC_TYPE_BAD_VALUE \
|
|
|| T == MAGIC_TYPE_VALUE_FOUND)
|
|
|
|
/* Magic state element macros. */
|
|
#define MAGIC_SEL_ANALYZE_POINTERS 0x00001
|
|
#define MAGIC_SEL_ANALYZE_NONPOINTERS 0x00002
|
|
#define MAGIC_SEL_ANALYZE_LIKELYPOINTERS 0x00004
|
|
#define MAGIC_SEL_ANALYZE_DATA 0x00008
|
|
#define MAGIC_SEL_ANALYZE_INVARIANTS 0x00010
|
|
#define MAGIC_SEL_ANALYZE_VIOLATIONS 0x00020
|
|
#define MAGIC_SEL_ANALYZE_WALKABLE 0x00040
|
|
#define MAGIC_SEL_ANALYZE_DYNAMIC 0x00080
|
|
#define MAGIC_SEL_ANALYZE_OUT_OF_BAND 0x00100
|
|
#define MAGIC_SEL_ANALYZE_LIB_SRC 0x00200
|
|
#define MAGIC_SEL_ANALYZE_ALL \
|
|
(MAGIC_SEL_ANALYZE_POINTERS | MAGIC_SEL_ANALYZE_NONPOINTERS \
|
|
| MAGIC_SEL_ANALYZE_DATA | MAGIC_SEL_ANALYZE_INVARIANTS \
|
|
| MAGIC_SEL_ANALYZE_VIOLATIONS | MAGIC_SEL_ANALYZE_WALKABLE \
|
|
| MAGIC_SEL_ANALYZE_DYNAMIC | MAGIC_SEL_ANALYZE_OUT_OF_BAND \
|
|
| MAGIC_SEL_ANALYZE_LIB_SRC)
|
|
|
|
#define MAGIC_SEL_SKIP_UNIONS 0x00400
|
|
#define MAGIC_SEL_SKIP_INTEGERS 0x00800
|
|
#define MAGIC_SEL_ANALYZE_NONPTRS_AS_PTRS 0x01000
|
|
#define MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS 0x02000
|
|
|
|
#define MAGIC_SEL_FOUND_DATA 0x04000
|
|
#define MAGIC_SEL_FOUND_INVARIANTS 0x08000
|
|
#define MAGIC_SEL_FOUND_VIOLATIONS 0X10000
|
|
#define MAGIC_SEL_FOUND_WALKABLE 0x20000
|
|
|
|
/* Magic state element analyzed. */
|
|
typedef enum {
|
|
_ptr_type_found,
|
|
_other_types_found,
|
|
_void_type_found,
|
|
_comp_trg_types_found,
|
|
_badentry_found
|
|
} _magic_trg_stats_t;
|
|
struct _magic_sel_analyzed_s {
|
|
unsigned type_id, contained_type_id;
|
|
int flags;
|
|
int num;
|
|
union {
|
|
struct {
|
|
void *value;
|
|
union {
|
|
struct _magic_dsentry dsentry;
|
|
struct _magic_dfunction dfunction;
|
|
} trg;
|
|
struct {
|
|
struct _magic_dsentry *dsentry;
|
|
struct _magic_dfunction *dfunction;
|
|
} trg_p;
|
|
int trg_flags;
|
|
int trg_offset;
|
|
_magic_selement_t trg_selements[MAGIC_MAX_RECURSIVE_TYPES + 1];
|
|
_magic_trg_stats_t trg_stats[MAGIC_MAX_RECURSIVE_TYPES + 1];
|
|
int first_legal_trg_type;
|
|
unsigned num_legal_trg_types;
|
|
unsigned num_trg_types;
|
|
} ptr;
|
|
struct {
|
|
int value;
|
|
int trg_flags;
|
|
} nonptr;
|
|
} u;
|
|
};
|
|
typedef struct _magic_sel_analyzed_s _magic_sel_analyzed_t;
|
|
|
|
#define MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
|
|
(((E)->u.ptr.trg_flags & MAGIC_STATE_TEXT) != 0)
|
|
#define MAGIC_SEL_ANALYZED_PTR_HAS_TRG_SENTRY(E) \
|
|
((E)->u.ptr.trg_flags && !MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E))
|
|
#define MAGIC_SEL_ANALYZED_PTR_SENTRY(E) \
|
|
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
|
|
? (E)->u.ptr.trg_p.dsentry->sentry \
|
|
: (E)->u.ptr.trg.dsentry.sentry
|
|
#define MAGIC_SEL_ANALYZED_PTR_SENTRY_ADDRESS(E) \
|
|
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
|
|
? &((E)->u.ptr.trg_p.dsentry->sentry) \
|
|
: &((E)->u.ptr.trg.dsentry.sentry)
|
|
#define MAGIC_SEL_ANALYZED_PTR_FUNCTION(E) \
|
|
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
|
|
? (E)->u.ptr.trg_p.dfunction->function \
|
|
: (E)->u.ptr.trg.dfunction.function
|
|
#define MAGIC_SEL_ANALYZED_PTR_TRG_NAME(E) \
|
|
(MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) ? "" \
|
|
: MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
|
|
? (MAGIC_SEL_ANALYZED_PTR_FUNCTION(E)).name \
|
|
: (MAGIC_SEL_ANALYZED_PTR_HAS_TRG_SENTRY(E) \
|
|
? (MAGIC_SEL_ANALYZED_PTR_SENTRY(E)).name : "?"))
|
|
#define MAGIC_SEL_ANALYZED_PTR_TRG_ADDRESS(E) \
|
|
(MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) ? NULL \
|
|
: MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
|
|
? (MAGIC_SEL_ANALYZED_PTR_FUNCTION(E)).address \
|
|
: (MAGIC_SEL_ANALYZED_PTR_SENTRY(E)).address)
|
|
#define MAGIC_SEL_ANALYZED_PTR_PRINT_TRG_ABS_NAME(E) \
|
|
do { \
|
|
if (MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) \
|
|
|| MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E)) { \
|
|
_magic_printf(MAGIC_SEL_ANALYZED_PTR_TRG_NAME(E)); \
|
|
} else { \
|
|
magic_print_sentry_abs_name( \
|
|
MAGIC_SEL_ANALYZED_PTR_SENTRY_ADDRESS(E)); \
|
|
} \
|
|
} while(0)
|
|
#define MAGIC_SEL_ANALYZED_PTR_FIRST_TRG_TYPE(E) \
|
|
((E)->u.ptr.trg_selements[0].type)
|
|
#define MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) \
|
|
(MAGIC_TYPE_IS_SPECIAL(MAGIC_SEL_ANALYZED_PTR_FIRST_TRG_TYPE(E)))
|
|
#define MAGIC_SEL_ANALYZED_PTR_SET_SPECIAL_TRG_TYPE(E,T) \
|
|
do { \
|
|
(E)->u.ptr.trg_selements[0].type = T; \
|
|
(E)->u.ptr.num_trg_types = 1; \
|
|
(E)->u.ptr.num_legal_trg_types = 0; \
|
|
(E)->u.ptr.first_legal_trg_type = -1; \
|
|
} while(0)
|
|
#define MAGIC_SEL_ANALYZED_TRG_FLAGS(E) \
|
|
((E)->type_id == MAGIC_TYPE_POINTER ? (E)->u.ptr.trg_flags \
|
|
: (E)->u.nonptr.trg_flags)
|
|
#define MAGIC_SEL_ANALYZED_FLAG(E,F) (((E)->flags & F) != 0)
|
|
#define MAGIC_SEL_ANALYZED_TRG_STATS_HAS_VIOLATIONS(E) \
|
|
((E) == _other_types_found || (E) == _badentry_found)
|
|
#define MAGIC_SEL_ANALYZED_TRG_STATS_C(E) \
|
|
((E) == _ptr_type_found ? 'p' : (E) == _other_types_found ? 'o' \
|
|
: (E) == _void_type_found ? 'v' : (E) == _comp_trg_types_found ? 'c' \
|
|
: (E) == _badentry_found ? 'b' : '?')
|
|
|
|
#define MAGIC_SEL_ANALYZED_PRINT(E, FLAGS) do { \
|
|
_magic_printf("SEL_ANALYZED: (num=%d, type=%s, flags(DIVW)=%d%d%d%d", \
|
|
(E)->num, (E)->type_id == MAGIC_TYPE_POINTER ? "ptr" : "nonptr", \
|
|
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_DATA), \
|
|
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_INVARIANTS), \
|
|
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_VIOLATIONS), \
|
|
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_WALKABLE)); \
|
|
if((E)->type_id == MAGIC_TYPE_POINTER) { \
|
|
_magic_printf(", value=0x%08x, trg_name=", (E)->u.ptr.value); \
|
|
MAGIC_SEL_ANALYZED_PTR_PRINT_TRG_ABS_NAME(E); \
|
|
_magic_printf(", trg_offset=%d, trg_flags(RL)=%c%c", \
|
|
(E)->u.ptr.trg_offset, \
|
|
(E)->u.ptr.trg_flags \
|
|
? MAGIC_STATE_FLAGS_REGION_C((E)->u.ptr.trg_flags) : 0, \
|
|
(E)->u.ptr.trg_flags \
|
|
? MAGIC_STATE_FLAGS_LIBSPEC_C((E)->u.ptr.trg_flags) : 0); \
|
|
if((E)->u.ptr.num_trg_types > 0) { \
|
|
_magic_printf(", trg_selements=("); \
|
|
magic_sel_analyzed_trg_selements_print(E, FLAGS); \
|
|
_magic_printf(")"); \
|
|
} \
|
|
} else { \
|
|
_magic_printf(", value=%d/0x%08x", \
|
|
(E)->u.nonptr.value, (E)->u.nonptr.value); \
|
|
if((E)->u.nonptr.trg_flags) { \
|
|
_magic_printf(", trg_flags(RL)=%c%c", \
|
|
MAGIC_STATE_FLAGS_REGION_C((E)->u.nonptr.trg_flags), \
|
|
MAGIC_STATE_FLAGS_LIBSPEC_C((E)->u.nonptr.trg_flags)); \
|
|
} \
|
|
} \
|
|
_magic_printf(")"); \
|
|
} while(0)
|
|
|
|
/* Magic state element stats. */
|
|
struct _magic_sel_stats_s {
|
|
unsigned ptr_found;
|
|
unsigned nonptr_found;
|
|
unsigned nonptr_unconstrained_found;
|
|
int trg_flags;
|
|
int ptr_type_found;
|
|
int other_types_found;
|
|
int null_type_found;
|
|
int badoffset_found;
|
|
int unknown_found;
|
|
int void_type_found;
|
|
int comp_trg_types_found;
|
|
int value_found;
|
|
int badvalue_found;
|
|
int badentry_found;
|
|
};
|
|
typedef struct _magic_sel_stats_s _magic_sel_stats_t;
|
|
|
|
/* Magic state element stats. */
|
|
#define MAGIC_SEL_STAT_INCR(S,I,F) ((S)->F += (I)->F)
|
|
#define MAGIC_SEL_STATS_INCR(S,I) do { \
|
|
MAGIC_SEL_STAT_INCR(S,I, ptr_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, nonptr_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, nonptr_unconstrained_found); \
|
|
S->trg_flags |= I->trg_flags; \
|
|
MAGIC_SEL_STAT_INCR(S,I, ptr_type_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, other_types_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, null_type_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, badoffset_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, unknown_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, void_type_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, comp_trg_types_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, value_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, badvalue_found); \
|
|
MAGIC_SEL_STAT_INCR(S,I, badentry_found); \
|
|
} while(0)
|
|
|
|
#define MAGIC_SEL_STATS_HAS_VIOLATIONS(S) \
|
|
(MAGIC_SEL_STATS_NUM_VIOLATIONS(S) > 0)
|
|
#define MAGIC_SEL_STATS_NUM_VIOLATIONS(S) \
|
|
((S)->ptr_found ? MAGIC_SEL_PTR_STATS_NUM_VIOLATIONS(S) \
|
|
: MAGIC_SEL_NONPTR_STATS_NUM_VIOLATIONS(S))
|
|
#define MAGIC_SEL_PTR_STATS_NUM_VIOLATIONS(S) ((S)->other_types_found \
|
|
+ (S)->badoffset_found + (S)->unknown_found + (S)->badvalue_found \
|
|
+ (S)->badentry_found)
|
|
#define MAGIC_SEL_NONPTR_STATS_NUM_VIOLATIONS(S) ((S)->badvalue_found)
|
|
|
|
#define MAGIC_SEL_STATS_PRINT(E) do { \
|
|
_magic_printf("SEL_STATS: (type=%s", \
|
|
(E)->ptr_found ? "ptr" : "nonptr"); \
|
|
if((E)->trg_flags) { \
|
|
_magic_printf(", trg_flags(RL)=%c%c", \
|
|
MAGIC_STATE_FLAGS_REGION_C((E)->trg_flags), \
|
|
MAGIC_STATE_FLAGS_LIBSPEC_C((E)->trg_flags)); \
|
|
} \
|
|
if((E)->ptr_found) _magic_printf(", ptr_found=%d", (E)->ptr_found); \
|
|
if((E)->nonptr_found) \
|
|
_magic_printf(", nonptr_found=%d", (E)->nonptr_found); \
|
|
if((E)->nonptr_unconstrained_found) \
|
|
_magic_printf(", nonptr_unconstrained_found=%d", \
|
|
(E)->nonptr_unconstrained_found); \
|
|
if((E)->ptr_type_found) \
|
|
_magic_printf(", ptr_type_found=%d", (E)->ptr_type_found); \
|
|
if((E)->other_types_found) \
|
|
_magic_printf(", other_types_found=%d", (E)->other_types_found); \
|
|
if((E)->null_type_found) \
|
|
_magic_printf(", null_type_found=%d", (E)->null_type_found); \
|
|
if((E)->badoffset_found) \
|
|
_magic_printf(", badoffset_found=%d", (E)->badoffset_found); \
|
|
if((E)->unknown_found) \
|
|
_magic_printf(", unknown_found=%d", (E)->unknown_found); \
|
|
if((E)->void_type_found) \
|
|
_magic_printf(", void_type_found=%d", (E)->void_type_found); \
|
|
if((E)->comp_trg_types_found) \
|
|
_magic_printf(", comp_trg_types_found=%d", \
|
|
(E)->comp_trg_types_found); \
|
|
if((E)->value_found) \
|
|
_magic_printf(", value_found=%d", (E)->value_found); \
|
|
if((E)->badvalue_found) \
|
|
_magic_printf(", badvalue_found=%d", (E)->badvalue_found); \
|
|
if((E)->badentry_found) \
|
|
_magic_printf(", badentry_found=%d", (E)->badentry_found); \
|
|
_magic_printf(", violations=%d", MAGIC_SEL_STATS_NUM_VIOLATIONS(E)); \
|
|
_magic_printf(")"); \
|
|
} while(0)
|
|
|
|
/* Magic sentry macros. */
|
|
#define MAGIC_SENTRY_ANALYZE_STOP 1
|
|
#define MAGIC_SENTRY_ANALYZE_CONTINUE 2
|
|
#define MAGIC_SENTRY_ANALYZE_SKIP_PATH 3
|
|
#define MAGIC_SENTRY_ANALYZE_IS_VALID_RET(R) \
|
|
((R)>=MAGIC_SENTRY_ANALYZE_STOP && (R)<=MAGIC_SENTRY_ANALYZE_SKIP_PATH)
|
|
|
|
#ifndef __MINIX
|
|
#define MAGIC_PTR_LIKELY_INTS_START 0xFFFFF000
|
|
#else
|
|
#define MAGIC_PTR_LIKELY_INTS_START 0xE0000000
|
|
#endif
|
|
#define MAGIC_PTR_LIKELY_INTS_END 0xFFF
|
|
#define MAGIC_PTR_IS_LIKELY_INT(V) \
|
|
((V) && ((unsigned)(V)>=MAGIC_PTR_LIKELY_INTS_START \
|
|
|| (unsigned)(V)<=MAGIC_PTR_LIKELY_INTS_END))
|
|
#define MAGIC_INT_IS_LIKELY_PTR(V) \
|
|
((V) && !MAGIC_PTR_IS_LIKELY_INT((void*)V))
|
|
|
|
/* Magic callbacks. */
|
|
typedef int (*magic_cb_sentries_analyze_pre_t)();
|
|
PUBLIC void magic_setcb_sentries_analyze_pre(magic_cb_sentries_analyze_pre_t cb);
|
|
|
|
/* Magic state entry functions. */
|
|
typedef int (*magic_sentry_analyze_cb_t)(_magic_selement_t* selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
|
|
void* cb_args);
|
|
PUBLIC int magic_sentry_print_ptr_types(struct _magic_sentry* entry);
|
|
PUBLIC int magic_sentry_extract_ptrs(struct _magic_sentry* entry,
|
|
void ****ptr_map, const struct _magic_type ***ptr_type_map, int *ptr_num);
|
|
PUBLIC int magic_sentry_analyze(struct _magic_sentry* sentry, int flags,
|
|
const magic_sentry_analyze_cb_t cb, void* cb_args,
|
|
_magic_sel_stats_t *sentry_stats);
|
|
PUBLIC int magic_sentries_analyze(int flags, const magic_sentry_analyze_cb_t cb,
|
|
void* cb_args, _magic_sel_stats_t *sentries_stats);
|
|
PUBLIC int magic_sentry_print_selements(struct _magic_sentry* sentry);
|
|
PUBLIC int magic_sentry_print_ptr_selements(struct _magic_sentry* sentry,
|
|
int skip_null_ptrs, int max_target_recusions);
|
|
|
|
/* Magic dynamic state entry functions. */
|
|
PUBLIC int magic_dsentries_analyze(int flags,
|
|
const magic_sentry_analyze_cb_t cb, void* cb_args,
|
|
_magic_sel_stats_t *dsentries_stats);
|
|
|
|
/* Magic sentry analyze callbacks. */
|
|
PUBLIC int magic_sentry_print_el_cb(_magic_selement_t* selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
|
|
void* cb_args);
|
|
PUBLIC int magic_sentry_print_ptr_el_cb(_magic_selement_t* selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
|
|
void* cb_args);
|
|
PUBLIC int magic_sentry_print_el_with_trg_reg_cb(_magic_selement_t* selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
|
|
void* cb_args);
|
|
PUBLIC int magic_sentry_print_el_with_trg_cb(_magic_selement_t* selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
|
|
void* cb_args);
|
|
|
|
/* Magic sentry analyze helpers. */
|
|
#define magic_sentry_analyze_invariants(sentry, cb, cb_args, sentry_stats) \
|
|
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
|
|
cb_args, sentry_stats)
|
|
#define magic_sentries_analyze_invariants(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
|
|
cb_args, sentries_stats)
|
|
#define magic_dsentries_analyze_invariants(cb, cb_args, dsentries_stats) \
|
|
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
|
|
cb_args, dsentries_stats)
|
|
#define magic_allsentries_analyze_invariants(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS \
|
|
| MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, sentries_stats)
|
|
|
|
#define magic_sentry_analyze_violations(sentry, cb, cb_args, sentry_stats) \
|
|
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
|
|
cb_args, sentry_stats)
|
|
#define magic_sentries_analyze_violations(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
|
|
cb_args, sentries_stats)
|
|
#define magic_dsentries_analyze_violations(cb, cb_args, dsentries_stats) \
|
|
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
|
|
cb_args, dsentries_stats)
|
|
#define magic_allsentries_analyze_violations(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
|
|
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS \
|
|
| MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, sentries_stats)
|
|
|
|
#define magic_sentry_analyze_likely_pointers(sentry, cb, cb_args, sentry_stats)\
|
|
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
|
|
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, sentry_stats)
|
|
#define magic_sentries_analyze_likely_pointers(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
|
|
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, sentries_stats)
|
|
#define magic_dsentries_analyze_likely_pointers(cb, cb_args, dsentries_stats) \
|
|
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
|
|
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, dsentries_stats)
|
|
#define magic_allsentries_analyze_likely_pointers(cb, cb_args, sentries_stats) \
|
|
magic_sentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
|
|
| MAGIC_SEL_ANALYZE_DATA | MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, \
|
|
sentries_stats)
|
|
|
|
/* Magic state type functions. */
|
|
PUBLIC int magic_type_count_ptrs(const struct _magic_type* type, int *ptr_num);
|
|
|
|
/* Magic type walk callbacks. */
|
|
PUBLIC int magic_type_examine_ptr_cb(const struct _magic_type* parent_type,
|
|
const unsigned parent_offset, int child_num, const struct _magic_type* type,
|
|
const unsigned offset, int depth, void* cb_args);
|
|
PUBLIC int magic_type_extract_ptr_cb(const struct _magic_type* parent_type,
|
|
const unsigned parent_offset, int child_num, const struct _magic_type* type,
|
|
const unsigned offset, int depth, void* cb_args);
|
|
PUBLIC int magic_type_analyzer_cb(const struct _magic_type* parent_type,
|
|
const unsigned parent_offset, int child_num, const struct _magic_type* type,
|
|
const unsigned offset, int depth, void* cb_args);
|
|
|
|
/* Magic state element functions. */
|
|
PUBLIC int magic_selement_analyze(_magic_selement_t *selement, int flags,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC int magic_selement_analyze_ptr(_magic_selement_t *selement, int flags,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC int magic_selement_analyze_nonptr(_magic_selement_t *selement, int flags,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC int magic_selement_analyze_ptr_value_invs(_magic_selement_t *selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC int magic_selement_analyze_ptr_trg_invs(_magic_selement_t *selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC _magic_trg_stats_t
|
|
magic_selement_analyze_ptr_target(const struct _magic_type *ptr_type,
|
|
const struct _magic_type *trg_type, int trg_flags);
|
|
PUBLIC int magic_selement_analyze_ptr_type_invs(_magic_selement_t *selement,
|
|
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
|
|
PUBLIC int magic_selement_recurse_ptr(_magic_selement_t *selement,
|
|
_magic_selement_t *new_selement, int max_steps);
|
|
PUBLIC void
|
|
magic_sel_analyzed_trg_selements_print(_magic_sel_analyzed_t *sel_analyzed,
|
|
int flags);
|
|
PUBLIC _magic_selement_t*
|
|
magic_selement_type_cast(_magic_selement_t *selement, int flags,
|
|
const struct _magic_type* type, _magic_sel_analyzed_t *sel_analyzed,
|
|
_magic_sel_stats_t *sel_stats);
|
|
|
|
#endif /* _MAGIC_ANALYSIS_H */
|
|
|