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 {