/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDBus module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qcoreapplication.h>

#include <qdebug.h>

#include <qmetaobject.h>

#include <qobject.h>

#include <qsocketnotifier.h>

#include <qstringlist.h>

#include <qtimer.h>

#include <qthread.h>

#include "qdbusargument.h"

#include "qdbusconnection_p.h"

#include "qdbusinterface_p.h"

#include "qdbusmessage.h"

#include "qdbusmetatype.h"

#include "qdbusmetatype_p.h"

#include "qdbusabstractadaptor.h"

#include "qdbusabstractadaptor_p.h"

#include "qdbusutil_p.h"

#include "qdbusmessage_p.h"

#include "qdbuscontext_p.h"

#include "qdbuspendingcall_p.h"

#include "qdbusintegrator_p.h"

#include "qdbusthreaddebug_p.h"

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

static bool isDebugging;

#define qDBusDebug              if (!::isDebugging); else qDebug

static inline QDebug operator<<(QDebug dbg, const QThread *th)

{

    dbg.nospace() << "QThread(ptr=" << (void*)th;

    if (th && !th->objectName().isEmpty())

        dbg.nospace() << ", name=" << th->objectName();

    dbg.nospace() << ')';

    return dbg.space();

}

#if QDBUS_THREAD_DEBUG

static inline QDebug operator<<(QDebug dbg, const QDBusConnectionPrivate *conn)

{

    dbg.nospace() << "QDBusConnection("

                  << "ptr=" << (void*)conn

                  << ", name=" << conn->name

                  << ", baseService=" << conn->baseService

                  << ", thread=";

    if (conn->thread() == QThread::currentThread())

        dbg.nospace() << "same thread";

    else

        dbg.nospace() << conn->thread();

    dbg.nospace() << ')';

    return dbg.space();

}

Q_AUTOTEST_EXPORT void qdbusDefaultThreadDebug(int action, int condition, QDBusConnectionPrivate *conn)

{

    qDBusDebug() << QThread::currentThread()

                 << "QtDBus threading action" << action

                 << (condition == QDBusLockerBase::BeforeLock ? "before lock" :

                     condition == QDBusLockerBase::AfterLock ? "after lock" :

                     condition == QDBusLockerBase::BeforeUnlock ? "before unlock" :

                     condition == QDBusLockerBase::AfterUnlock ? "after unlock" :

                     condition == QDBusLockerBase::BeforePost ? "before event posting" :

                     condition == QDBusLockerBase::AfterPost ? "after event posting" :

                     condition == QDBusLockerBase::BeforeDeliver ? "before event delivery" :

                     condition == QDBusLockerBase::AfterDeliver ? "after event delivery" :

                     condition == QDBusLockerBase::BeforeAcquire ? "before acquire" :

                     condition == QDBusLockerBase::AfterAcquire ? "after acquire" :

                     condition == QDBusLockerBase::BeforeRelease ? "before release" :

                     condition == QDBusLockerBase::AfterRelease ? "after release" :

                     "condition unknown")

                 << "in connection" << conn;

}

Q_AUTOTEST_EXPORT qdbusThreadDebugFunc qdbusThreadDebug = 0;

#endif

typedef void (*QDBusSpyHook)(const QDBusMessage&);

typedef QVarLengthArray<QDBusSpyHook, 4> QDBusSpyHookList;

Q_GLOBAL_STATIC(QDBusSpyHookList, qDBusSpyHookList)

extern "C" {

    // libdbus-1 callbacks

static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms);

static dbus_bool_t qDBusAddTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

  //  qDebug("addTimeout %d", q_dbus_timeout_get_interval(timeout));

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    if (!q_dbus_timeout_get_enabled(timeout))

        return true;

    QDBusWatchAndTimeoutLocker locker(AddTimeoutAction, d);

    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

        // correct thread

        return qDBusRealAddTimeout(d, timeout, q_dbus_timeout_get_interval(timeout));

    } else {

        // wrong thread: sync back

        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

        ev->subtype = QDBusConnectionCallbackEvent::AddTimeout;

        d->timeoutsPendingAdd.append(qMakePair(timeout, q_dbus_timeout_get_interval(timeout)));

        d->postEventToThread(AddTimeoutAction, d, ev);

        return true;

    }

}

