windows_message.c File Reference

#include <rz_windows.h>
#include "windows_message.h"

Go to the source code of this file.

Classes
struct	_window

Typedefs
typedef struct _window	window

Functions
void	free_window (void *ptr)
static window *	window_from_handle (HANDLE hwnd)
static RzTable *	create_window_table (void)
static void	add_window_to_table (RzTable *tbl, window *win)
RZ_API void	rz_w32_identify_window (void)
static BOOL CALLBACK	enum_childs (_In_ HWND hwnd, _In_ LPARAM lParam)
static RzList *	get_windows (RzDebug *dbg)
static ut64	get_dispatchmessage_offset (RzDebug *dbg)
static void	init_msg_types (Sdb **msg_types)
static DWORD	get_msg_type (char *name)
static void	print_windows (RzDebug *dbg, RzList *windows)
RZ_API void	rz_w32_print_windows (RzDebug *dbg)
RZ_API bool	rz_w32_add_winmsg_breakpoint (RzDebug *dbg, const char *msg_name, const char *window_id)

Variables
static char *	msg_types_arr []

Typedef Documentation

window

typedef struct _window window

Function Documentation

add_window_to_table()

static void add_window_to_table ( RzTable *  tbl, window *  win  )

static

Definition at line 301 of file windows_message.c.

                                                           {
    rz_return_if_fail(tbl && win);
    char *handle = rz_str_newf("0x%08" PFMT64x "", (ut64)win->h);
    char *pid = rz_str_newf("%lu", win->pid);
    char *tid = rz_str_newf("%lu", win->tid);
    rz_table_add_row(tbl, handle, pid, tid, win->name, NULL);
    free(handle);
    free(tid);
    free(pid);
}

References free(), handle, NULL, PFMT64x, pid, rz_return_if_fail, rz_str_newf(), rz_table_add_row(), and ut64().

Referenced by print_windows(), and rz_w32_identify_window().

create_window_table()

static RzTable* create_window_table ( void  )

static

Definition at line 289 of file windows_message.c.

                                          {
    RzTable *tbl = rz_table_new();
    if (!tbl) {
        return NULL;
    }
    rz_table_add_column(tbl, rz_table_type("number"), "Handle", ST32_MAX);
    rz_table_add_column(tbl, rz_table_type("number"), "PID", ST32_MAX);
    rz_table_add_column(tbl, rz_table_type("number"), "TID", ST32_MAX);
    rz_table_add_column(tbl, rz_table_type("string"), "Class Name", ST32_MAX);
    return tbl;
}

References NULL, rz_table_add_column(), rz_table_new(), rz_table_type(), and ST32_MAX.

Referenced by print_windows(), and rz_w32_identify_window().

enum_childs()

static BOOL CALLBACK enum_childs ( _In_ HWND  hwnd, _In_ LPARAM  lParam  )

static

Definition at line 346 of file windows_message.c.

                        {
    RzList *windows = (RzList *)lParam;
    window *win = window_from_handle(hwnd);
    if (!win) {
        return false;
    }
    rz_list_push(windows, win);
    return true;
}

References rz_list_push(), and window_from_handle().

Referenced by get_windows().

free_window()

void free_window

(

void *

ptr

)

Definition at line 259 of file windows_message.c.

                            {
    window *win = ptr;
    free(win->name);
    free(win);
}

References free().

Referenced by get_windows().

get_dispatchmessage_offset()

static ut64 get_dispatchmessage_offset ( RzDebug *  dbg )

static

Definition at line 378 of file windows_message.c.

                                                     {
    RzList *modlist = rz_debug_modules_list(dbg);
    RzListIter *it;
    RzDebugMap *mod;
    bool found = false;
    rz_list_foreach (modlist, it, mod) {
        if (!strnicmp(mod->name, "user32.dll", sizeof("user32.dll"))) {
            found = true;
            break;
        }
    }
    if (!found) {
        return 0;
    }
    char *res = dbg->corebind.cmdstr(dbg->corebind.core, "f~DispatchMessageW");
    if (!*res) {
        free(res);
        return 0;
    }
    char *line = strtok(res, "\n");
    ut64 offset = 0;
    do {
        char *sym = strrchr(line, ' ');
        if (sym && rz_str_startswith(sym + 1, "sym.imp")) {
            offset = rz_num_math(NULL, line);
            dbg->iob.read_at(dbg->iob.io, offset, (ut8 *)&offset, sizeof(offset));
            break;
        }
    } while ((line = strtok(NULL, "\n")));
    free(res);
    return offset;
}

