/* Implementation of the _dbus_bindings Connection type, a Python wrapper
* for DBusConnection. See also conn-methods.c.
*
* Copyright (C) 2006-2008 Collabora Ltd. <http://www.collabora.co.uk/>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include "dbus_bindings-internal.h"
#include "conn-internal.h"
/* Connection definition ============================================ */
PyDoc_STRVAR(Connection_tp_doc,
"A D-Bus connection.\n"
"\n"
"::\n"
"\n"
" Connection(address, mainloop=None) -> Connection\n"
);
/* D-Bus Connection user data slot, containing an owned reference to either
* the Connection, or a weakref to the Connection.
*/
static dbus_int32_t _connection_python_slot;
/* C API for main-loop hooks ======================================== */
/* Return a borrowed reference to the DBusConnection which underlies this
* Connection. */
DBusConnection *
DBusPyConnection_BorrowDBusConnection(PyObject *self)
{
DBusConnection *dbc;
TRACE(self);
if (!DBusPyConnection_Check(self)) {
PyErr_SetString(PyExc_TypeError, "A dbus.Connection is required");
return NULL;
}
dbc = ((Connection *)self)->conn;
if (!dbc) {
PyErr_SetString(PyExc_RuntimeError, "Connection is in an invalid "
"state: no DBusConnection");
return NULL;
}
return dbc;
}
/* Internal C API =================================================== */
/* Pass a message through a handler. */
DBusHandlerResult
DBusPyConnection_HandleMessage(Connection *conn,
PyObject *msg,
PyObject *callable)
{
PyObject *obj;
TRACE(conn);
obj = PyObject_CallFunctionObjArgs(callable, conn, msg,
NULL);
if (obj == Py_None) {
DBG("%p: OK, handler %p returned None", conn, callable);
Py_CLEAR(obj);
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (obj == Py_NotImplemented) {
DBG("%p: handler %p returned NotImplemented, continuing",
conn, callable);
Py_CLEAR(obj);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
else if (!obj) {
if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
DBG_EXC("%p: handler %p caused OOM", conn, callable);
PyErr_Clear();
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
DBG_EXC("%p: handler %p raised exception", conn, callable);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
else {
long i = PyLong_AsLong(obj);
DBG("%p: handler %p returned %ld", conn, callable, i);
Py_CLEAR(obj);
if (i == -1 && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "Return from D-Bus message "
"handler callback should be None, "
"NotImplemented or integer");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
else if (i == DBUS_HANDLER_RESULT_HANDLED ||
i == DBUS_HANDLER_RESULT_NOT_YET_HANDLED ||
i == DBUS_HANDLER_RESULT_NEED_MEMORY) {
return i;
}
else {
PyErr_Format(PyExc_ValueError, "Integer return from "
"D-Bus message handler callback should "
"be a DBUS_HANDLER_RESULT_... constant, "
"not %d", (int)i);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
}
}
/* On KeyError or if unregistration is in progress, return None. */
PyObject *
DBusPyConnection_GetObjectPathHandlers(PyObject *self, PyObject *path)
{
PyObject *callbacks;
TRACE(self);
callbacks = PyDict_GetItem(((Connection *)self)->object_paths, path);
if (!callbacks) {
if (PyErr_ExceptionMatches(PyExc_KeyError)) {
PyErr_Clear();
Py_RETURN_NONE;
}
}
Py_INCREF(callbacks);
return callbacks;
}
/* Return a new reference to a Python Connection or subclass corresponding
* to the DBusConnection conn. For use in callbacks.
*
* Raises AssertionError if the DBusConnection does not have a Connection.
*/
PyObject *
DBusPyConnection_ExistingFromDBusConnection(DBusConnection *conn)
{
PyObject *self, *ref;
Py_BEGIN_ALLOW_THREADS
ref = (PyObject *)dbus_connection_get_data(conn,
_connection_python_slot);
Py_END_ALLOW_THREADS
if (ref) {
DBG("(DBusConnection *)%p has weak reference at %p", conn, ref);
self = PyWeakref_GetObject(ref); /* still a borrowed ref */
if (self && self != Py_None && DBusPyConnection_Check(self)) {
DBG("(DBusConnection *)%p has weak reference at %p pointing to %p",
conn, ref, self);
TRACE(self);
Py_INCREF(self);
TRACE(self);
return self;
}
}
PyErr_SetString(PyExc_AssertionError,
"D-Bus connection does not have a Connection "
"instance associated with it");
return NULL;
}
/* Return a new reference to a Python Connection or subclass (given by cls)
* corresponding to the DBusConnection conn, which must have been newly
* created. For use by the Connection and Bus constructors.
*
* Raises AssertionError if the DBusConnection already has a Connection.
*/
static PyObject *
DBusPyConnection_NewConsumingDBusConnection(PyTypeObject *cls,
DBusConnection *conn,
PyObject *mainloop)
{
Connection *self = NULL;
PyObject *ref;
dbus_bool_t ok;
DBG("%s(cls=%p, conn=%p, mainloop=%p)", __func__, cls, conn, mainloop);
DBUS_PY_RAISE_VIA_NULL_IF_FAIL(conn);
Py_BEGIN_ALLOW_THREADS
ref = (PyObject *)dbus_connection_get_data(conn,
_connection_python_slot);
Py_END_ALLOW_THREADS
if (ref) {
self = (Connection *)PyWeakref_GetObject(ref);
ref = NULL;
if (self && (PyObject *)self != Py_None) {
self = NULL;
PyErr_SetString(PyExc_AssertionError,
"Newly created D-Bus connection already has a "
"Connection instance associated with it");
DBG("%s() fail - assertion failed, DBusPyConn has a DBusConn already", __func__);
DBG_WHEREAMI;
return NULL;
}
}
ref = NULL;
/* Change mainloop from a borrowed reference to an owned reference */
if (!mainloop || mainloop == Py_None) {
mainloop = dbus_py_get_default_main_loop();
if (!mainloop)
goto err;
}
else {
Py_INCREF(mainloop);
}
DBG("Constructing Connection from DBusConnection at %p", conn);
self = (Connection *)(cls->tp_alloc(cls, 0));
if (!self) goto err;
TRACE(self);
DBG_WHEREAMI;
self->has_mainloop = (mainloop != Py_None);
self->conn = NULL;
self->filters = PyList_New(0);
self->weaklist = NULL;
if (!self->filters) goto err;
self->object_paths = PyDict_New();
if (!self->object_paths) goto err;
ref = PyWeakref_NewRef((PyObject *)self, NULL);
if (!ref) goto err;
DBG("Created weak ref %p to (Connection *)%p for (DBusConnection *)%p",
ref, self, conn);
Py_BEGIN_ALLOW_THREADS
ok = dbus_connection_set_data(conn, _connection_python_slot,
(void *)ref,
(DBusFreeFunction)dbus_py_take_gil_and_xdecref);
Py_END_ALLOW_THREADS
if (ok) {
DBG("Attached weak ref %p ((Connection *)%p) to (DBusConnection *)%p",
ref, self, conn);
ref = NULL; /* don't DECREF it - the DBusConnection owns it now */
}
else {
DBG("Failed to attached weak ref %p ((Connection *)%p) to "
"(DBusConnection *)%p - will dispose of it", ref, self, conn);
PyErr_NoMemory();
goto err;
}
DBUS_PY_RAISE_VIA_GOTO_IF_FAIL(conn, err);
self->conn = conn;
/* the DBusPyConnection will close it now */
conn = NULL;
if (self->has_mainloop
&& !dbus_py_set_up_connection((PyObject *)self, mainloop)) {
goto err;
}
Py_CLEAR(mainloop);
DBG("%s() -> %p", __func__, self);
TRACE(self);
return (PyObject *)self;
err:
DBG("Failed to construct Connection from DBusConnection at %p", conn);
Py_CLEAR(mainloop);
Py_CLEAR(self);
Py_CLEAR(ref);
if (conn) {
Py_BEGIN_ALLOW_THREADS
dbus_connection_close(conn);
dbus_connection_unref(conn);
Py_END_ALLOW_THREADS
}
DBG("%s() fail", __func__);
DBG_WHEREAMI;
return NULL;
}
/* Connection type-methods ========================================== */
/* Constructor */
static PyObject *
Connection_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
{
DBusConnection *conn;
PyObject *address_or_conn;
DBusError error;
PyObject *self, *mainloop = NULL;
static char *argnames[] = {"address", "mainloop", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", argnames,
&address_or_conn, &mainloop)) {
return NULL;
}
if (DBusPyLibDBusConnection_CheckExact(address_or_conn)) {
DBusPyLibDBusConnection *wrapper =
(DBusPyLibDBusConnection *) address_or_conn;
DBUS_PY_RAISE_VIA_NULL_IF_FAIL(wrapper->conn);
conn = dbus_connection_ref (wrapper->conn);
}
else if (PyBytes_Check(address_or_conn)) {
const char *address = PyBytes_AS_STRING(address_or_conn);
dbus_error_init(&error);
/* We always open a private connection (at the libdbus level). Sharing
* is done in Python, to keep things simple. */
Py_BEGIN_ALLOW_THREADS
conn = dbus_connection_open_private(address, &error);
Py_END_ALLOW_THREADS
if (!conn) {
DBusPyException_ConsumeError(&error);
return NULL;
}
}
else if (PyUnicode_Check(address_or_conn)) {
PyObject *address_as_bytes = PyUnicode_AsUTF8String(address_or_conn);
const char *address;
if (!address_as_bytes)
return NULL;
address = PyBytes_AS_STRING(address_as_bytes);
dbus_error_init(&error);
/* We always open a private connection (at the libdbus level). Sharing
* is done in Python, to keep things simple. */
Py_BEGIN_ALLOW_THREADS
conn = dbus_connection_open_private(address, &error);
Py_END_ALLOW_THREADS
Py_CLEAR(address_as_bytes);
if (!conn) {
DBusPyException_ConsumeError(&error);
return NULL;
}
}
else {
PyErr_SetString(PyExc_TypeError, "connection or str expected");
return NULL;
}
self = DBusPyConnection_NewConsumingDBusConnection(cls, conn, mainloop);
TRACE(self);
return self;
}
/* Post-construction: nothing to do (but don't chain up to object.__init__,
* which takes no arguments and does nothing) */
static int
Connection_tp_init(PyObject *self UNUSED, PyObject *args UNUSED,
PyObject *kwargs UNUSED)
{
return 0;
}
/* Destructor */
static void Connection_tp_dealloc(Connection *self)
{
DBusConnection *conn = self->conn;
PyObject *et, *ev, *etb;
PyObject *filters = self->filters;
PyObject *object_paths = self->object_paths;
/* avoid clobbering any pending exception */
PyErr_Fetch(&et, &ev, &etb);
if (self->weaklist) {
PyObject_ClearWeakRefs((PyObject *)self);
}
TRACE(self);
DBG("Deallocating Connection at %p (DBusConnection at %p)", self, conn);
DBG_WHEREAMI;
DBG("Connection at %p: deleting callbacks", self);
self->filters = NULL;
Py_CLEAR(filters);
self->object_paths = NULL;
Py_CLEAR(object_paths);
if (conn) {
/* Might trigger callbacks if we're unlucky... */
DBG("Connection at %p has a conn, closing it...", self);
Py_BEGIN_ALLOW_THREADS
dbus_connection_close(conn);
Py_END_ALLOW_THREADS
}
/* make sure to do this last to preserve the invariant that
* self->conn is always non-NULL for any referenced Connection
* (until the filters and object paths were freed, we might have been
* in a reference cycle!)
*/
DBG("Connection at %p: nulling self->conn", self);
self->conn = NULL;
if (conn) {
DBG("Connection at %p: unreffing conn", self);
dbus_connection_unref(conn);
}
DBG("Connection at %p: freeing self", self);
PyErr_Restore(et, ev, etb);
(Py_TYPE(self)->tp_free)((PyObject *)self);
}
/* Connection type object =========================================== */
PyTypeObject DBusPyConnection_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_dbus_bindings.Connection", /*tp_name*/
sizeof(Connection), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)Connection_tp_dealloc,
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
#ifdef PY3
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
#else
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS | Py_TPFLAGS_BASETYPE,
#endif
Connection_tp_doc, /*tp_doc*/
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
offsetof(Connection, weaklist), /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
DBusPyConnection_tp_methods, /*tp_methods*/
0, /*tp_members*/
0, /*tp_getset*/
0, /*tp_base*/
0, /*tp_dict*/
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
Connection_tp_init, /*tp_init*/
0, /*tp_alloc*/
Connection_tp_new, /*tp_new*/
0, /*tp_free*/
0, /*tp_is_gc*/
};
dbus_bool_t
dbus_py_init_conn_types(void)
{
/* Get a slot to store our weakref on DBus Connections */
_connection_python_slot = -1;
if (!dbus_connection_allocate_data_slot(&_connection_python_slot))
return FALSE;
if (PyType_Ready(&DBusPyConnection_Type) < 0)
return FALSE;
return TRUE;
}
dbus_bool_t
dbus_py_insert_conn_types(PyObject *this_module)
{
/* PyModule_AddObject steals a ref */
Py_INCREF (&DBusPyConnection_Type);
if (PyModule_AddObject(this_module, "Connection",
(PyObject *)&DBusPyConnection_Type) < 0) return FALSE;
return TRUE;
}
/* vim:set ft=c cino< sw=4 sts=4 et: */