static bool qDBusRealAddTimeout(QDBusConnectionPrivate *d, DBusTimeout *timeout, int ms)

{

    Q_ASSERT(d->timeouts.keys(timeout).isEmpty());

    int timerId = d->startTimer(ms);

    if (!timerId)

        return false;

    d->timeouts[timerId] = timeout;

    return true;

}

static void qDBusRemoveTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

  //  qDebug("removeTimeout");

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    QDBusWatchAndTimeoutLocker locker(RemoveTimeoutAction, d);

    // is it pending addition?

    QDBusConnectionPrivate::PendingTimeoutList::iterator pit = d->timeoutsPendingAdd.begin();

    while (pit != d->timeoutsPendingAdd.end()) {

        if (pit->first == timeout)

            pit = d->timeoutsPendingAdd.erase(pit);

        else

            ++pit;

    }

    // is it a running timer?

    bool correctThread = QCoreApplication::instance() && QThread::currentThread() == d->thread();

    QDBusConnectionPrivate::TimeoutHash::iterator it = d->timeouts.begin();

    while (it != d->timeouts.end()) {

        if (it.value() == timeout) {

            if (correctThread) {

                // correct thread

                d->killTimer(it.key());

            } else {

                // incorrect thread or no application, post an event for later

                QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

                ev->subtype = QDBusConnectionCallbackEvent::KillTimer;

                ev->timerId = it.key();

                d->postEventToThread(KillTimerAction, d, ev);

            }

            it = d->timeouts.erase(it);

            break;

        } else {

            ++it;

        }

    }

}

static void qDBusToggleTimeout(DBusTimeout *timeout, void *data)

{

    Q_ASSERT(timeout);

    Q_ASSERT(data);

    //qDebug("ToggleTimeout");

    qDBusRemoveTimeout(timeout, data);

    qDBusAddTimeout(timeout, data);

}

static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd);

static dbus_bool_t qDBusAddWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    int flags = q_dbus_watch_get_flags(watch);

    int fd = q_dbus_watch_get_fd(watch);

    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

        return qDBusRealAddWatch(d, watch, flags, fd);

    } else {

        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

        ev->subtype = QDBusConnectionCallbackEvent::AddWatch;

        ev->watch = watch;

        ev->fd = fd;

        ev->extra = flags;

        d->postEventToThread(AddWatchAction, d, ev);

        return true;

    }

}

static bool qDBusRealAddWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int flags, int fd)

{

    QDBusConnectionPrivate::Watcher watcher;

    QDBusWatchAndTimeoutLocker locker(AddWatchAction, d);

    if (flags & DBUS_WATCH_READABLE) {

        //qDebug("addReadWatch %d", fd);

        watcher.watch = watch;

        if (QCoreApplication::instance()) {

            watcher.read = new QSocketNotifier(fd, QSocketNotifier::Read, d);

            watcher.read->setEnabled(q_dbus_watch_get_enabled(watch));

            d->connect(watcher.read, SIGNAL(activated(int)), SLOT(socketRead(int)));

        }

    }

    if (flags & DBUS_WATCH_WRITABLE) {

        //qDebug("addWriteWatch %d", fd);

        watcher.watch = watch;

        if (QCoreApplication::instance()) {

            watcher.write = new QSocketNotifier(fd, QSocketNotifier::Write, d);

            watcher.write->setEnabled(q_dbus_watch_get_enabled(watch));

            d->connect(watcher.write, SIGNAL(activated(int)), SLOT(socketWrite(int)));

        }

    }

    d->watchers.insertMulti(fd, watcher);

    return true;

}