References rz_core_bind_t::cmdstr, rz_core_bind_t::core, rz_debug_t::corebind, dbg, found, free(), rz_io_bind_t::io, rz_debug_t::iob, setup::line, mod(), NULL, rz_io_bind_t::read_at, rz_debug_modules_list(), rz_num_math(), rz_str_startswith(), and ut64().

Referenced by rz_w32_add_winmsg_breakpoint().

get_msg_type()

static DWORD get_msg_type ( char *  name )

static

Definition at line 420 of file windows_message.c.

                                      {
    static Sdb *msg_types = NULL;
    if (!msg_types) {
        init_msg_types(&msg_types);
    }
    ut32 found;
    const char *type_str = sdb_const_get(msg_types, name, &found);
    if (found) {
        int type = rz_num_get(NULL, type_str);
        return type;
    }
    return 0;
}

References found, init_msg_types(), NULL, rz_num_get(), sdb_const_get(), and type.

Referenced by rz_w32_add_winmsg_breakpoint().

get_windows()

static RzList* get_windows ( RzDebug *  dbg )

static

Definition at line 358 of file windows_message.c.

                                         {
    RzList *windows = rz_list_newf((RzListFree)free_window);
    HWND hCurWnd = NULL;
    do {
        hCurWnd = FindWindowEx(NULL, hCurWnd, NULL, NULL);
        DWORD dwProcessID = 0;
        GetWindowThreadProcessId(hCurWnd, &dwProcessID);
        if (dbg->pid == dwProcessID) {
            EnumChildWindows(hCurWnd, enum_childs, (LPARAM)windows);
            window *win = window_from_handle(hCurWnd);
            if (!win) {
                rz_list_free(windows);
                return NULL;
            }
            rz_list_push(windows, win);
        }
    } while (hCurWnd != NULL);
    return windows;
}

References dbg, DWORD, enum_childs(), free_window(), NULL, rz_debug_t::pid, rz_list_free(), rz_list_newf(), rz_list_push(), and window_from_handle().

Referenced by rz_w32_add_winmsg_breakpoint(), and rz_w32_print_windows().

init_msg_types()

static void init_msg_types ( Sdb **  msg_types )

static

Definition at line 411 of file windows_message.c.

                                            {
    *msg_types = sdb_new0();
    int i;
    char *cur_type;
    for (i = 0; (cur_type = msg_types_arr[i]); i++) {
        sdb_query(*msg_types, cur_type);
    }
}

References i, msg_types_arr, sdb_new0(), and sdb_query().

Referenced by get_msg_type().

print_windows()

static void print_windows ( RzDebug *  dbg, RzList *  windows  )

static

Definition at line 434 of file windows_message.c.

                                                         {
    RzTable *tbl = create_window_table();
    if (!tbl) {
        return;
    }
    RzListIter *it;
    window *win;
    rz_list_foreach (windows, it, win) {
        add_window_to_table(tbl, win);
    }
    char *t = rz_table_tostring(tbl);
    dbg->cb_printf(t);
    free(t);
    rz_table_free(tbl);
}

References add_window_to_table(), rz_debug_t::cb_printf, create_window_table(), dbg, free(), rz_table_free(), and rz_table_tostring().

Referenced by rz_w32_add_winmsg_breakpoint(), and rz_w32_print_windows().

rz_w32_add_winmsg_breakpoint()

RZ_API bool rz_w32_add_winmsg_breakpoint	(	RzDebug *	dbg,
		const char *	msg_name,
		const char *	window_id
	)

Definition at line 462 of file windows_message.c.

                                                                                                    {
    rz_return_val_if_fail(dbg && msg_name, false);
    char *name = strdup(msg_name);
    rz_str_trim(name);
 
    DWORD type = get_msg_type(name);
    if (!type) {
        free(name);
        return false;
    }
    ut64 offset = 0;
    if (window_id) {
        RzList *windows = get_windows(dbg);
        if (windows && !windows->length) {
            dbg->cb_printf("No windows for this process.\n");
        }
        ut64 win_h = rz_num_math(NULL, window_id);
        RzListIter *it;
        window *win;
        rz_list_foreach (windows, it, win) {
            if ((ut64)win->h == win_h || !strnicmp(win->name, window_id, strlen(window_id))) {
                offset = win->proc;
                break;
            }
        }
        if (!offset) {
            dbg->cb_printf("Window not found, try these:\n");
            print_windows(dbg, windows);
        }
        rz_list_free(windows);
    } else {
        offset = get_dispatchmessage_offset(dbg);
    }
    if (!offset) {
        free(name);
        return false;
    }
    RzBreakpointItem *b = rz_debug_bp_add(dbg, offset, 0, 0, 0, NULL, 0);
    if (!b) {
        free(name);
        return false;
    }
    char *cond;
    if (window_id) {
        char *reg;
        if (!strcmp(dbg->arch, "arm")) {
            if (dbg->bits == RZ_SYS_BITS_64) {
                reg = "x1";
            } else {
                reg = "r1";
            }
        } else {
            reg = "edx";
        }
        b->cond = rz_str_newf("?q `ae %s,%d,-`", reg, type);
    } else {
        char *reg;
        if (!strcmp(dbg->arch, "arm")) {
            if (dbg->bits == RZ_SYS_BITS_64) {
                reg = "x0";
            } else {
                reg = "r0";
            }
        } else {
            if (dbg->bits == RZ_SYS_BITS_64) {
                reg = "rcx";
            } else {
                reg = "ecx";
            }
        }
        b->cond = rz_str_newf("?q `ae %lu,%s,%d,+,[4],-`", type, reg, dbg->bits);
    }
    free(name);
    return true;
}

