{

RUN_ON_DB_OPEN = 0, // run script after opening database (default)

RUN_ON_UI_READY = 1, // run script when UI is ready

RUN_ON_INIT = 2, // run script immediately on plugin load (shortly after IDA starts)

{

PyObject *str;

/* Catch line change events. */

/* Print the filename and line number */

if ( what == PyTrace_LINE )

{

str = PyObject_Str(frame->f_code->co_filename);

if ( str )

{

msg("PROFILING: %s:%d\n", PyString_AsString(str), frame->f_lineno);

Py_DECREF(str);

}

}

return 0;

{

time_t etime;

exec_entry_t() { etime = time(NULL); }

{

exec_entries_t entries;

int timeout;

uint32 steps_before_action;

bool waitdialog_shown;

bool interruptible_state;

execution_t()

: timeout(2),

steps_before_action(0),

waitdialog_shown(false),

interruptible_state(true)

{

reset_steps();

}

void reset_steps();

void push();

void pop();

bool can_interrupt_current(time_t now) const;

void stop_tracking();

void sync_to_present_time();

void maybe_hide_waitdialog();

void set_interruptible(bool intr) { interruptible_state = intr; }

static int on_trace(PyObject *obj, _frame *frame, int what, PyObject *arg);

{

// we want to trace/check the time about every 10 steps. But we don't

// want it to be exactly 10 steps, or we might never make important

// checks because the tracing happens always at the wrong point.

// E.g., imagine the following loop:

// ---

// while True:

// gen_disasm_text(dtext, ea, ea + 4, False)

// ---

// If we never hit the 'trace' callback while in the 'while True' loop

// but always when performing the call to the processor module's 'out/outop'

// then the loop will never stop. That was happening on windows (optimized.)

steps_before_action = 1 + rand() % 20;

{

if ( entries.empty() )

PyEval_SetTrace(execution_t::on_trace, NULL);

entries.push_back();

LEXEC("push() (now: %d entries)\n", int(entries.size()));

{

entries.pop_back();

if ( entries.empty() )

stop_tracking();

LEXEC("pop() (now: %d entries)\n", int(entries.size()));

{

PyEval_SetTrace(NULL, NULL);

maybe_hide_waitdialog();

{

time_t now = time(NULL);

for ( size_t i = 0, n = entries.size(); i < n; ++i )

entries[i].etime = now;

maybe_hide_waitdialog();

{

if ( waitdialog_shown )

{

hide_wait_box();

waitdialog_shown = false;

}

{

LEXEC("can_interrupt_current(): nentries: %d\n", int(entries.size()));

if ( entries.empty() || timeout <= 0 || !interruptible_state )

return false;

const exec_entry_t &last = entries.back();

bool can = (now - last.etime) > timeout;

LEXEC("can_interrupt_current(): last: %d, now: %d (-> %d)\n",

int(last.etime), int(now), can);

return can;

{

LEXEC("on_trace() (steps=%d, nentries=%d)\n",

int(execution.steps_before_action), int(execution.entries.size()));

// we don't want to query for time at every trace event

if ( execution.steps_before_action-- > 0 )

return 0;

execution.reset_steps();

time_t now = time(NULL);

LEXEC("on_trace()::now: %d\n", int(now));

bool can_interrupt = execution.can_interrupt_current(now);

if ( can_interrupt )

{

LEXEC("on_trace()::can_interrupt. Waitdialog shown? %d\n",

int(execution.waitdialog_shown));

if ( execution.waitdialog_shown )

{

if ( user_cancelled() )

{

LEXEC("on_trace()::INTERRUPTING\n");

PyErr_SetString(PyExc_KeyboardInterrupt, "User interrupted");

return -1;

}

}

else

{

LEXEC("on_trace()::showing wait dialog\n");

show_wait_box("Running Python script");

execution.waitdialog_shown = true;

}

}

#ifdef ENABLE_PYTHON_PROFILING

return tracefunc(obj, frame, what, arg);

#else

qnotused(obj);

qnotused(frame);

qnotused(what);

qnotused(arg);

return 0;

#endif

{

bool created;

new_execution_t()

{

created = g_ui_ready && execution.timeout > 0;

if ( created )

{

PYW_GIL_CHECK_LOCKED_SCOPE();

execution.push();

}

}

~new_execution_t()

{

if ( created )

{

PYW_GIL_CHECK_LOCKED_SCOPE();

execution.pop();

}

}

{

// Clear timeout

execution.timeout = 0;

// Uninstall the trace function and hide the waitbox (if it was shown)

execution.stop_tracking();

{

// Update the timeout

qswap(timeout, execution.timeout);

// Reset the execution time and hide the waitbox (so it is shown again after timeout elapses)

execution.sync_to_present_time();

return timeout;

qstring *errbuf,

bool clear_error = true)

{

if ( errbuf != NULL )

errbuf->clear();

// No exception?

if ( !PyErr_Occurred() )

return;

PyW_GetError(errbuf, clear_error);

const char *str,

const char *filename = "<string>")

{

// Compile as an expression

PYW_GIL_CHECK_LOCKED_SCOPE();

PyCompilerFlags cf = {0};

newref_t py_code(Py_CompileStringFlags(str, filename, Py_eval_input, &cf));

if ( py_code == NULL || PyErr_Occurred() )

{

// Not an expression?

PyErr_Clear();

// Run as a string

PyRun_SimpleString(str);

}

else

{

PyObject *py_globals = get_module_globals();

newref_t py_result(

PyEval_EvalCode(

(PyCodeObject *) py_code.o,

py_globals,

py_globals));

if ( py_result == NULL || PyErr_Occurred() ) //-V560 is always false: PyErr_Occurred()

{

PyErr_Print();

}

else

{

if ( py_result.o != Py_None )

{

bool ok = false;

if ( PyUnicode_Check(py_result.o) )

{

newref_t py_result_utf8(PyUnicode_AsUTF8String(py_result.o));

ok = py_result_utf8 != NULL;

if ( ok )

msg("%s\n", PyString_AS_STRING(py_result_utf8.o));

}

else

{

qstring result_str;

ok = PyW_ObjectToString(py_result.o, &result_str);

if ( ok )

msg("%s\n", result_str.c_str());

}

if ( !ok )

msg("*** IDAPython: Couldn't convert evaluation result\n");

}

}

}

const char *str,

qstring *errbuf)

{

PYW_GIL_GET;

PyObject *globals = get_module_globals();

bool ok;

if ( globals == NULL )

{

ok = false;

}

else

{

errbuf->clear();

PyErr_Clear();

{

new_execution_t exec;

newref_t result(PyRun_String(

str,

Py_file_input,

globals,

globals));

ok = result != NULL && !PyErr_Occurred();

if ( !ok )

handle_python_error(errbuf);

}

}

if ( !ok && errbuf->empty() )

*errbuf = "internal error";

return ok;

idc_value_t *argv,

idc_value_t *res)

{

qstring errbuf;

bool ok = IDAPython_extlang_eval_snippet(argv[0].c_str(), &errbuf);

if ( ok )

res->set_long(0);

else

res->set_string(errbuf);

return eOk;

{

static const char *const script_files[] =

{

S_IDC_MODNAME ".py",

S_INIT_PY,

"ida_idaapi.py",

"idautils.py"

};

char filepath[QMAXPATH];

for ( size_t i=0; i < qnumber(script_files); i++ )

{

qmakepath(filepath, sizeof(filepath), g_idapython_dir, script_files[i], NULL);

if ( !qfileexist(filepath) )

{

warning("IDAPython: Missing required file: '%s'", script_files[i]);

return false;

}

}

// on linux, PyQt needs to drop python/lib/python2.7/lib-dynload/sip.so,

// thus we can't rely on the mere presence of 'lib'. However, we know

// the bundled python drops python/lib/python27.zip. Let's look for that.

#ifdef __LINUX__

qmakepath(filepath, sizeof(filepath), g_idapython_dir, "lib", "python27.zip", NULL);

if ( qfileexist(filepath) )

{

deb(IDA_DEBUG_PLUGIN, "Found \"%s\"; assuming local Python.\n", filepath);

g_use_local_python = true;

}

#endif // __LINUX__

return true;

{

#ifdef __NT__

// if the current disk has no space (sic, the current directory, not the one

// with the input file), PyRun_File() will die with a cryptic message that

// C runtime library could not be loaded. So we check the disk space before

// calling it.

char curdir[QMAXPATH];

// check if the current directory is accessible. if not, qgetcwd won't return

qgetcwd(curdir, sizeof(curdir));

if ( get_free_disk_space(curdir) == 0 )

{

warning("No free disk space on %s, python will not be available", curdir);

return 0;

}

#endif

PYW_GIL_CHECK_LOCKED_SCOPE();

PyObject *file_obj = PyFile_FromString((char*)FileName, "r"); //lint !e605

PyObject *globals = get_module_globals();

if ( globals == NULL || file_obj == NULL )

{

Py_XDECREF(file_obj);

return 0;

}

PyErr_Clear();

PyObject *result = PyRun_File(

PyFile_AsFile(file_obj),

FileName,

Py_file_input,

globals,

globals);

Py_XDECREF(file_obj);

int rc = result != NULL && !PyErr_Occurred();

Py_XDECREF(result);

return rc;

{

qstring qbuf;

netnode history;

// Get the existing or create a new netnode in the database

history.create(S_IDAPYTHON_DATA_NODE);

history.getblob(&qbuf, 0, 'A');

if ( ask_text(&qbuf, 0, qbuf.c_str(), "ACCEPT TABS\nEnter Python expressions") )

{

{

PYW_GIL_GET;

new_execution_t exec;

PyRun_SimpleString(qbuf.c_str());

}

// Store the statement to the database

history.setblob(qbuf.c_str(), qbuf.size(), 0, 'A');

}

idc_value_t *idc_result,

const ref_t &py_result,

qstring *errbuf)

{

if ( errbuf != NULL )

errbuf->clear();

if ( py_result == NULL )

{

handle_python_error(errbuf);

return false;

}

int cvt = CIP_OK;

if ( idc_result != NULL )

{

idc_result->clear();

cvt = pyvar_to_idcvar(py_result, idc_result);

if ( cvt < CIP_OK && errbuf != NULL )

*errbuf = "ERROR: bad return value";

}

return cvt >= CIP_OK;

const char *FileName,

PyObject *globals,

qstring *errbuf,

const char *idaapi_script = S_IDAAPI_EXECSCRIPT,

idc_value_t *second_res = NULL,

bool want_tuple = false)

{

PYW_GIL_CHECK_LOCKED_SCOPE();

ref_t py_execscript(get_idaapi_attr(idaapi_script));

if ( py_execscript == NULL )

{

errbuf->sprnt("Could not find %s.%s ?!", S_IDA_IDAAPI_MODNAME, idaapi_script);

return false;

}

char script[MAXSTR];

qstrncpy(script, FileName, sizeof(script));

strrpl(script, '\\', '/');

if ( globals == NULL )

globals = get_module_globals();

newref_t py_script(PyString_FromString(script));

borref_t py_false(Py_False);

newref_t py_ret(PyObject_CallFunctionObjArgs(

py_execscript.o,

py_script.o,

globals,

py_false.o,

NULL));

// Failure at this point means the script was interrupted

bool interrupted = false;

if ( PyW_GetError(errbuf) || py_ret == NULL )

{

PyErr_Clear();

if ( errbuf->empty() )

*errbuf = "Script interrupted";

interrupted = true;

}

bool ok = false;

if ( !interrupted )

{

PyObject *ret_o;

if ( want_tuple )

{

if ( second_res != NULL

&& PyTuple_Check(py_ret.o)

&& PyTuple_Size(py_ret.o) == 2 )

{

ret_o = PyTuple_GetItem(py_ret.o, 0); // Borrowed reference

}

else

{

INTERR(30444);

}

}

else

{

ret_o = py_ret.o;

}

if ( ret_o == Py_None ) //-V614 uninitialized 'ret_o'

{

if ( want_tuple )

{

borref_t ret2_o(PyTuple_GetItem(py_ret.o, 1));

ok = return_python_result(second_res, ret2_o, errbuf);

}

else

{

ok = true;

}

}

else if ( PyString_Check(ret_o) )

{

*errbuf = PyString_AsString(ret_o);

}

else

{

INTERR(30154);

}

}

return ok;

{

qstring errbuf;

bool ok;

{

new_execution_t exec;

ok = IDAPython_ExecFile(script, /*globals*/ NULL, &errbuf);

}

if ( !ok )

warning("IDAPython: error executing '%s':\n%s", script, errbuf.c_str());

return ok;

const char *full_name,

char *modname,

char *attrname,

size_t sz,

const char *defmod = S_IDA_IDAAPI_MODNAME)

{

const char *p = strrchr(full_name, '.');

if ( p == NULL )

{

qstrncpy(modname, defmod, sz);

qstrncpy(attrname, full_name, sz);

}

else

{

qstrncpy(modname, full_name, p - full_name + 1);

qstrncpy(attrname, p + 1, sz);

}

return p != NULL;

idc_value_t *result,

const char *name,

const idc_value_t args[],

size_t nargs,

qstring *errbuf)

{

PYW_GIL_GET;

// Try to extract module name (if any) from the funcname

char modname[MAXSTR];

char funcname[MAXSTR];

bool imported_module = parse_py_modname(name, modname, funcname, MAXSTR);

bool ok = true;

PyObject *module = NULL;

ref_vec_t pargs;

do

{

// Convert arguments to python

ok = pyw_convert_idc_args(args, nargs, pargs, 0, errbuf);

if ( !ok )

break;

if ( imported_module )

{

module = PyImport_ImportModule(modname);

}

else

{

module = PyImport_AddModule(S_MAIN);

QASSERT(30156, module != NULL);

}

PyObject *globals = PyModule_GetDict(module);

QASSERT(30157, globals != NULL);

PyObject *func = PyDict_GetItemString(globals, funcname);

if ( func == NULL )

{

errbuf->sprnt("undefined function %s", name);

ok = false;

break;

}

borref_t code(PyFunction_GetCode(func));

qvector<PyObject*> pargs_ptrs;

pargs.to_pyobject_pointers(&pargs_ptrs);

newref_t py_res(PyEval_EvalCodeEx(

(PyCodeObject*) code.o,

globals, NULL,

pargs_ptrs.begin(),

nargs,

NULL, 0, NULL, 0, NULL));

ok = return_python_result(result, py_res, errbuf);

} while ( false );

if ( imported_module )

Py_XDECREF(module);

return ok;

{

out->sprnt("def %s():\n", name);

// dont copy trailing whitespace

int i = body.length()-1;

while ( i >= 0 && qisspace(body.at(i)) )

i--;

out->append(body.substr(0, i+1));

out->replace("\n", "\n ");

const char *name,

ea_t /*current_ea*/,

const char *expr,

qstring *errbuf)

{

PYW_GIL_GET;

PyObject *globals = get_module_globals();

bool isfunc = false;

PyCodeObject *code = (PyCodeObject *)Py_CompileString(expr, "<string>", Py_eval_input);

if ( code == NULL )

{

// try compiling as a list of statements

// wrap them into a function

handle_python_error(errbuf);

qstring func;

wrap_in_function(&func, expr, name);

code = (PyCodeObject *)Py_CompileString(func.c_str(), "<string>", Py_file_input);

if ( code == NULL )

{

handle_python_error(errbuf);

return false;

}

isfunc = true;

}

// Set the desired function name

Py_XDECREF(code->co_name);

code->co_name = PyString_FromString(name);

// Create a function out of code

PyObject *func = PyFunction_New((PyObject *)code, globals);

if ( func == NULL )

{

ERR:

handle_python_error(errbuf);

Py_XDECREF(code);

return false;

}

int err = PyDict_SetItemString(globals, name, func);

Py_XDECREF(func);

if ( err )

goto ERR;

if ( isfunc )

{

idc_value_t result;

return IDAPython_extlang_call_func(&result, name, NULL, 0, errbuf);

}

return true;

const char *path,

qstring *errbuf)

{

PYW_GIL_GET;

new_execution_t exec;

PyObject *globals = get_module_globals_from_path(path);

return IDAPython_ExecFile(path, globals, errbuf);

idc_value_t *procobj,

const char *path,

qstring *errbuf)

{

PYW_GIL_GET;

bool ok;

{

new_execution_t exec;

PyObject *globals = get_module_globals_from_path(path);

ok = IDAPython_ExecFile(path, globals, errbuf, S_IDAAPI_LOADPROCMOD, procobj, true);

}

if ( ok && procobj->is_zero() )

{

errbuf->clear();

ok = false;

}

return ok;

const char *path,

qstring *errbuf)

{

PYW_GIL_GET;

new_execution_t exec;

PyObject *globals = get_module_globals_from_path(path);

return IDAPython_ExecFile(path, globals, errbuf, S_IDAAPI_UNLOADPROCMOD);

idc_value_t *result, // out: created object or exception

const char *name, // in: object class name

const idc_value_t args[], // in: input arguments

size_t nargs, // in: number of input arguments

qstring *errbuf) // out: error message if evaluation fails

{

PYW_GIL_GET;

bool ok = false;

ref_vec_t pargs;

do

{

// Parse the object name (to get the module and class name)

char modname[MAXSTR];

char clsname[MAXSTR];

parse_py_modname(name, modname, clsname, MAXSTR);

// Get a reference to the module

ref_t py_mod(PyW_TryImportModule(modname));

if ( py_mod == NULL )

{

errbuf->sprnt("Could not import module '%s'!", modname);

break;

}

// If the class provides an wraper instantiator, use that

ref_t py_res;

if ( nargs == 1 && args[0].vtype == VT_PVOID )

py_res = try_create_swig_wrapper(py_mod, clsname, args[0].pvoid);

if ( py_res != NULL )

{