1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qdbusargument_p.h"

    43 #include "qdbusutil_p.h"

    44 

    45 QT_BEGIN_NAMESPACE

    46 

    47 static void qIterAppend(DBusMessageIter *it, QByteArray *ba, int type, const void *arg)

    48 {

    49     if (ba)

    50         *ba += char(type);

    51     else

    52         q_dbus_message_iter_append_basic(it, type, arg);

    53 }

    54 

    55 QDBusMarshaller::~QDBusMarshaller()

    56 {

    57     close();

    58 }

    59 

    60 inline QString QDBusMarshaller::currentSignature()

    61 {

    62     if (message)

    63         return QString::fromUtf8(q_dbus_message_get_signature(message));

    64     return QString();

    65 }

    66 

    67 inline void QDBusMarshaller::append(uchar arg)

    68 {

    69     qIterAppend(&iterator, ba, DBUS_TYPE_BYTE, &arg);

    70 }

    71 

    72 inline void QDBusMarshaller::append(bool arg)

    73 {

    74     dbus_bool_t cast = arg;

    75     qIterAppend(&iterator, ba, DBUS_TYPE_BOOLEAN, &cast);

    76 }

    77 

    78 inline void QDBusMarshaller::append(short arg)

    79 {

    80     qIterAppend(&iterator, ba, DBUS_TYPE_INT16, &arg);

    81 }

    82 

    83 inline void QDBusMarshaller::append(ushort arg)

    84 {

    85     qIterAppend(&iterator, ba, DBUS_TYPE_UINT16, &arg);

    86 }

    87 

    88 inline void QDBusMarshaller::append(int arg)

    89 {

    90     qIterAppend(&iterator, ba, DBUS_TYPE_INT32, &arg);

    91 }

    92 

    93 inline void QDBusMarshaller::append(uint arg)

    94 {

    95     qIterAppend(&iterator, ba, DBUS_TYPE_UINT32, &arg);

    96 }

    97 

    98 inline void QDBusMarshaller::append(qlonglong arg)

    99 {

   100     qIterAppend(&iterator, ba, DBUS_TYPE_INT64, &arg);

   101 }

   102 

   103 inline void QDBusMarshaller::append(qulonglong arg)

   104 {

   105     qIterAppend(&iterator, ba, DBUS_TYPE_UINT64, &arg);

   106 }

   107 

   108 inline void QDBusMarshaller::append(double arg)

   109 {

   110     qIterAppend(&iterator, ba, DBUS_TYPE_DOUBLE, &arg);

   111 }

   112 

   113 void QDBusMarshaller::append(const QString &arg)

   114 {

   115     QByteArray data = arg.toUtf8();

   116     const char *cdata = data.constData();

   117     qIterAppend(&iterator, ba, DBUS_TYPE_STRING, &cdata);

   118 }

   119 

   120 inline void QDBusMarshaller::append(const QDBusObjectPath &arg)

   121 {

   122     QByteArray data = arg.path().toUtf8();

   123     if (!ba && data.isEmpty())

   124         error(QLatin1String("Invalid object path passed in arguments"));

   125     const char *cdata = data.constData();

   126     qIterAppend(&iterator, ba, DBUS_TYPE_OBJECT_PATH, &cdata);

   127 }

   128 

   129 inline void QDBusMarshaller::append(const QDBusSignature &arg)

   130 {

   131     QByteArray data = arg.signature().toUtf8();

   132     if (!ba && data.isEmpty())

   133         error(QLatin1String("Invalid signature passed in arguments"));

   134     const char *cdata = data.constData();

   135     qIterAppend(&iterator, ba, DBUS_TYPE_SIGNATURE, &cdata);

   136 }

   137 

   138 inline void QDBusMarshaller::append(const QByteArray &arg)

   139 {

   140     if (ba) {

   141         *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;

   142         return;

   143     }

   144 

   145     const char* cdata = arg.constData();

   146     DBusMessageIter subiterator;

   147     q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING,

   148                                      &subiterator);

   149     q_dbus_message_iter_append_fixed_array(&subiterator, DBUS_TYPE_BYTE, &cdata, arg.length());

   150     q_dbus_message_iter_close_container(&iterator, &subiterator);

   151 }

   152 

   153 inline bool QDBusMarshaller::append(const QDBusVariant &arg)

   154 {

   155     if (ba) {

   156         *ba += DBUS_TYPE_VARIANT_AS_STRING;

   157         return true;

   158     }

   159 

   160     const QVariant &value = arg.variant();

   161     QVariant::Type id = QVariant::Type(value.userType());

   162     if (id == QVariant::Invalid) {

   163         qWarning("QDBusMarshaller: cannot add a null QDBusVariant");

   164         error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));

   165         return false;

   166     }

   167 

   168     QByteArray tmpSignature;

   169     const char *signature = 0;

   170     if (int(id) == qMetaTypeId<QDBusArgument>()) {

   171         // take the signature from the QDBusArgument object we're marshalling

   172         tmpSignature =

   173             qvariant_cast<QDBusArgument>(value).currentSignature().toLatin1();

   174         signature = tmpSignature.constData();

   175     } else {

   176         // take the signatuer from the metatype we're marshalling

   177         signature = QDBusMetaType::typeToSignature(id);

   178     }

   179     if (!signature) {

   180         qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "

   181                  "Use qDBusRegisterMetaType to register it",

   182                  QVariant::typeToName( id ), id);

   183         error(QString::fromLatin1("Unregistered type %1 passed in arguments")

   184               .arg(QLatin1String(QVariant::typeToName(id))));

   185         return false;

   186     }

   187 

   188     QDBusMarshaller sub;

   189     open(sub, DBUS_TYPE_VARIANT, signature);

   190     bool isOk = sub.appendVariantInternal(value);

   191     // don't call sub.close(): it auto-closes

   192 

   193     return isOk;

   194 }

   195 

   196 inline void QDBusMarshaller::append(const QStringList &arg)

   197 {

   198     if (ba) {

   199         *ba += DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;

   200         return;

   201     }

   202 

   203     QDBusMarshaller sub;

   204     open(sub, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING);

   205     QStringList::ConstIterator it = arg.constBegin();

   206     QStringList::ConstIterator end = arg.constEnd();

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

   208         sub.append(*it);

   209     // don't call sub.close(): it auto-closes

   210 }

   211 

   212 inline QDBusMarshaller *QDBusMarshaller::beginStructure()

   213 {

   214     return beginCommon(DBUS_TYPE_STRUCT, 0);

   215 }

   216 

   217 inline QDBusMarshaller *QDBusMarshaller::beginArray(int id)

   218 {

   219     const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) );

   220     if (!signature) {

   221         qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "

   222                  "Use qDBusRegisterMetaType to register it",

   223                  QVariant::typeToName( QVariant::Type(id) ), id);

   224         error(QString::fromLatin1("Unregistered type %1 passed in arguments")

   225               .arg(QLatin1String(QVariant::typeToName(QVariant::Type(id)))));

   226         return this;

   227     }

   228 

   229     return beginCommon(DBUS_TYPE_ARRAY, signature);

   230 }

   231 

   232 inline QDBusMarshaller *QDBusMarshaller::beginMap(int kid, int vid)

   233 {

   234     const char *ksignature = QDBusMetaType::typeToSignature( QVariant::Type(kid) );

   235     if (!ksignature) {

   236         qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "

   237                  "Use qDBusRegisterMetaType to register it",

   238                  QVariant::typeToName( QVariant::Type(kid) ), kid);

   239         error(QString::fromLatin1("Unregistered type %1 passed in arguments")

   240               .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid)))));

   241         return this;

   242     }

   243     if (ksignature[1] != 0 || !q_dbus_type_is_basic(*ksignature)) {

   244         qWarning("QDBusMarshaller: type '%s' (%d) cannot be used as the key type in a D-BUS map.",

   245                  QVariant::typeToName( QVariant::Type(kid) ), kid);

   246         error(QString::fromLatin1("Type %1 passed in arguments cannot be used as a key in a map")

   247               .arg(QLatin1String(QVariant::typeToName(QVariant::Type(kid)))));

   248         return this;

   249     }

   250 

   251     const char *vsignature = QDBusMetaType::typeToSignature( QVariant::Type(vid) );

   252     if (!vsignature) {

   253         const char *typeName = QVariant::typeToName(QVariant::Type(vid));

   254         qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "

   255                  "Use qDBusRegisterMetaType to register it",

   256                  typeName, vid);

   257         error(QString::fromLatin1("Unregistered type %1 passed in arguments")

   258               .arg(QLatin1String(typeName)));

   259         return this;

   260     }

   261 

   262     QByteArray signature;

   263     signature = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING;

   264     signature += ksignature;

   265     signature += vsignature;

   266     signature += DBUS_DICT_ENTRY_END_CHAR_AS_STRING;

   267     return beginCommon(DBUS_TYPE_ARRAY, signature);

   268 }

   269 

   270 inline QDBusMarshaller *QDBusMarshaller::beginMapEntry()

   271 {

   272     return beginCommon(DBUS_TYPE_DICT_ENTRY, 0);

   273 }

   274 

   275 void QDBusMarshaller::open(QDBusMarshaller &sub, int code, const char *signature)

   276 {

   277     sub.parent = this;

   278     sub.ba = ba;

   279     sub.ok = true;

   280 

   281     if (ba)

   282         switch (code) {

   283         case DBUS_TYPE_ARRAY:

   284             *ba += char(code);

   285             *ba += signature;

   286             // fall through

   287 

   288         case DBUS_TYPE_DICT_ENTRY:

   289             sub.closeCode = 0;

   290             break;

   291 

   292         case DBUS_TYPE_STRUCT:

   293             *ba += DBUS_STRUCT_BEGIN_CHAR;

   294             sub.closeCode = DBUS_STRUCT_END_CHAR;

   295             break;

   296         }

   297     else

   298         q_dbus_message_iter_open_container(&iterator, code, signature, &sub.iterator);

   299 }

   300 

   301 QDBusMarshaller *QDBusMarshaller::beginCommon(int code, const char *signature)

   302 {

   303     QDBusMarshaller *d = new QDBusMarshaller;

   304     open(*d, code, signature);

   305     return d;

   306 }

   307 

   308 inline QDBusMarshaller *QDBusMarshaller::endStructure()

   309 { return endCommon(); }

   310 

   311 inline QDBusMarshaller *QDBusMarshaller::endArray()

   312 { return endCommon(); }

   313 

   314 inline QDBusMarshaller *QDBusMarshaller::endMap()

   315 { return endCommon(); }

   316 

   317 inline QDBusMarshaller *QDBusMarshaller::endMapEntry()

   318 { return endCommon(); }

   319 

   320 QDBusMarshaller *QDBusMarshaller::endCommon()

   321 {

   322     QDBusMarshaller *retval = parent;

   323     delete this;

   324     return retval;

   325 }

   326 

   327 void QDBusMarshaller::close()

   328 {

   329     if (ba) {

   330         if (closeCode)

   331             *ba += closeCode;

   332     } else if (parent) {

   333         q_dbus_message_iter_close_container(&parent->iterator, &iterator);

   334     }

   335 }

   336 

   337 void QDBusMarshaller::error(const QString &msg)

   338 {

   339     ok = false;

   340     if (parent)

   341         parent->error(msg);

   342     else

   343         errorString = msg;

   344 }

   345 

   346 bool QDBusMarshaller::appendVariantInternal(const QVariant &arg)

   347 {

   348     int id = arg.userType();

   349     if (id == QVariant::Invalid) {

   350         qWarning("QDBusMarshaller: cannot add an invalid QVariant");

   351         error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));

   352         return false;

   353     }

   354 

   355     // intercept QDBusArgument parameters here

   356     if (id == qMetaTypeId<QDBusArgument>()) {

   357         QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg);

   358         QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument);

   359         if (!d->message)

   360             return false;       // can't append this one...

   361 

   362         QDBusDemarshaller demarshaller;

   363         demarshaller.message = q_dbus_message_ref(d->message);

   364 

   365         if (d->direction == Demarshalling) {

   366             // it's demarshalling; just copy

   367             demarshaller.iterator = static_cast<QDBusDemarshaller *>(d)->iterator;

   368         } else {

   369             // it's marshalling; start over

   370             if (!q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))

   371                 return false;   // error!

   372         }

   373 

   374         return appendCrossMarshalling(&demarshaller);

   375     }

   376 

   377     const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) );

   378     if (!signature) {

   379         qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "

   380                  "Use qDBusRegisterMetaType to register it",

   381                  QVariant::typeToName( QVariant::Type(id) ), id);

   382         error(QString::fromLatin1("Unregistered type %1 passed in arguments")

   383               .arg(QLatin1String(QVariant::typeToName(QVariant::Type(id)))));

   384         return false;

   385     }

   386 

   387     switch (*signature) {

   388 #ifdef __OPTIMIZE__

   389     case DBUS_TYPE_BYTE:

   390     case DBUS_TYPE_BOOLEAN:

   391     case DBUS_TYPE_INT16:

   392     case DBUS_TYPE_UINT16:

   393     case DBUS_TYPE_INT32:

   394     case DBUS_TYPE_UINT32:

   395     case DBUS_TYPE_INT64:

   396     case DBUS_TYPE_UINT64:

   397     case DBUS_TYPE_DOUBLE:

   398         qIterAppend(&iterator, ba, *signature, arg.constData());

   399         return true;

   400 #else

   401     case DBUS_TYPE_BYTE:

   402         append( qvariant_cast<uchar>(arg) );

   403         return true;

   404     case DBUS_TYPE_BOOLEAN:

   405         append( arg.toBool() );

   406         return true;

   407     case DBUS_TYPE_INT16:

   408         append( qvariant_cast<short>(arg) );

   409         return true;

   410     case DBUS_TYPE_UINT16:

   411         append( qvariant_cast<ushort>(arg) );

   412         return true;

   413     case DBUS_TYPE_INT32:

   414         append( static_cast<dbus_int32_t>(arg.toInt()) );

   415         return true;

   416     case DBUS_TYPE_UINT32:

   417         append( static_cast<dbus_uint32_t>(arg.toUInt()) );

   418         return true;

   419     case DBUS_TYPE_INT64:

   420         append( arg.toLongLong() );

   421         return true;

   422     case DBUS_TYPE_UINT64:

   423         append( arg.toULongLong() );

   424         return true;

   425     case DBUS_TYPE_DOUBLE:

   426         append( arg.toDouble() );

   427         return true;

   428 #endif

   429 

   430     case DBUS_TYPE_STRING:

   431         append( arg.toString() );

   432         return true;

   433     case DBUS_TYPE_OBJECT_PATH:

   434         append( qvariant_cast<QDBusObjectPath>(arg) );

   435         return true;

   436     case DBUS_TYPE_SIGNATURE:

   437         append( qvariant_cast<QDBusSignature>(arg) );

   438         return true;

   439 

   440     // compound types:

   441     case DBUS_TYPE_VARIANT:

   442         // nested QVariant

   443         return append( qvariant_cast<QDBusVariant>(arg) );

   444 

   445     case DBUS_TYPE_ARRAY:

   446         // could be many things

   447         // find out what kind of array it is

   448         switch (arg.type()) {

   449         case QVariant::StringList:

   450             append( arg.toStringList() );

   451             return true;

   452 

   453         case QVariant::ByteArray:

   454             append( arg.toByteArray() );

   455             return true;

   456 

   457         default:

   458             ;                   // fall through

   459         }

   460         // fall through

   461 

   462     case DBUS_TYPE_STRUCT:

   463     case DBUS_STRUCT_BEGIN_CHAR:

   464         return appendRegisteredType( arg );

   465 

   466     case DBUS_TYPE_DICT_ENTRY:

   467     case DBUS_DICT_ENTRY_BEGIN_CHAR:

   468         qFatal("QDBusMarshaller::appendVariantInternal got a DICT_ENTRY!");

   469         return false;

   470 

   471     default:

   472         qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'",

   473                  signature);

   474         return false;

   475     }

   476 

   477     return true;

   478 }

   479 

   480 bool QDBusMarshaller::appendRegisteredType(const QVariant &arg)

   481 {

   482     ref.ref();                  // reference up

   483     QDBusArgument self(QDBusArgumentPrivate::create(this));

   484     return QDBusMetaType::marshall(self, arg.userType(), arg.constData());

   485 }

   486 

   487 bool QDBusMarshaller::appendCrossMarshalling(QDBusDemarshaller *demarshaller)

   488 {

   489     int code = q_dbus_message_iter_get_arg_type(&demarshaller->iterator);

   490     if (q_dbus_type_is_basic(code)) {

   491         // easy: just append

   492         // do exactly like the D-BUS docs suggest

   493         // (see apidocs for q_dbus_message_iter_get_basic)

   494 

   495         qlonglong value;

   496         q_dbus_message_iter_get_basic(&demarshaller->iterator, &value);

   497         q_dbus_message_iter_next(&demarshaller->iterator);

   498         q_dbus_message_iter_append_basic(&iterator, code, &value);

   499         return true;

   500     }

   501 

   502     if (code == DBUS_TYPE_ARRAY) {

   503         int element = q_dbus_message_iter_get_element_type(&demarshaller->iterator);

   504         if (q_dbus_type_is_fixed(element)) {

   505             // another optimisation: fixed size arrays

   506             // code is exactly like QDBusDemarshaller::toByteArray

   507             DBusMessageIter sub;

   508             q_dbus_message_iter_recurse(&demarshaller->iterator, &sub);

   509             q_dbus_message_iter_next(&demarshaller->iterator);

   510             int len;

   511             void* data;

   512             q_dbus_message_iter_get_fixed_array(&sub,&data,&len);

   513 

   514             char signature[2] = { element, 0 };

   515             q_dbus_message_iter_open_container(&iterator, DBUS_TYPE_ARRAY, signature, &sub);

   516             q_dbus_message_iter_append_fixed_array(&sub, element, &data, len);

   517             q_dbus_message_iter_close_container(&iterator, &sub);

   518 

   519             return true;

   520         }

   521     }

   522 

   523     // We have to recurse

   524     QDBusDemarshaller *drecursed = demarshaller->beginCommon();

   525 

   526     QDBusMarshaller mrecursed;  // create on the stack makes it autoclose

   527     QByteArray subSignature;

   528     const char *sig = 0;

   529     if (code == DBUS_TYPE_VARIANT || code == DBUS_TYPE_ARRAY) {

   530         subSignature = drecursed->currentSignature().toLatin1();

   531         if (!subSignature.isEmpty())

   532             sig = subSignature.constData();

   533     }

   534     open(mrecursed, code, sig);

   535 

   536     while (!drecursed->atEnd()) {

   537         if (!mrecursed.appendCrossMarshalling(drecursed)) {

   538             delete drecursed;

   539             return false;

   540         }

   541     }

   542 

   543     delete drecursed;

   544     return true;

   545 }

   546 

   547 QT_END_NAMESPACE