static void wrap_alloc_post(void *wrapctx, void *user_data)
{
void *ptr = drwrap_get_retval(wrapctx);
if (!ptr)
return;
size_t size = (size_t)user_data;
allocated(ptr, size);
logging_paused--;
}
void post_calloc(void *wrapctx, void *user_data)
{
malloc_t *block = (malloc_t *)user_data;
dr_mutex_lock(lock);
if (block)
set_addr_malloc(block, drwrap_get_retval(wrapctx), ALLOC, 0);
dr_mutex_unlock(lock);
}
static void
wrap_post(void *wrapcxt, void *user_data)
{
bool ok;
CHECK(wrapcxt != NULL, "invalid arg");
if (drwrap_get_func(wrapcxt) == addr_level0) {
dr_fprintf(STDERR, " <post-level0>\n");
/* not preserved for no-frills */
CHECK(load_count == 2 || user_data == (void *)99, "user_data not preserved");
CHECK(drwrap_get_retval(wrapcxt) == (void *) 42, "get_retval error");
} else if (drwrap_get_func(wrapcxt) == addr_level1) {
dr_fprintf(STDERR, " <post-level1>\n");
ok = drwrap_set_retval(wrapcxt, (void *) -4);
CHECK(ok, "set_retval error");
} else if (drwrap_get_func(wrapcxt) == addr_tailcall) {
dr_fprintf(STDERR, " <post-makes_tailcall>\n");
} else if (drwrap_get_func(wrapcxt) == addr_level2) {
dr_fprintf(STDERR, " <post-level2>\n");
} else if (drwrap_get_func(wrapcxt) == addr_skipme) {
CHECK(false, "should have skipped!");
} else if (drwrap_get_func(wrapcxt) == addr_repeat) {
dr_fprintf(STDERR, " <post-repeat#%d>\n", repeated ? 2 : 1);
if (!repeated) {
dr_mcontext_t *mc = drwrap_get_mcontext(wrapcxt);
mc->pc = addr_repeat;
mc->xsp = repeat_xsp;
#ifdef ARM
mc->lr = repeat_link;
#endif
CHECK(drwrap_redirect_execution(wrapcxt) == DREXT_SUCCESS,
"redirect rejected");
CHECK(drwrap_redirect_execution(wrapcxt) != DREXT_SUCCESS,
"allowed duplicate redirect");
}
repeated = !repeated;
} else if (drwrap_get_func(wrapcxt) == addr_postonly) {
dr_fprintf(STDERR, " <post-postonly>\n");
drwrap_unwrap(addr_skipme, wrap_pre, wrap_post);
CHECK(!drwrap_is_wrapped(addr_skipme, wrap_pre, wrap_post),
"drwrap_is_wrapped query failed");
drwrap_unwrap(addr_postonly, NULL, wrap_post);
CHECK(!drwrap_is_wrapped(addr_postonly, NULL, wrap_post),
"drwrap_is_wrapped query failed");
drwrap_unwrap(addr_runlots, NULL, wrap_post);
CHECK(!drwrap_is_wrapped(addr_runlots, NULL, wrap_post),
"drwrap_is_wrapped query failed");
} else if (drwrap_get_func(wrapcxt) == addr_runlots) {
dr_fprintf(STDERR, " <post-runlots>\n");
} else
CHECK(false, "invalid wrap");
}
void post_realloc(void *wrapctx, void *user_data)
{
malloc_t *block;
void *ret = drwrap_get_retval(wrapctx);
void *drc = drwrap_get_drcontext(wrapctx);;
realloc_tmp_t *data = user_data;
// if user_data is not set realloc was called to do a free
// or the call to realloc is an init call or the block
// was alloc by a non wrap module
if (data)
{
dr_mutex_lock(lock);
if (data->block)
{
block = data->block;
set_addr_malloc(block, ret, block->flag, 1);
// we dont set the alloc arg in get_caller_data
// because the post wrap happen after the return
get_caller_data(&(block->alloc_func_pc), &(block->alloc_func_sym),
&(block->alloc_module_name), drc, 0);
block->alloc_pc = get_prev_instr_pc(drwrap_get_retaddr(wrapctx),
drc);
}
// if realloc is use like a malloc set, we the size here
// because malloc wrapper receive a null size
else if ((block = search_on_tree(active_blocks, ret)))
{
block->size = data->size;
block->end = block->start + block->size;
}
dr_global_free(user_data, sizeof(realloc_tmp_t));
dr_mutex_unlock(lock);
}
}
static void
wrap_post_SSL_read(void *wrapcxt, void *user_data)
{
struct SSL_read_data *sd = (struct SSL_read_data *)user_data;
int actual_read = (int)(ptr_int_t)drwrap_get_retval(wrapcxt);
char filename[MAXIMUM_PATH] = { 0 };
dr_snprintf(filename, BUFFER_SIZE_ELEMENTS(filename), "trace-%x.read", sd->ssl);
NULL_TERMINATE_BUFFER(filename);
FILE *fp = fopen(filename, "ab+");
if (!fp) {
dr_fprintf(STDERR, "Couldn’t open the output file %s\n", filename);
dr_global_free(user_data, sizeof(struct SSL_read_data));
return;
}
if (actual_read > 0) {
fwrite(sd->read_buffer, 1, actual_read, fp);
}
fclose(fp);
dr_global_free(user_data, sizeof(struct SSL_read_data));
}
