/* 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: */