#include <qdbusmessage_p.h>

Public Functions
	QDBusMessagePrivate ()

	~QDBusMessagePrivate ()

Static Public Functions
static QDBusMessage	fromDBusMessage (DBusMessage *dmsg, QDBusConnection::ConnectionCapabilities capabilities)
	Constructs a QDBusMessage by parsing the given DBusMessage object. More...

static bool	isLocal (const QDBusMessage &msg)

static QDBusMessage	makeLocal (const QDBusConnectionPrivate &conn, const QDBusMessage &asSent)

static QDBusMessage	makeLocalReply (const QDBusConnectionPrivate &conn, const QDBusMessage &asSent)

static void	setParametersValidated (QDBusMessage &msg, bool enable)

static DBusMessage *	toDBusMessage (const QDBusMessage &message, QDBusConnection::ConnectionCapabilities capabilities, QDBusError *error)
	Constructs a DBusMessage object from message. More...

Public Variables
QList< QVariant >	arguments

uint	autoStartService: 1

uint	delayedReply: 1

QString	interface

uint	localMessage: 1

QDBusMessage *	localReply

QString	message

DBusMessage *	msg

QString	name

uint	parametersValidated: 1

QString	path

QAtomicInt	ref

DBusMessage *	reply

QString	service

QString	signature

int	timeout

int	type

Detailed Description

Definition at line 69 of file qdbusmessage_p.h.

Constructors and Destructors

◆ QDBusMessagePrivate()

QDBusMessagePrivate::QDBusMessagePrivate ( )

Definition at line 65 of file qdbusmessage.cpp.

Referenced by QDBusMessage::QDBusMessage().

     : msg(0), reply(0), type(DBUS_MESSAGE_TYPE_INVALID),
       timeout(-1), localReply(0), ref(1), delayedReply(false), localMessage(false),
       parametersValidated(false), autoStartService(true)
 {
 }

◆ ~QDBusMessagePrivate()

QDBusMessagePrivate::~QDBusMessagePrivate ( )

Definition at line 72 of file qdbusmessage.cpp.

 {
     if (msg)
         q_dbus_message_unref(msg);
     if (reply)
         q_dbus_message_unref(reply);
     delete localReply;
 }

Functions

◆ fromDBusMessage()

QDBusMessage QDBusMessagePrivate::fromDBusMessage	(	DBusMessage *	dmsg,
		QDBusConnection::ConnectionCapabilities	capabilities
	)

static

Constructs a QDBusMessage by parsing the given DBusMessage object.

Warning: This function is not part of the public interface.

Definition at line 235 of file qdbusmessage.cpp.

Referenced by makeLocal(), QDBusConnectionPrivate::processFinishedCall(), qDBusSignalFilter(), QDBusConnectionPrivate::sendWithReply(), and setParametersValidated().

 {
     QDBusMessage message;
     if (!dmsg)
         return message;
 
     message.d_ptr->type = q_dbus_message_get_type(dmsg);
     message.d_ptr->path = QString::fromUtf8(q_dbus_message_get_path(dmsg));
     message.d_ptr->interface = QString::fromUtf8(q_dbus_message_get_interface(dmsg));
     message.d_ptr->name = message.d_ptr->type == DBUS_MESSAGE_TYPE_ERROR ?
                       QString::fromUtf8(q_dbus_message_get_error_name(dmsg)) :
                       QString::fromUtf8(q_dbus_message_get_member(dmsg));
     message.d_ptr->service = QString::fromUtf8(q_dbus_message_get_sender(dmsg));
     message.d_ptr->signature = QString::fromUtf8(q_dbus_message_get_signature(dmsg));
     message.d_ptr->msg = q_dbus_message_ref(dmsg);
 
     QDBusDemarshaller demarshaller(capabilities);
     demarshaller.message = q_dbus_message_ref(dmsg);
     if (q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))
         while (!demarshaller.atEnd())
             message << demarshaller.toVariantInternal();
     return message;
 }

◆ isLocal()

bool QDBusMessagePrivate::isLocal ( const QDBusMessage & msg )

static

Definition at line 259 of file qdbusmessage.cpp.

Referenced by QDBusConnectionPrivate::handleObjectCall(), QDBusConnectionPrivate::send(), and setParametersValidated().

 {
     return message.d_ptr->localMessage;
 }

◆ makeLocal()