static void qDBusRemoveWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    //qDebug("remove watch");

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    int fd = q_dbus_watch_get_fd(watch);

    QDBusWatchAndTimeoutLocker locker(RemoveWatchAction, d);

    QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);

    while (i != d->watchers.end() && i.key() == fd) {

        if (i.value().watch == watch) {

            if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

                // correct thread, delete the socket notifiers

                delete i.value().read;

                delete i.value().write;

            } else {

                // incorrect thread or no application, use delete later

                if (i->read)

                    i->read->deleteLater();

                if (i->write)

                    i->write->deleteLater();

            }

            i = d->watchers.erase(i);

        } else {

            ++i;

        }

    }

}

static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd);

static void qDBusToggleWatch(DBusWatch *watch, void *data)

{

    Q_ASSERT(watch);

    Q_ASSERT(data);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    int fd = q_dbus_watch_get_fd(watch);

    if (QCoreApplication::instance() && QThread::currentThread() == d->thread()) {

        qDBusRealToggleWatch(d, watch, fd);

    } else {

        QDBusConnectionCallbackEvent *ev = new QDBusConnectionCallbackEvent;

        ev->subtype = QDBusConnectionCallbackEvent::ToggleWatch;

        ev->watch = watch;

        ev->fd = fd;

        d->postEventToThread(ToggleWatchAction, d, ev);

    }

}

static void qDBusRealToggleWatch(QDBusConnectionPrivate *d, DBusWatch *watch, int fd)

{

    QDBusWatchAndTimeoutLocker locker(ToggleWatchAction, d);

    QDBusConnectionPrivate::WatcherHash::iterator i = d->watchers.find(fd);

    while (i != d->watchers.end() && i.key() == fd) {

        if (i.value().watch == watch) {

            bool enabled = q_dbus_watch_get_enabled(watch);

            int flags = q_dbus_watch_get_flags(watch);

            //qDebug("toggle watch %d to %d (write: %d, read: %d)", q_dbus_watch_get_fd(watch), enabled, flags & DBUS_WATCH_WRITABLE, flags & DBUS_WATCH_READABLE);

            if (flags & DBUS_WATCH_READABLE && i.value().read)

                i.value().read->setEnabled(enabled);

            if (flags & DBUS_WATCH_WRITABLE && i.value().write)

                i.value().write->setEnabled(enabled);

            return;

        }

        ++i;

    }

}

static void qDBusUpdateDispatchStatus(DBusConnection *connection, DBusDispatchStatus new_status, void *data)

{

    Q_ASSERT(connection);

    Q_UNUSED(connection);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    static int slotId; // 0 is QObject::deleteLater()

    if (!slotId) {

        // it's ok to do this: there's no race condition because the store is atomic

        // and we always set to the same value

        slotId = QDBusConnectionPrivate::staticMetaObject.indexOfSlot("doDispatch()");

    }

    //qDBusDebug() << "Updating dispatcher status" << slotId;

    if (new_status == DBUS_DISPATCH_DATA_REMAINS)

        QDBusConnectionPrivate::staticMetaObject.method(slotId).

            invoke(d, Qt::QueuedConnection);

}

static void qDBusNewConnection(DBusServer *server, DBusConnection *connection, void *data)

{

    // ### We may want to separate the server from the QDBusConnectionPrivate    

    Q_ASSERT(server); Q_UNUSED(server);

    Q_ASSERT(connection);

    Q_ASSERT(data);

    // keep the connection alive

    q_dbus_connection_ref(connection);

    QDBusConnectionPrivate *d = new QDBusConnectionPrivate;

    // setConnection does the error handling for us

    QDBusErrorInternal error;

    d->setPeer(connection, error);

    QDBusConnection retval = QDBusConnectionPrivate::q(d);

    d->setBusService(retval);

    //d->name = QString::number(reinterpret_cast<int>(d));

    //d->setConnection(d->name, d); 

    // make QDBusServer emit the newConnection signal

    QDBusConnectionPrivate *server_d = static_cast<QDBusConnectionPrivate *>(data);

    server_d->serverConnection(retval);

}

} // extern "C"