References rz_debug_t::arch, b, rz_debug_t::bits, rz_debug_t::cb_printf, cond, dbg, DWORD, free(), get_dispatchmessage_offset(), get_msg_type(), get_windows(), rz_list_t::length, NULL, print_windows(), reg, rz_debug_bp_add(), rz_list_free(), rz_num_math(), rz_return_val_if_fail, rz_str_newf(), rz_str_trim(), RZ_SYS_BITS_64, strdup(), type, and ut64().

Referenced by rz_cmd_debug_set_cond_bp_win_handler().

rz_w32_identify_window()

RZ_API void rz_w32_identify_window

(

void

)

Definition at line 312 of file windows_message.c.

                                         {
    while (!rz_cons_yesno('y', "Move cursor to the window to be identified. Ready? (Y/n)"))
        ;
    POINT p;
    if (!GetCursorPos(&p)) {
        rz_sys_perror("GetCursorPos");
    }
    HWND hwnd = WindowFromPoint(p);
    window *win = NULL;
    if (hwnd) {
        if (rz_cons_yesno('y', "Try to get the child? (Y/n)")) {
            HWND child = ChildWindowFromPoint(hwnd, p);
            hwnd = child ? child : hwnd;
        }
        win = window_from_handle(hwnd);
    } else {
        eprintf("No window found\n");
        return;
    }
    if (!win) {
        eprintf("Error trying to get information from 0x%08" PFMT64x "\n", (ut64)hwnd);
        return;
    }
    RzTable *tbl = create_window_table();
    if (!tbl) {
        return;
    }
    add_window_to_table(tbl, win);
    char *tbl_str = rz_table_tofancystring(tbl);
    rz_cons_print(tbl_str);
    free(tbl_str);
    rz_table_free(tbl);
}

References add_window_to_table(), create_window_table(), eprintf, free(), NULL, p, PFMT64x, rz_cons_yesno(), rz_sys_perror, rz_table_free(), rz_table_tofancystring(), ut64(), and window_from_handle().

Referenced by rz_cmd_debug().

rz_w32_print_windows()

RZ_API void rz_w32_print_windows

(

RzDebug *

dbg

)

Definition at line 450 of file windows_message.c.

                                               {
    RzList *windows = get_windows(dbg);
    if (windows) {
        if (!windows->length) {
            dbg->cb_printf("No windows for this process.\n");
            return;
        }
        print_windows(dbg, windows);
    }
    rz_list_free(windows);
}

References rz_debug_t::cb_printf, dbg, get_windows(), rz_list_t::length, print_windows(), and rz_list_free().

Referenced by rz_cmd_debug().

window_from_handle()

static window* window_from_handle ( HANDLE  hwnd )

static

Definition at line 265 of file windows_message.c.

                                               {
    rz_return_val_if_fail(hwnd, NULL);
    window *win = RZ_NEW0(window);
    if (!win) {
        return NULL;
    }
    win->h = hwnd;
    win->tid = GetWindowThreadProcessId(hwnd, &win->pid);
    win->proc = GetClassLongPtrW(hwnd, GCLP_WNDPROC);
    const size_t sz = MAX_CLASS_NAME * sizeof(WCHAR);
    wchar_t *tmp = malloc(sz);
    if (!tmp) {
        free(win);
        return NULL;
    }
    GetClassNameW(hwnd, tmp, MAX_CLASS_NAME);
    win->name = rz_utf16_to_utf8(tmp);
    free(tmp);
    if (!win->name) {
        win->name = strdup("");
    }
    return win;
}

References free(), malloc(), NULL, RZ_NEW0, rz_return_val_if_fail, strdup(), and autogen_x86imm::tmp.

Referenced by enum_childs(), get_windows(), and rz_w32_identify_window().

Variable Documentation

msg_types_arr

char* msg_types_arr[]

static

Definition at line 7 of file windows_message.c.

Referenced by init_msg_types().