QDBusMessage QDBusMessagePrivate::makeLocal	(	const QDBusConnectionPrivate &	conn,
		const QDBusMessage &	asSent
	)

static

Definition at line 264 of file qdbusmessage.cpp.

Referenced by makeLocalReply(), QDBusConnectionPrivate::sendWithReplyLocal(), and setParametersValidated().

 {
     // simulate the message being sent to the bus and then received back
     // the only field that the bus sets when delivering the message
     // (as opposed to the message as we send it), is the sender
     // so we simply set the sender to our unique name
 
     // determine if we are carrying any complex types
     QString computedSignature;
     QVariantList::ConstIterator it = asSent.d_ptr->arguments.constBegin();
     QVariantList::ConstIterator end = asSent.d_ptr->arguments.constEnd();
     for ( ; it != end; ++it) {
         int id = it->userType();
         const char *signature = QDBusMetaType::typeToSignature(id);
         if ((id != QVariant::StringList && id != QVariant::ByteArray &&
              qstrlen(signature) != 1) || id == qMetaTypeId<QDBusVariant>()) {
             // yes, we are
             // we must marshall and demarshall again so as to create QDBusArgument
             // entries for the complex types
             QDBusError error;
             DBusMessage *message = toDBusMessage(asSent, conn.capabilities, &error);
             if (!message) {
                 // failed to marshall, so it's a call error
                 return QDBusMessage::createError(error);
             }
 
             q_dbus_message_set_sender(message, conn.baseService.toUtf8());
 
             QDBusMessage retval = fromDBusMessage(message, conn.capabilities);
             retval.d_ptr->localMessage = true;
             q_dbus_message_unref(message);
             if (retval.d_ptr->service.isEmpty())
                 retval.d_ptr->service = conn.baseService;
             return retval;
         } else {
             computedSignature += QLatin1String(signature);
         }
     }
 
     // no complex types seen
     // optimize by using the variant list itself
     QDBusMessage retval;
     QDBusMessagePrivate *d = retval.d_ptr;
     d->arguments = asSent.d_ptr->arguments;
     d->path = asSent.d_ptr->path;
     d->interface = asSent.d_ptr->interface;
     d->name = asSent.d_ptr->name;
     d->message = asSent.d_ptr->message;
     d->type = asSent.d_ptr->type;
 
     d->service = conn.baseService;
     d->signature = computedSignature;
     d->localMessage = true;
     return retval;
 }

◆ makeLocalReply()

QDBusMessage QDBusMessagePrivate::makeLocalReply	(	const QDBusConnectionPrivate &	conn,
		const QDBusMessage &	asSent
	)

static

Definition at line 321 of file qdbusmessage.cpp.

Referenced by QDBusConnectionPrivate::sendWithReplyLocal(), and setParametersValidated().

 {
     // simulate the reply (return or error) message being sent to the bus and
     // then received back.
     if (callMsg.d_ptr->localReply)
         return makeLocal(conn, *callMsg.d_ptr->localReply);
     return QDBusMessage();      // failed
 }

◆ setParametersValidated()

static void QDBusMessagePrivate::setParametersValidated	(	QDBusMessage &	msg,
		bool	enable
	)

inlinestatic

Definition at line 93 of file qdbusmessage_p.h.

Referenced by QDBusAbstractInterface::asyncCallWithArgumentList(), QDBusAbstractInterface::callWithArgumentList(), QDBusAbstractInterface::callWithCallback(), QDBusConnectionPrivate::findMetaObject(), QDBusConnectionPrivate::getNameOwnerNoCache(), QDBusAbstractInterfacePrivate::property(), QDBusConnectionPrivate::relaySignal(), and QDBusAbstractInterfacePrivate::setProperty().

94 { msg.d_ptr->parametersValidated = enable; }

QDBusMessage::d_ptr

QDBusMessagePrivate * d_ptr

Definition: qdbusmessage.h:119

QDBusMessagePrivate::parametersValidated

uint parametersValidated

Definition: qdbusmessage_p.h:90

◆ toDBusMessage()

DBusMessage * QDBusMessagePrivate::toDBusMessage	(	const QDBusMessage &	message,
		QDBusConnection::ConnectionCapabilities	capabilities,
		QDBusError *	error
	)

static

Constructs a DBusMessage object from message.

Warning: This function is not part of the public interface. The returned value must be de-referenced with q_dbus_message_unref. The capabilities flags indicates which capabilities to use.

