void
lookup_remote_credentials(NiceAgent* agent, guint stream_id) {
guint retval;
gchar lookup_cmd[1024];
g_snprintf(lookup_cmd, sizeof(lookup_cmd), "./niceexchange.sh 0 %s lookup dummy", remote_hostname);
if(is_caller)
lookup_cmd[18] = '1';
gchar *stdout;
gchar *stderr;
retval = execute_sync(lookup_cmd, NULL, &stdout, &stderr);
if(retval != 0) {
g_critical("niceexchange lookup returned a non-zero return value (%i)!", retval);
if(stderr != NULL)
g_critical("This was written to stderr:\n%s", stderr);
g_free(stdout);
g_free(stderr);
g_main_loop_unref(gloop);
g_object_unref(agent);
exit(1);
}
parse_remote_data(agent, stream_id, 1, stdout, strlen(stdout));
g_free(stdout);
g_free(stderr);
}
void
publish_local_credentials(NiceAgent* agent, guint stream_id) {
gint retval;
// publish local credentials
gchar publish_cmd[1024];
g_snprintf(publish_cmd, sizeof(publish_cmd), "./niceexchange.sh 0 %s publish dummy", remote_hostname);
if(is_caller)
publish_cmd[18] = '1';
gchar *stdin;
local_credentials_to_string(agent, stream_id, 1, &stdin);
retval = execute_sync(publish_cmd, stdin, NULL, NULL);
if(retval != 0) {
g_critical("niceexchange publish returned a non-zero return value (%i)!", retval);
g_main_loop_unref(gloop);
g_object_unref(agent);
exit(1);
}
g_free(stdin);
g_debug("published local credentials\n");
}
//queue up a received datagram for eventual handlng via IDA's execute_sync mechanism
//call no sdk functions other than execute_sync
void disp_request_t::queueBuffer(Buffer *b) {
if (buffers.enqueue(b)) {
//only invoke execute_sync if the buffer just added was at the head of he queue
//in theory this allows multiple datagrams to get queued for handling
//in a single execute_sync callback
execute_sync(*this, MFF_WRITE);
}
}
void sdl_window_info::notify_changed()
{
auto wp = std::make_unique<worker_param>(std::static_pointer_cast<sdl_window_info>(shared_from_this()));
if (SDL_ThreadID() == main_threadid)
{
execute_async_wait(¬ify_changed_wt, std::move(wp));
}
else
execute_sync(¬ify_changed_wt, std::move(wp));
}
void sdl_window_info::notify_changed()
{
worker_param wp;
if (SDL_ThreadID() == main_threadid)
{
execute_async_wait(¬ify_changed_wt, worker_param(this));
}
else
execute_sync(¬ify_changed_wt, worker_param(this));
}
//------------------------------------------------------------------------
static int py_execute_sync(PyObject *py_callable, int reqf)
{
PYW_GIL_CHECK_LOCKED_SCOPE();
int rc = -1;
// Callable?
if ( PyCallable_Check(py_callable) )
{
struct py_exec_request_t : exec_request_t
{
ref_t py_callable;
virtual int idaapi execute()
{
PYW_GIL_GET;
newref_t py_result(PyObject_CallFunctionObjArgs(py_callable.o, NULL));
int ret = py_result == NULL || !PyInt_Check(py_result.o)
? -1
: PyInt_AsLong(py_result.o);
// if the requesting thread decided not to wait for the request to
// complete, we have to self-destroy, nobody else will do it
if ( (code & MFF_NOWAIT) != 0 )
delete this;
return ret;
}
py_exec_request_t(PyObject *pyc)
{
// No need to GIL-ensure here, since this is created
// within the py_execute_sync() scope.
py_callable = borref_t(pyc);
}
virtual ~py_exec_request_t()
{
// Need to GIL-ensure here, since this might be called
// from the main thread.
PYW_GIL_GET;
py_callable = ref_t(); // Release callable
}
};
py_exec_request_t *req = new py_exec_request_t(py_callable);
// Release GIL before executing, or if this is running in the
// non-main thread, this will wait on the req.sem, while the main
// thread might be waiting for the GIL to be available.
Py_BEGIN_ALLOW_THREADS;
rc = execute_sync(*req, reqf);
Py_END_ALLOW_THREADS;
// destroy the request once it is finished. exception: NOWAIT requests
// will be handled in the future, so do not destroy them yet!
if ( (reqf & MFF_NOWAIT) == 0 )
delete req;
}
return rc;
}
//queue up a received datagram for eventual handlng via IDA's execute_sync mechanism
//call no sdk functions other than execute_sync
void disp_request_t::queueObject(json_object *obj) {
bool call_exec = false;
qmutex_lock(mtx);
objects.push_back(obj);
call_exec = objects.size() == 1;
qmutex_unlock(mtx);
if (call_exec) {
//only invoke execute_sync if the buffer just added was at the head of the queue
//in theory this allows multiple datagrams to get queued for handling
//in a single execute_sync callback
execute_sync(*this, MFF_WRITE);
}
}
void
unpublish_local_credentials(NiceAgent* agent, guint stream_id) {
guint retval;
g_debug("lookup remote credentials done\n");
gchar unpublish_cmd[1024];
g_snprintf(unpublish_cmd, sizeof(unpublish_cmd), "./niceexchange.sh 0 %s unpublish dummy", remote_hostname);
if(is_caller)
unpublish_cmd[18] = '1';
retval = execute_sync(unpublish_cmd, NULL, NULL, NULL);
if(retval != 0) {
g_critical("niceexchange unpublish returned a non-zero return value (%i)!", retval);
g_main_loop_unref(gloop);
g_object_unref(agent);
exit(1);
}
g_debug("unpublish local credentials done\n");
}