static QByteArray buildMatchRule(const QString &service,

                                 const QString &objectPath, const QString &interface,

                                 const QString &member, const QStringList &argMatch, const QString & /*signature*/)

{

    QString result = QLatin1String("type='signal',");

    QString keyValue = QLatin1String("%1='%2',");

    if (!service.isEmpty())

        result += keyValue.arg(QLatin1String("sender"), service);

    if (!objectPath.isEmpty())

        result += keyValue.arg(QLatin1String("path"), objectPath);

    if (!interface.isEmpty())

        result += keyValue.arg(QLatin1String("interface"), interface);

    if (!member.isEmpty())

        result += keyValue.arg(QLatin1String("member"), member);

    // add the argument string-matching now

    if (!argMatch.isEmpty()) {

        keyValue = QLatin1String("arg%1='%2',");

        for (int i = 0; i < argMatch.count(); ++i)

            if (!argMatch.at(i).isNull())

                result += keyValue.arg(i).arg(argMatch.at(i));

    }

    result.chop(1);             // remove ending comma

    return result.toLatin1();

}

static bool findObject(const QDBusConnectionPrivate::ObjectTreeNode *root,

                       const QString &fullpath, int &usedLength,

                       QDBusConnectionPrivate::ObjectTreeNode &result)

{

    int start = 0;

    int length = fullpath.length();

    if (fullpath.at(0) == QLatin1Char('/'))

        start = 1;

    // walk the object tree

    const QDBusConnectionPrivate::ObjectTreeNode *node = root;

    while (start < length && node && !(node->flags & QDBusConnection::ExportChildObjects)) {

        int end = fullpath.indexOf(QLatin1Char('/'), start);

        end = (end == -1 ? length : end);

        QStringRef pathComponent(&fullpath, start, end - start);

        QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator it =

            qLowerBound(node->children.constBegin(), node->children.constEnd(), pathComponent);

        if (it != node->children.constEnd() && it->name == pathComponent)

            // match

            node = it;

        else

            node = 0;

        start = end + 1;

    }

    // found our object

    usedLength = (start > length ? length : start);

    if (node) {

        if (node->obj || !node->children.isEmpty())

            result = *node;

        else

            // there really is no object here

            // we're just looking at an unused space in the QVector

            node = 0;

    }

    return node;

}

static QObject *findChildObject(const QDBusConnectionPrivate::ObjectTreeNode *root,

                                const QString &fullpath, int start)

{

    int length = fullpath.length();

    // any object in the tree can tell us to switch to its own object tree:

    const QDBusConnectionPrivate::ObjectTreeNode *node = root;

    if (node && node->flags & QDBusConnection::ExportChildObjects) {

        QObject *obj = node->obj;

        while (obj) {

            if (start >= length)

                // we're at the correct level

                return obj;

            int pos = fullpath.indexOf(QLatin1Char('/'), start);

            pos = (pos == -1 ? length : pos);

            QStringRef pathComponent(&fullpath, start, pos - start);

            const QObjectList children = obj->children();

            // find a child with the proper name

            QObject *next = 0;

            QObjectList::ConstIterator it = children.constBegin();

            QObjectList::ConstIterator end = children.constEnd();

            for ( ; it != end; ++it)

                if ((*it)->objectName() == pathComponent) {

                    next = *it;

                    break;

                }

            if (!next)

                break;

            obj = next;

            start = pos + 1;

        }

    }

    // object not found

    return 0;

}

static bool shouldWatchService(const QString &service)

{

    return !service.isEmpty() && !service.startsWith(QLatin1Char(':'));

}

extern Q_DBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook);

void qDBusAddSpyHook(QDBusSpyHook hook)

{

    qDBusSpyHookList()->append(hook);

}

extern "C" {

static DBusHandlerResult

qDBusSignalFilter(DBusConnection *connection, DBusMessage *message, void *data)

{

    Q_ASSERT(data);

    Q_UNUSED(connection);

    QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);

    if (d->mode == QDBusConnectionPrivate::InvalidMode)

        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;