The error object is set to indicate the error if anything went wrong with the marshalling. Usually, this error message will be placed in the reply, as if the call failed. The error pointer must not be null.

Definition at line 111 of file qdbusmessage.cpp.

Referenced by makeLocal(), QDBusConnectionPrivate::relaySignal(), QDBusConnectionPrivate::send(), QDBusConnectionPrivate::sendWithReply(), QDBusConnectionPrivate::sendWithReplyAsync(), and setParametersValidated().

 {
     if (!qdbus_loadLibDBus()) {
         *error = QDBusError(QDBusError::Failed, QLatin1String("Could not open lidbus-1 library"));
         return 0;
     }
 
     DBusMessage *msg = 0;
     const QDBusMessagePrivate *d_ptr = message.d_ptr;
 
     switch (d_ptr->type) {
     case DBUS_MESSAGE_TYPE_INVALID:
         //qDebug() << "QDBusMessagePrivate::toDBusMessage" <<  "message is invalid";
         break;
     case DBUS_MESSAGE_TYPE_METHOD_CALL:
         // only service and interface can be empty -> path and name must not be empty
         if (!d_ptr->parametersValidated) {
             if (!QDBusUtil::checkBusName(d_ptr->service, QDBusUtil::EmptyAllowed, error))
                 return 0;
             if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error))
                 return 0;
             if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error))
                 return 0;
             if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method"))
                 return 0;
         }
 
         msg = q_dbus_message_new_method_call(data(d_ptr->service.toUtf8()), d_ptr->path.toUtf8(),
                                              data(d_ptr->interface.toUtf8()), d_ptr->name.toUtf8());
         q_dbus_message_set_auto_start( msg, d_ptr->autoStartService );
         break;
     case DBUS_MESSAGE_TYPE_METHOD_RETURN:
         msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
         if (!d_ptr->localMessage) {
             q_dbus_message_set_destination(msg, q_dbus_message_get_sender(d_ptr->reply));
             q_dbus_message_set_reply_serial(msg, q_dbus_message_get_serial(d_ptr->reply));
         }
         break;
     case DBUS_MESSAGE_TYPE_ERROR:
         // error name can't be empty
         if (!d_ptr->parametersValidated
             && !QDBusUtil::checkErrorName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error))
             return 0;
 
         msg = q_dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
         q_dbus_message_set_error_name(msg, d_ptr->name.toUtf8());
         if (!d_ptr->localMessage) {
             q_dbus_message_set_destination(msg, q_dbus_message_get_sender(d_ptr->reply));
             q_dbus_message_set_reply_serial(msg, q_dbus_message_get_serial(d_ptr->reply));
         }
         break;
     case DBUS_MESSAGE_TYPE_SIGNAL:
         // nothing can be empty here
         if (!d_ptr->parametersValidated) {
             if (!QDBusUtil::checkObjectPath(d_ptr->path, QDBusUtil::EmptyNotAllowed, error))
                 return 0;
             if (!QDBusUtil::checkInterfaceName(d_ptr->interface, QDBusUtil::EmptyAllowed, error))
                 return 0;
             if (!QDBusUtil::checkMemberName(d_ptr->name, QDBusUtil::EmptyNotAllowed, error, "method"))
                 return 0;
         }
 
         msg = q_dbus_message_new_signal(d_ptr->path.toUtf8(), d_ptr->interface.toUtf8(),
                                         d_ptr->name.toUtf8());
         break;
     default:
         Q_ASSERT(false);
         break;
     }
 
     // if we got here, the parameters validated
     // and since the message parameters cannot be changed once the message is created
     // we can record this fact
     d_ptr->parametersValidated = true;
 
     QDBusMarshaller marshaller(capabilities);
     QVariantList::ConstIterator it =  d_ptr->arguments.constBegin();
     QVariantList::ConstIterator cend = d_ptr->arguments.constEnd();
     q_dbus_message_iter_init_append(msg, &marshaller.iterator);
     if (!d_ptr->message.isEmpty())
         // prepend the error message
         marshaller.append(d_ptr->message);
     for ( ; it != cend; ++it)
         marshaller.appendVariantInternal(*it);
 
     // check if everything is ok
     if (marshaller.ok)
         return msg;
 
     // not ok;
     q_dbus_message_unref(msg);
     *error = QDBusError(QDBusError::Failed, QLatin1String("Marshalling failed: ") + marshaller.errorString);
     return 0;
 }