gboolean
ftp_policy_parse_authinfo(FtpProxy *self, const gchar *cmd, GString *param)
{
gboolean called = FALSE;
PyObject *result = NULL;
PyObject *args = NULL;
gboolean ret;
z_proxy_enter(self);
z_policy_lock(self->super.thread);
args = z_policy_var_build("ss", cmd, param->str);
result = z_policy_call(self->super.handler, "parseInbandAuth", args, &called, self->super.session_id);
if (!called)
{
z_policy_unlock(self->super.thread);
z_proxy_return(self, FALSE);
}
if (result == NULL || !z_policy_var_parse(result, "i", &ret))
ret = FALSE;
if (result)
z_policy_var_unref(result);
z_policy_unlock(self->super.thread);
z_proxy_return(self, ret);
}
gboolean
ftp_policy_bounce_check(FtpProxy *self, guint side, ZSockAddr *remote, gboolean connect)
{
PyObject *zsock;
gboolean called;
ZPolicyObj *res;
gboolean ret;
z_proxy_enter(self);
z_policy_lock(self->super.thread);
zsock = z_policy_sockaddr_new(remote);
res = z_policy_call(self->super.handler, "bounceCheck", z_policy_var_build("(Oii)", zsock, side, connect), &called, self->super.session_id);
if (!called)
{
z_policy_unlock(self->super.thread);
z_proxy_return(self, TRUE);
}
if ((res == NULL) || !z_policy_var_parse(res, "i", &ret))
ret = FALSE;
z_policy_var_unref(res);
z_policy_var_unref(zsock);
z_policy_unlock(self->super.thread);
z_proxy_return(self, ret);
}
static void
anypy_main(ZProxy * s)
{
AnyPyProxy *self = Z_CAST(s, AnyPyProxy);
ZPolicyObj *res;
gboolean called;
z_proxy_enter(self);
if (!z_proxy_connect_server(&self->super, NULL, 0) || !anypy_stream_init(self))
{
z_proxy_leave(self);
return;
}
z_policy_lock(self->super.thread);
res = z_policy_call(self->super.handler, "proxyThread", NULL, &called, self->super.session_id);
z_policy_var_unref(res);
z_policy_unlock(self->super.thread);
z_proxy_return(self);
}
/**
* z_policy_event:
* @handler: Python object whom to send the event
* @name: Method to be called
* @args: Args to pass to @name
* @session_id: Session ID
*
* Sends an event to an object by calling one of its methods. The methods
* 'preProcessEvent' and 'postProcessEvent' are called before and after the
* event handler method.
*
* FIXME: I found no occurences of 'ProcessEvent' but in this function, so I
* can't track the purpose of this functionality.
*
* Returns:
* Z_UNSPEC, Z_ABORT, ???
*/
gint
z_policy_event(PyObject *handler, char *name, PyObject *args, gchar *session_id)
{
PyObject *res;
unsigned long c_res;
gboolean called;
Py_XINCREF(args);
res = z_policy_call(handler, "preProcessEvent", args, &called, session_id);
if (res)
{
if (PyInt_Check(res))
{
c_res = PyInt_AsLong(res);
Py_XDECREF(res);
if (c_res != Z_UNSPEC)
{
Py_XDECREF(args);
return c_res;
}
}
else
{
PyErr_Format(PyExc_TypeError, "preProcessEvent() handlers should return an int.");
PyErr_Print(); /* produce a backtrace, and handle it immediately */
Py_XDECREF(res);
}
}
else
if (called)
return Z_ABORT;
Py_XINCREF(args);
res = z_policy_call(handler, name, args, &called, session_id);
if (res)
{
if (PyInt_Check(res))
{
c_res = PyInt_AsLong(res);
Py_XDECREF(res);
if (c_res != Z_UNSPEC)
{
Py_XDECREF(args);
return c_res;
}
}
else
{
PyErr_Format(PyExc_TypeError, "Event handlers should return an int: %s", name);
PyErr_Print(); /* produce a backtrace, and handle it immediately */
Py_XDECREF(res);
}
}
else
if (called)
return Z_ABORT;
res = z_policy_call(handler, "postProcessEvent", args, &called, session_id);
if (res)
{
if (PyInt_Check(res))
{
c_res = PyInt_AsLong(res);
Py_XDECREF(res);
return c_res;
}
else
{
PyErr_Format(PyExc_TypeError, "postProcessEvent() handlers should return an int.");
PyErr_Print(); /* produce a backtrace, and handle it immediately */
Py_XDECREF(res);
}
}
else
if (called)
return Z_ABORT;
return Z_UNSPEC;
}
/**
* z_proxy_stack_proxy:
* @self: proxy instance
* @proxy_class: a Python class to be instantiated as the child proxy
*
* This function is called to start a child proxy.
**/
gboolean
z_proxy_stack_proxy(ZProxy *self, ZPolicyObj *proxy_class, ZStackedProxy **stacked, ZPolicyDict *stack_info)
{
int downpair[2], uppair[2];
ZPolicyObj *res, *client_stream, *server_stream, *stack_info_obj;
ZStream *tmpstream;
ZStream *client_upstream, *server_upstream;
z_proxy_enter(self);
if (proxy_class == z_policy_none)
{
z_policy_var_unref(proxy_class);
z_proxy_leave(self);
return FALSE;
}
if (!z_proxy_stack_prepare_streams(self, downpair, uppair))
{
z_policy_var_unref(proxy_class);
z_proxy_leave(self);
return FALSE;
}
/*LOG
This message reports that Zorp is about to stack a proxy class
with the given fds as communication channels.
*/
z_proxy_log(self, CORE_DEBUG, 6, "Stacking subproxy; client='%d:%d', server='%d:%d'", downpair[0], downpair[1], uppair[0], uppair[1]);
tmpstream = z_stream_fd_new(downpair[1], "");
client_stream = z_policy_stream_new(tmpstream);
z_stream_unref(tmpstream);
tmpstream = z_stream_fd_new(uppair[1], "");
server_stream = z_policy_stream_new(tmpstream);
z_stream_unref(tmpstream);
if (stack_info)
{
stack_info_obj = z_policy_struct_new(stack_info, Z_PST_SHARED);
}
else
{
Py_XINCREF(Py_None);
stack_info_obj = Py_None;
}
res = z_policy_call(self->handler, "stackProxy", z_policy_var_build("(OOOO)", client_stream, server_stream, proxy_class, stack_info_obj),
NULL, self->session_id);
z_policy_var_unref(client_stream);
z_policy_var_unref(server_stream);
z_policy_var_unref(stack_info_obj);
if (!res || res == z_policy_none || !z_policy_proxy_check(res))
{
z_proxy_log(self, CORE_ERROR, 3, "Error stacking subproxy;");
close(downpair[0]);
close(downpair[1]);
close(uppair[0]);
close(uppair[1]);
z_policy_var_unref(res);
z_proxy_leave(self);
return FALSE;
}
client_upstream = z_stream_fd_new(downpair[0], "");
server_upstream = z_stream_fd_new(uppair[0], "");
*stacked = z_stacked_proxy_new(client_upstream, server_upstream, NULL, self, z_policy_proxy_get_proxy(res), 0);
z_policy_var_unref(res);
z_proxy_leave(self);
return TRUE;
}
static gboolean
plug_packet_stat_event(ZPlugSession *session G_GNUC_UNUSED,
guint64 client_bytes, guint64 client_pkts,
guint64 server_bytes, guint64 server_pkts,
gpointer user_data)
{
PlugProxy *self = (PlugProxy *) user_data;
ZPolicyObj *res;
gboolean called;
guint resc;
z_policy_lock(self->super.thread);
res = z_policy_call(self->super.handler, "packetStats",
z_policy_var_build("iiii",
(guint32) client_bytes,
(guint32) client_pkts,
(guint32) server_bytes,
(guint32) server_pkts),
&called,
self->super.session_id);
if (called)
{
resc = Z_REJECT;
if (res)
{
if (!z_policy_var_parse(res, "i", &resc))
{
/*LOG
This message is logged when the policy layer returned a
non-integer value in its packetStats() function. packetStats()
is expected to return Z_REJECT or Z_ACCEPT.
gchar *username,
gchar *passwd,
gchar ***groups G_GNUC_UNUSED,
ZProxy *proxy
)
{
gboolean called;
ZPolicyObj *res;
gboolean ret = FALSE;
ZPolicyObj *session;
z_session_enter(session_id);
session = z_policy_getattr(proxy->handler, "session");
res = z_policy_call(self, "performAuthentication",
z_policy_var_build("(sOss)", session_id, session, username, passwd),
&called, session_id);
z_policy_var_unref(session);
if (res != NULL)
{
gboolean retval;
if (z_policy_var_parse_boolean(res, &retval))
{
z_log(session_id, CORE_INFO, 6, "Authentication backend called; username='******', result='%d'",
username, retval);
ret = retval;
}
else
{
